@volter/browser-sandboxes 0.1.4 → 0.1.6

package/dist/client.js

@@ -1,64 +1,132 @@
-// A remote runtime client with the same method shape as the in-page runtime.
-// Differences forced by the wire: ports() and the file surface are async.
-// Browser-safe: no Node globals, so a tab can drive a hosted sandbox with it.
-// The client negotiates the agent's descriptor before it trusts the wire and
-// states the protocol it speaks on every request.
-import { SUBSTRATE_AGENT_PROTOCOL, SUBSTRATE_PROTOCOL_BASE_PATH, SUBSTRATE_PROTOCOL_HEADER, hostedProtocolHeader, negotiateHostedProtocol, } from "@volter/browser-runtime/browser-hosted-protocol.js";
-/** A fresh ArrayBuffer copy satisfies the fetch body type for any typed array. */
+// A client of the container's wire (ADR-0026): Docker's Engine API, the
+// named subset, over fetch and a WebSocket, with the in-page runtime's method
+// names so a tab drives a hosted container the way it drives its own. Where
+// Docker's API lacks a thing the transfer needs, the client speaks the row
+// the daemon names: a port through the daemon, an event stream, a file
+// listing and removal, and an archive `exclude`, `replace` and `strip`.
+// Browser-safe: no Node globals.
+import { DOCKER_ENGINE_BASE_PATH, multiplexFrame } from "@volter/browser-runtime/docker-engine.js";
+import { packTar, unpackTar } from "@volter/browser-runtime/browser-tar.js";
+const KILL_CLOSE_CODE = 4001;
 function toBody(data) {
-    return typeof data === "string" ? data : data.slice().buffer;
+    return typeof data === "string" ? data : new Uint8Array(data).buffer;
+}
+function dirname(path) { const index = path.lastIndexOf("/"); return index <= 0 ? "/" : path.slice(0, index); }
+function basename(path) { return path.slice(path.lastIndexOf("/") + 1); }
+/** Splits Docker's multiplexed stream into stdout and stderr chunks, across message boundaries. */
+class FrameParser {
+    onFrame;
+    buffered = new Uint8Array(0);
+    constructor(onFrame) {
+        this.onFrame = onFrame;
+    }
+    push(bytes) {
+        const joined = new Uint8Array(this.buffered.byteLength + bytes.byteLength);
+        joined.set(this.buffered);
+        joined.set(bytes, this.buffered.byteLength);
+        let offset = 0;
+        while (joined.byteLength - offset >= 8) {
+            const size = new DataView(joined.buffer, joined.byteOffset + offset).getUint32(4, false);
+            if (joined.byteLength - offset < 8 + size)
+                break;
+            this.onFrame(joined[offset], joined.subarray(offset + 8, offset + 8 + size));
+            offset += 8 + size;
+        }
+        this.buffered = joined.slice(offset);
+    }
 }
 export class RemoteRuntime {
     files;
     base;
-    /** The catalogue's base path, from the negotiated descriptor; /v1 until then. */
-    basePath = SUBSTRATE_PROTOCOL_BASE_PATH;
-    /** The agent's descriptor once negotiated. */
-    descriptor;
     token;
     network;
+    makeSocket;
     listeners = new Map();
-    outputs = new Map();
-    pending = new Map();
     abort = new AbortController();
+    /** The one container this daemon holds, known after `connect`. */
+    containerId;
+    startedAt = Date.now();
     constructor(baseUrl, token, options = {}) {
         this.base = baseUrl.replace(/\/$/, "");
         this.token = token;
         this.network = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.makeSocket = options.socket ?? ((url) => new WebSocket(url));
         this.files = {
-            read: async (p) => new Uint8Array(await (await this.ok(await this.call(`/fs/read?path=${encodeURIComponent(p)}`))).arrayBuffer()),
+            read: async (p) => {
+                const entries = unpackTar(new Uint8Array(await (await this.ok(await this.call(`${this.container}/archive?path=${encodeURIComponent(p)}`))).arrayBuffer()));
+                const file = entries.find((entry) => entry.type === "file");
+                if (!file)
+                    throw new Error(`${p} is not a file`);
+                return file.data ?? new Uint8Array(0);
+            },
             readText: async (p) => new TextDecoder().decode(await this.files.read(p)),
-            write: async (p, data) => this.json(await this.call(`/fs/write?path=${encodeURIComponent(p)}`, { method: "PUT", body: toBody(data) })),
-            list: async (p) => this.json(await this.call(`/fs/list?path=${encodeURIComponent(p)}`)),
-            mkdir: async (p) => this.json(await this.call(`/fs/mkdir?path=${encodeURIComponent(p)}`, { method: "POST" })),
-            remove: async (p) => this.json(await this.call(`/fs/remove?path=${encodeURIComponent(p)}`, { method: "DELETE" })),
-            snapshot: async () => this.json(await this.call("/fs/snapshot")),
-            export: async (root = "/workspace", format = "zip", options = {}) => {
+            write: async (p, data) => {
+                const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+                const tar = packTar([{ path: basename(p), type: "file", mode: 0o644, mtime: Math.floor(Date.now() / 1000), data: bytes }]);
+                await this.files.mkdir(dirname(p));
+                await this.ok(await this.call(`${this.container}/archive?path=${encodeURIComponent(dirname(p))}`, { method: "PUT", headers: { "content-type": "application/x-tar" }, body: toBody(tar) }));
+                return { ok: true };
+            },
+            list: async (p) => (await this.json(await this.call(`${this.container}/files?path=${encodeURIComponent(p)}`))).map(({ name, type, size }) => ({ name, type, size })),
+            mkdir: async (p) => {
+                // A directory is made by extracting one into its parent, parent by parent from the root down.
+                const parts = p.split("/").filter(Boolean);
+                for (let depth = 1; depth <= parts.length; depth += 1) {
+                    const parent = `/${parts.slice(0, depth - 1).join("/")}`;
+                    const name = parts[depth - 1];
+                    const listed = await this.files.list(parent).catch(() => []);
+                    if (listed.some((entry) => entry.name === name))
+                        continue;
+                    const tar = packTar([{ path: name, type: "directory", mode: 0o755, mtime: Math.floor(Date.now() / 1000) }]);
+                    await this.ok(await this.call(`${this.container}/archive?path=${encodeURIComponent(parent)}`, { method: "PUT", headers: { "content-type": "application/x-tar" }, body: toBody(tar) }));
+                }
+                return { ok: true };
+            },
+            remove: async (p) => { await this.ok(await this.call(`${this.container}/files?path=${encodeURIComponent(p)}`, { method: "DELETE" })); return { ok: true }; },
+            export: async (root = "/workspace", _format = "tar", options = {}) => {
                 const exclude = options.exclude?.length ? `&exclude=${encodeURIComponent(options.exclude.join(","))}` : "";
-                const response = await this.ok(await this.call(`/fs/export?root=${encodeURIComponent(root)}&format=${format}${exclude}`));
+                const response = await this.ok(await this.call(`${this.container}/archive?path=${encodeURIComponent(root)}${exclude}`));
                 return {
-                    format,
+                    format: "tar",
                     bytes: new Uint8Array(await response.arrayBuffer()),
                     integrity: response.headers.get("x-substrate-integrity"),
                     entries: Number(response.headers.get("x-substrate-entries")),
                     fileBytes: Number(response.headers.get("x-substrate-file-bytes")),
                 };
             },
-            import: async (bytes, { root = "/workspace", replace = true } = {}) => this.json(await this.call(`/fs/import?root=${encodeURIComponent(root)}&replace=${replace}`, { method: "POST", body: toBody(bytes) })),
+            import: async (bytes, { root = "/workspace", replace = true } = {}) => {
+                await this.files.mkdir(root);
+                // The archive's top entry is the tree's own name; `strip=1` lands its contents in `root`.
+                const summary = await this.json(await this.call(`${this.container}/archive?path=${encodeURIComponent(root)}&replace=${replace}&strip=1`, { method: "PUT", headers: { "content-type": "application/x-tar" }, body: toBody(bytes) }));
+                return { format: "tar", ...summary };
+            },
         };
     }
+    get container() {
+        if (!this.containerId)
+            throw new Error("connect() first: the container is not known yet.");
+        return `/containers/${this.containerId}`;
+    }
     /**
-     * Negotiates the agent's protocol, then opens the event stream and returns
-     * the agent's health. A server speaking another protocol or version is
-     * refused with the reason.
+     * Pings the daemon, finds its one container, opens the event stream, and
+     * returns the container's health. A server that is not a Docker daemon of
+     * ours is refused with its status.
      */
     async connect() {
-        await this.negotiate();
-        const response = await this.call("/events", { signal: this.abort.signal });
-        await this.ok(response);
-        if (response.body)
-            void this.consume(response.body);
-        return this.json(await this.call("/health"));
+        const ping = await this.call("/_ping");
+        if (!ping.ok)
+            throw new Error(`${this.base} did not answer Docker's ping: ${ping.status} ${await ping.text().catch(() => "")}`);
+        const containers = await this.json(await this.call("/containers/json"));
+        const first = containers[0];
+        if (!first)
+            throw new Error(`${this.base} holds no container.`);
+        this.containerId = first.Id;
+        this.startedAt = first.Created * 1000;
+        const events = await this.call(`${this.container}/events`, { signal: this.abort.signal });
+        await this.ok(events);
+        if (events.body)
+            void this.consume(events.body);
+        return this.health();
     }
     async consume(body) {
         const decoder = new TextDecoder();
@@ -86,26 +154,7 @@ export class RemoteRuntime {
         }
     }
     dispatch(event) {
-        const type = String(event.type);
-        if (type === "pty-output" || type === "pty-exit") {
-            const key = `pty:${String(event.id)}`;
-            const sink = this.outputs.get(key);
-            if (sink)
-                sink(event);
-            else
-                this.pending.set(key, [...(this.pending.get(key) ?? []), event]);
-            return;
-        }
-        if (type === "output") {
-            const key = Number(event.pid);
-            const sink = this.outputs.get(key);
-            if (sink)
-                sink(event);
-            else
-                this.pending.set(key, [...(this.pending.get(key) ?? []), event]);
-            return;
-        }
-        for (const listener of this.listeners.get(type) ?? [])
+        for (const listener of this.listeners.get(String(event.type)) ?? [])
             listener(event);
     }
     on(type, listener) {
@@ -114,77 +163,158 @@ export class RemoteRuntime {
         this.listeners.set(type, set);
         return () => { set.delete(listener); };
     }
-    async start(command, options = {}) {
-        if (options.terminal)
-            return this.startTerminalProcess(command, options);
-        const { onStdout, onStderr, cwd, env, stdin } = options;
-        const started = await this.json(await this.call("/processes", {
+    async execCreate(cmd, options) {
+        const created = await this.json(await this.call(`${this.container}/exec`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ command, cwd, env, stdin }),
+            body: JSON.stringify({
+                Cmd: cmd,
+                Tty: options.tty,
+                AttachStdin: options.stdin,
+                AttachStdout: true,
+                AttachStderr: true,
+                ...(options.cwd !== undefined ? { WorkingDir: options.cwd } : {}),
+                ...(options.env ? { Env: Object.entries(options.env).map(([key, value]) => `${key}=${value}`) } : {}),
+            }),
         }));
-        const sink = (event) => (event.stream === "stdout" ? onStdout : onStderr)?.(String(event.chunk));
-        this.outputs.set(started.pid, sink);
-        for (const event of this.pending.get(started.pid) ?? [])
-            sink(event);
-        this.pending.delete(started.pid);
+        return created.Id;
+    }
+    async execExitCode(id) {
+        const inspect = await this.json(await this.call(`/exec/${id}/json`));
+        return inspect.ExitCode ?? 1;
+    }
+    execSocket(id, options = {}) {
+        const url = new URL(`${this.base}${DOCKER_ENGINE_BASE_PATH}/exec/${id}/start`);
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        url.searchParams.set("token", this.tokenValue());
+        if (options.rows)
+            url.searchParams.set("h", String(options.rows));
+        if (options.columns)
+            url.searchParams.set("w", String(options.columns));
+        const socket = this.makeSocket(url.href);
+        socket.binaryType = "arraybuffer";
+        return socket;
+    }
+    async start(command, options = {}) {
+        const tty = options.terminal !== undefined;
+        const wantsStdin = options.stdin !== undefined || options.stdinStream !== undefined || tty;
+        const id = await this.execCreate(["sh", "-c", command], { tty, stdin: wantsStdin, ...(options.cwd !== undefined ? { cwd: options.cwd } : {}), ...(options.env ? { env: options.env } : {}) });
+        const startedAt = Date.now();
         let state = "running";
-        const result = this.json(this.call(`/processes/${started.pid}/result`)).then((settled) => {
-            this.outputs.delete(started.pid);
-            state = settled.state;
-            if (settled.state === "failed" || !settled.result)
-                throw new Error(settled.error ?? "process failed");
-            return settled.result;
-        });
-        return {
-            pid: started.pid,
-            command: started.command,
-            startedAt: started.startedAt,
-            get state() { return state; },
-            result,
-            kill: () => { void this.call(`/processes/${started.pid}/kill`, { method: "POST" }); },
-            resize: () => undefined,
+        let stdout = "";
+        let stderr = "";
+        const decoderOut = new TextDecoder();
+        const decoderErr = new TextDecoder();
+        const onOut = (bytes) => { const text = decoderOut.decode(bytes, { stream: true }); stdout += text; options.onStdout?.(text); };
+        const onErr = (bytes) => { const text = decoderErr.decode(bytes, { stream: true }); stderr += text; options.onStderr?.(text); };
+        const settle = (exitCode) => {
+            state = "exited";
+            return { stdout, stderr, exitCode, ...(options.cwd !== undefined ? { cwd: options.cwd } : {}), ...(options.env ? { env: options.env } : {}) };
         };
+        let kill = () => undefined;
+        let resize = () => undefined;
+        let result;
+        if (!wantsStdin) {
+            // Output only: the hijacked HTTP form, streamed.
+            const controller = new AbortController();
+            kill = () => controller.abort();
+            result = (async () => {
+                const response = await this.ok(await this.call(`/exec/${id}/start`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}", signal: controller.signal }));
+                const parser = new FrameParser((stream, payload) => (stream === 2 ? onErr : onOut)(payload));
+                const reader = response.body?.getReader();
+                if (reader)
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        parser.push(value);
+                    }
+                return settle(await this.execExitCode(id));
+            })().catch((cause) => { state = "failed"; throw cause; });
+        }
+        else {
+            // Input too: the socket, framed as the daemon frames it.
+            const socket = this.execSocket(id, tty ? { rows: options.terminal.rows, columns: options.terminal.columns } : {});
+            const parser = new FrameParser((stream, payload) => (stream === 2 ? onErr : onOut)(payload));
+            kill = () => socket.close(KILL_CLOSE_CODE, "kill");
+            resize = (columns, rows) => { void this.call(`/exec/${id}/resize?h=${rows}&w=${columns}`, { method: "POST" }).catch(() => undefined); };
+            const offResize = options.terminal?.onResize?.((columns, rows) => resize(columns, rows));
+            result = new Promise((resolve, reject) => {
+                socket.onmessage = (event) => {
+                    const bytes = event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : new TextEncoder().encode(String(event.data));
+                    if (tty)
+                        onOut(bytes);
+                    else
+                        parser.push(bytes);
+                };
+                socket.onopen = () => {
+                    // End of input is an empty binary frame (the daemon's rule); the daemon closes the socket when the process exits.
+                    if (options.stdin !== undefined) {
+                        socket.send(options.stdin);
+                        if (!tty)
+                            socket.send(new ArrayBuffer(0));
+                    }
+                    if (options.stdinStream) {
+                        void (async () => {
+                            try {
+                                for await (const chunk of options.stdinStream)
+                                    socket.send(new Uint8Array(chunk).buffer);
+                                if (tty)
+                                    socket.send("\u0004");
+                                else
+                                    socket.send(new ArrayBuffer(0));
+                            }
+                            catch {
+                                socket.close(KILL_CLOSE_CODE, "stdin failed");
+                            }
+                        })();
+                    }
+                };
+                socket.onerror = () => { state = "failed"; reject(new Error(`the exec's socket failed: ${command}`)); };
+                socket.onclose = () => {
+                    offResize?.();
+                    this.execExitCode(id).then((code) => resolve(settle(code)), (cause) => { state = "failed"; reject(cause instanceof Error ? cause : new Error(String(cause))); });
+                };
+            });
+        }
+        void result.catch(() => undefined);
+        return { pid: 0, command, startedAt, get state() { return state; }, result, kill: () => kill(), resize: (columns, rows) => resize(columns, rows) };
     }
     async spawn(command, options = {}) {
         return (await this.start(command, options)).result;
     }
-    /** A terminal session on a guest pseudo-terminal; bytes in, bytes out. */
+    /** A terminal session: an exec of the command with a TTY over the socket; bytes in, bytes out. */
     async openPty(options = {}) {
-        const opened = await this.json(await this.call("/ptys", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(options) }));
-        const key = `pty:${opened.id}`;
+        const { command = "sh", cols = 80, rows = 24, cwd, env } = options;
+        const id = await this.execCreate(["sh", "-c", command], { tty: true, stdin: true, ...(cwd !== undefined ? { cwd } : {}), ...(env ? { env } : {}) });
+        const socket = this.execSocket(id, { rows, columns: cols });
         const listeners = new Set();
         const retained = [];
         let retainedBytes = 0;
-        let resolveExit = () => undefined;
-        const exited = new Promise((resolve) => { resolveExit = resolve; });
-        const sink = (event) => {
-            if (event.type === "pty-output") {
-                const bytes = Uint8Array.from(atob(String(event.data)), (c) => c.charCodeAt(0));
-                if (listeners.size === 0) {
-                    retained.push(bytes);
-                    retainedBytes += bytes.byteLength;
-                    while (retainedBytes > 64 * 1_024 && retained.length > 1)
-                        retainedBytes -= retained.shift().byteLength;
-                }
-                else {
-                    for (const listener of listeners)
-                        listener(bytes);
-                }
-            }
-            else {
-                this.outputs.delete(key);
-                resolveExit(Number(event.exitCode));
+        const opened = new Promise((resolve, reject) => { socket.onopen = () => resolve(); socket.onerror = () => reject(new Error("the terminal's socket failed")); });
+        const exited = new Promise((resolve) => { socket.onclose = () => { void this.execExitCode(id).then(resolve, () => resolve(1)); }; });
+        socket.onmessage = (event) => {
+            const bytes = event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : new TextEncoder().encode(String(event.data));
+            if (listeners.size === 0) {
+                retained.push(bytes);
+                retainedBytes += bytes.byteLength;
+                while (retainedBytes > 64 * 1_024 && retained.length > 1)
+                    retainedBytes -= retained.shift().byteLength;
             }
+            else
+                for (const listener of listeners)
+                    listener(bytes);
         };
-        this.outputs.set(key, sink);
-        for (const event of this.pending.get(key) ?? [])
-            sink(event);
-        this.pending.delete(key);
+        await opened;
+        let size = { cols, rows };
         return {
-            id: opened.id, pid: opened.pid, cols: opened.cols, rows: opened.rows, allocator: opened.allocator, resizable: opened.resizable,
-            write: (data) => this.call(`/ptys/${opened.id}/input`, { method: "POST", body: toBody(data) }),
-            resize: (cols, rows) => this.json(this.call(`/ptys/${opened.id}/resize`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ cols, rows }) })),
+            id, pid: 0, cols, rows, allocator: "exec", resizable: true,
+            write: async (data) => { socket.send(typeof data === "string" ? data : new Uint8Array(data).buffer); },
+            resize: async (nextCols, nextRows) => {
+                await this.ok(await this.call(`/exec/${id}/resize?h=${nextRows}&w=${nextCols}`, { method: "POST" }));
+                size = { cols: nextCols, rows: nextRows };
+                return size;
+            },
             onData: (listener) => {
                 listeners.add(listener);
                 for (const bytes of retained.splice(0))
@@ -192,109 +322,53 @@ export class RemoteRuntime {
                 retainedBytes = 0;
                 return () => { listeners.delete(listener); };
             },
-            kill: () => { void this.call(`/ptys/${opened.id}/kill`, { method: "POST" }); },
+            kill: () => socket.close(KILL_CLOSE_CODE, "kill"),
             exited,
         };
     }
-    /** Implements the ordinary process surface on the hosted PTY allocator. */
-    async startTerminalProcess(command, options) {
-        const terminal = options.terminal;
-        const startedAt = Date.now();
-        const pty = await this.openPty({
-            command,
-            cols: terminal.columns,
-            rows: terminal.rows,
-            ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
-            ...(options.env !== undefined ? { env: options.env } : {}),
-        });
-        const decoder = new TextDecoder();
-        let stdout = "";
-        let state = "running";
-        const offData = pty.onData((bytes) => {
-            const chunk = decoder.decode(bytes, { stream: true });
-            stdout += chunk;
-            options.onStdout?.(chunk);
-        });
-        const offResize = terminal.onResize?.((columns, rows) => {
-            void pty.resize(columns, rows).catch(() => undefined);
-        });
-        if (options.stdin !== undefined)
-            await pty.write(options.stdin);
-        if (options.stdinStream) {
-            void (async () => {
-                try {
-                    for await (const chunk of options.stdinStream)
-                        await pty.write(chunk);
-                    await pty.write("\u0004");
-                }
-                catch {
-                    pty.kill();
-                }
-            })();
-        }
-        const result = pty.exited.then((exitCode) => {
-            const tail = decoder.decode();
-            if (tail) {
-                stdout += tail;
-                options.onStdout?.(tail);
-            }
-            offData();
-            offResize?.();
-            state = "exited";
-            return { stdout, stderr: "", exitCode, ...(options.cwd !== undefined ? { cwd: options.cwd } : {}), ...(options.env !== undefined ? { env: options.env } : {}) };
-        }, (cause) => {
-            offData();
-            offResize?.();
-            state = "failed";
-            throw cause;
-        });
-        void result.catch(() => undefined);
+    /** The container's health, from inspect and top; never counts as activity on the daemon's clock beyond the request. */
+    async health() {
+        const inspect = await this.json(await this.call(`${this.container}/json`));
+        const top = await this.json(await this.call(`${this.container}/top`));
         return {
-            pid: pty.pid,
-            command,
-            startedAt,
-            get state() { return state; },
-            result,
-            kill: () => pty.kill(),
-            resize: (columns, rows) => { void pty.resize(columns, rows).catch(() => undefined); },
+            ok: true,
+            root: inspect.Config.WorkingDir,
+            portDiscovery: "inspect",
+            ports: Object.keys(inspect.NetworkSettings.Ports).map((key) => Number(key.split("/")[0])),
+            startedAt: this.startedAt,
+            lastActivityAt: Date.now(),
+            liveProcesses: top.Processes.filter((row) => row[2] === "running").length,
         };
     }
-    /** GET / on the agent, judged by the protocol the client speaks. */
-    async negotiate() {
-        const response = await this.network(`${this.base}/`, { headers: { authorization: `Bearer ${this.tokenValue()}` } });
-        const descriptor = response.ok ? await response.json().catch(() => undefined) : undefined;
-        const negotiated = negotiateHostedProtocol(descriptor, { protocol: SUBSTRATE_AGENT_PROTOCOL });
-        if (!negotiated.ok)
-            throw new Error(`${this.base} is not a ${SUBSTRATE_AGENT_PROTOCOL} server: ${negotiated.reason}`);
-        this.descriptor = negotiated.descriptor;
-        this.basePath = negotiated.descriptor.basePath.replace(/\/$/, "");
-        return negotiated.descriptor;
+    async processes() {
+        const top = await this.json(await this.call(`${this.container}/top`));
+        return top.Processes.map((row) => ({ pid: Number(row[0]), startedAt: Date.parse(row[1] ?? "") || 0, state: row[2] ?? "", command: row[3] ?? "" }));
     }
-    /** The agent's health; never counts as activity on the agent. */
-    async health() { return this.json(await this.call("/health")); }
-    async processes() { return this.json(await this.call("/processes")); }
-    async ports() { return (await this.json(await this.call("/ports"))).map((entry) => entry.port); }
-    portUrl(port) { return `${this.base}${this.basePath}/ports/${port}/`; }
+    async ports() { return (await this.health()).ports; }
+    portUrl(port) { return `${this.base}${DOCKER_ENGINE_BASE_PATH}${this.container}/ports/${port}/`; }
     request(port, input = "/", init = {}) {
-        // An absolute virtual path is relative to the port, never to the agent, and
-        // the agent may itself sit behind a path prefix such as a control plane.
-        const target = new URL(input.toString().replace(/^\//, ""), `${this.base}${this.basePath}/ports/${port}/`);
-        return this.call(target.href.slice(this.base.length + this.basePath.length), init);
+        // An absolute virtual path is relative to the port, never to the daemon,
+        // and the daemon may itself sit behind a path prefix such as a control plane.
+        const target = new URL(input.toString().replace(/^\//, ""), this.portUrl(port));
+        return this.call(target.href.slice(this.base.length + DOCKER_ENGINE_BASE_PATH.length), init);
+    }
+    /** The profiler's rows, carried under `substrate` in Docker's stats. */
+    async metrics() {
+        const stats = await this.json(await this.call(`${this.container}/stats?stream=false`));
+        return stats.substrate ?? {};
     }
-    async metrics() { return this.json(await this.call("/metrics")); }
-    /** A WebSocket to a guest port, tunnelled through the agent. */
+    /** A WebSocket to a guest port, tunnelled through the daemon. */
     webSocket(port, input = "/") {
-        const target = new URL(input.toString().replace(/^\//, ""), `${this.base}${this.basePath}/ports/${port}/`);
+        const target = new URL(input.toString().replace(/^\//, ""), this.portUrl(port));
         target.protocol = target.protocol === "https:" ? "wss:" : "ws:";
         target.searchParams.set("token", this.tokenValue());
-        return new WebSocket(target);
+        return this.makeSocket(target.href);
     }
     close() { this.abort.abort(); }
     call(route, init = {}) {
         const headers = new Headers(init.headers);
         headers.set("authorization", `Bearer ${this.tokenValue()}`);
-        headers.set(SUBSTRATE_PROTOCOL_HEADER, hostedProtocolHeader(SUBSTRATE_AGENT_PROTOCOL));
-        return this.network(`${this.base}${this.basePath}${route}`, { ...init, headers });
+        return this.network(`${this.base}${DOCKER_ENGINE_BASE_PATH}${route}`, { ...init, headers });
     }
     tokenValue() { return typeof this.token === "function" ? (this.token() ?? "") : this.token; }
     async ok(response) {
@@ -306,4 +380,6 @@ export class RemoteRuntime {
         return (await this.ok(await responseOrPromise)).json();
     }
 }
+/** Frames a chunk the way the daemon frames stdout, for tests and tools that need the shape. */
+export const dockerFrame = multiplexFrame;
 //# sourceMappingURL=client.js.map