Add port binding support and example for container scripts

.vscode/settings.json

@@ -25,6 +25,7 @@
         "gptool",
         "gptools",
         "gptoolsjs",
+        "hostpath",
         "limitrows",
         "llmify",
         "llmrequest",
@@ -41,12 +42,15 @@
         "promptfoo",
         "prompty",
         "quoteify",
+        "socketserver",
         "stringifying",
         "sysr",
         "tabletojson",
         "treesitter",
         "typecheck",
         "unfence",
+        "urllib",
+        "urlparse",
         "vsix",
         "xpai"
     ],

docs/src/content/docs/reference/scripts/container.md

@@ -56,6 +56,25 @@ You can enable network access using `networkEnabled`.
 const container = await host.container({ networkEnabled: true })
 ```
 
+### Port bindings
+
+You can bind container ports to host ports and access web servers running in the container.
+
+For example, this configuration will map the host `8088` port to `80` on the container
+and you will be able to access a local web server using `http://localhost:8088/`.
+
+```js
+const container = await host.container({
+    networkEnabled: true,
+    ports: {
+        containerPort: "80/tcp",
+        hostPort: "8088",
+    },
+})
+```
+
+Then
+
 ## Run a command
 
 You can run a command in the container using the `exec` method. It returns the exit code, standard output and error streams.

packages/cli/src/docker.ts

@@ -11,9 +11,15 @@ import { randomHex } from "../../core/src/crypto"
 import { errorMessage } from "../../core/src/error"
 import { host } from "../../core/src/host"
 import { TraceOptions } from "../../core/src/trace"
-import { logError, dotGenaiscriptPath, logVerbose } from "../../core/src/util"
+import {
+    logError,
+    dotGenaiscriptPath,
+    logVerbose,
+    arrayify,
+} from "../../core/src/util"
 import { CORE_VERSION } from "../../core/src/version"
 import { isQuiet } from "./log"
+import Dockerode from "dockerode"
 
 type DockerodeType = import("dockerode")
 
@@ -127,6 +133,7 @@ export class DockerManager {
             networkEnabled,
             name,
         } = options
+        const ports = arrayify(options.ports)
         try {
             trace?.startDetails(`📦 container start ${image}`)
             await this.pullImage(image, { trace })
@@ -139,9 +146,10 @@ export class DockerManager {
                 )
             )
             await ensureDir(hostPath)
-            const containerPath = DOCKER_CONTAINER_VOLUME
 
-            const container = await this._docker.createContainer({
+            const containerPath = DOCKER_CONTAINER_VOLUME
+            logVerbose(`container: create ${image} ${name ?? ""}`)
+            const containerOptions: Dockerode.ContainerCreateOptions = {
                 name,
                 Image: image,
                 AttachStdin: false,
@@ -162,10 +170,28 @@ export class DockerManager {
                         ? key
                         : `${key}=${value}`
                 ),
+                ExposedPorts: ports.reduce(
+                    (acc, { containerPort }) => {
+                        acc[containerPort] = {}
+                        return acc
+                    },
+                    <Record<string, any>>{}
+                ),
                 HostConfig: {
                     Binds: [`${hostPath}:${containerPath}`],
+                    PortBindings: ports?.reduce(
+                        (acc, { containerPort, hostPort }) => {
+                            acc[containerPort] = [
+                                { HostPort: String(hostPort) },
+                            ]
+                            return acc
+                        },
+                        <Record<string, { HostPort: string }[]>>{}
+                    ),
                 },
-            })
+            }
+            const container =
+                await this._docker.createContainer(containerOptions)
             trace?.itemValue(`id`, container.id)
             trace?.itemValue(`host path`, hostPath)
             trace?.itemValue(`container path`, containerPath)

packages/core/src/types/prompt_template.d.ts

@@ -2212,6 +2212,11 @@ interface ShellHost {
     confirm(message: string, options?: ShellConfirmOptions): Promise<boolean>
 }
 
+interface ContainerPortBinding {
+    containerPort: string
+    hostPort: string | number
+}
+
 interface ContainerOptions {
     /**
      * Container image names.
@@ -2239,6 +2244,11 @@ interface ContainerOptions {
      * Disable automatic purge of container and volume directory
      */
     disablePurge?: boolean
+
+    /**
+     * List of exposed TCP ports
+     */
+    ports?: ElementOrArray<ContainerPortBinding>
 }
 
 interface PromptHost extends ShellHost {

packages/sample/genaisrc/container-web.genai.mjs

@@ -0,0 +1,55 @@
+script({
+    model: "gpt-3.5-turbo",
+})
+
+const disablePurge = env.vars.purge === "no"
+
+// start web server
+const hostPort = 8089
+const webContainer = await host.container({
+    disablePurge,
+    networkEnabled: true,
+    ports: { containerPort: "80/tcp", hostPort },
+})
+await webContainer.writeText(
+    "main.py",
+    `
+import http.server
+import socketserver
+import urllib.parse
+
+PORT = 80
+
+class CustomHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        parsed_path = urllib.parse.urlparse(self.path)
+        if parsed_path.path == '/echo':
+            query = urllib.parse.parse_qs(parsed_path.query)
+            message = query.get('message', [''])[0]
+            self.send_response(200)
+            self.send_header('Content-type', 'text/plain')
+            self.end_headers()
+            self.wfile.write(message.encode())
+        else:
+            super().do_GET()
+
+with socketserver.TCPServer(("", PORT), CustomHandler) as httpd:
+    print(f"Serving at port {PORT}")
+    httpd.serve_forever()
+`
+)
+webContainer.exec("python", ["main.py"]) // don't await
+await sleep(1000) // wait for server to start
+const msg = Math.random().toString()
+const url = `http://localhost:${hostPort}/echo?message=` + msg
+console.log(`fetching ${url} with msg ${msg}`)
+const res = await fetch(url)
+console.log(res.status)
+const text = await res.text()
+console.log(text)
+if (text !== msg) throw new Error(`expected ${msg}, got ${text} instead`)
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+}
+