hyperbrane 0.1.2 → 0.2.1

package/dist/sandbox/sshService.js

@@ -1,680 +0,0 @@
-import { posix } from "node:path";
-import { Client } from "ssh2";
-import { SandboxNotFoundError, } from "./api.js";
-import { createProxyEndpoints } from "./endpointProxy.js";
-import { socketConnection } from "./localService.js";
-/** SFTP status codes (draft-ietf-secsh-filexfer-02). */
-const SFTP_NO_SUCH_FILE = 2;
-const SFTP_EOF = 1;
-/**
- * Commands running at once on the connection. sshd refuses sessions past its MaxSessions (10 by
- * default) per connection, and counts a closed one until it has cleaned up after it, so this stays
- * well below; the services fan out wider, and the rest wait their turn.
- */
-const MAX_CHANNELS = 4;
-/** Attempts at a command sshd refused to start (it was busy cleaning up sessions). */
-const ATTEMPTS = 8;
-export function createSshSandbox(host, options) {
-    const { user, port = 22, privateKey, passphrase, hostVerifier, readyTimeout = 15000, endpoints } = options;
-    let connecting = null;
-    function connection() {
-        if (connecting)
-            return connecting;
-        const opened = new Promise((resolve, reject) => {
-            const client = new Client();
-            let ready = false;
-            client
-                .on("ready", () => {
-                ready = true;
-                // Small writes (keystrokes, short replies) go out at once.
-                client.setNoDelay(true);
-                resolve(client);
-            })
-                .on("error", (error) => {
-                if (!ready)
-                    reject(new Error(`ssh to ${user}@${host}:${port} failed: ${error.message}`));
-            })
-                .on("close", () => {
-                if (connecting === opened)
-                    connecting = null;
-                if (!ready)
-                    reject(new Error(`ssh to ${user}@${host}:${port} closed before it was ready`));
-            })
-                // strictVendor off: OpenSSH extensions (stream-local forwarding) are tried on any server, not
-                // only on one that announces itself as OpenSSH (a proxy in front of it may not).
-                .connect({ host, port, username: user, privateKey, passphrase, readyTimeout, keepaliveInterval: 20000, hostVerifier, strictVendor: false });
-        });
-        connecting = opened;
-        opened.catch(() => {
-            if (connecting === opened)
-                connecting = null;
-        });
-        return opened;
-    }
-    function remotePath(path) {
-        return posix.resolve("/", path);
-    }
-    /**
-     * SSH hands the remote side a single command line for the login shell to parse, so every word is
-     * quoted. Environment goes through env(1), since servers drop most variables set over the protocol.
-     */
-    function commandLine(cmd, env = {}, cwd) {
-        const words = [...Object.entries(env).map(([name, value]) => `${name}=${value}`), ...cmd];
-        const run = `exec env ${words.map(quote).join(" ")}`;
-        return cwd === undefined ? run : `cd ${quote(cwd)} && ${run}`;
-    }
-    let running = 0;
-    const waiting = [];
-    /** Waits for one of the MAX_CHANNELS slots; the returned function gives it back. */
-    async function slot() {
-        if (running >= MAX_CHANNELS)
-            await new Promise((resolve) => waiting.push(resolve));
-        else
-            running += 1;
-        let released = false;
-        return () => {
-            if (released)
-                return;
-            released = true;
-            const next = waiting.shift();
-            if (next)
-                next(); // the slot passes straight on
-            else
-                running -= 1;
-        };
-    }
-    const backoff = (attempt) => new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
-    /**
-     * Starts `command` on its own channel, feeding it `stdin` (or nothing) and closing its input. The
-     * channel holds a slot until it closes. A channel sshd refuses to open is asked for again.
-     */
-    async function exec(command, stdin) {
-        for (let attempt = 1;; attempt++) {
-            const release = await slot();
-            try {
-                const client = await connection();
-                const channel = await new Promise((resolve, reject) => client.exec(command, (error, opened) => (error ? reject(error) : resolve(opened))));
-                channel.on("close", release);
-                if (stdin !== "keep open")
-                    channel.end(stdin === undefined ? undefined : typeof stdin === "string" ? stdin : Buffer.from(stdin));
-                return channel;
-            }
-            catch (error) {
-                release();
-                if (attempt >= ATTEMPTS || !/Channel open failure/.test(error.message))
-                    throw error;
-            }
-            await backoff(attempt);
-        }
-    }
-    /**
-     * The exit code once the channel closes (-1 if the command died of a signal), or null if sshd
-     * closed it without running the command: no exit status (not even a signal) and no output.
-     */
-    function exited(channel) {
-        return new Promise((resolve) => {
-            let code = null;
-            channel.on("exit", (exitCode) => (code = exitCode ?? -1));
-            channel.on("close", () => resolve(code));
-        });
-    }
-    async function runBytes(command, stdin) {
-        for (let attempt = 1;; attempt++) {
-            const channel = await exec(command, stdin);
-            const out = [];
-            const err = [];
-            channel.on("data", (chunk) => out.push(chunk));
-            channel.stderr.on("data", (chunk) => err.push(chunk));
-            const exitCode = await exited(channel);
-            const output = { stdout: Buffer.concat(out), stderr: Buffer.concat(err).toString() };
-            if (exitCode !== null)
-                return { exitCode, ...output };
-            if (attempt >= ATTEMPTS || out.length > 0 || err.length > 0)
-                return { exitCode: -1, ...output };
-            await backoff(attempt);
-        }
-    }
-    async function run(command, stdin) {
-        const { exitCode, stdout, stderr } = await runBytes(command, stdin);
-        return { exitCode, stdout: stdout.toString(), stderr };
-    }
-    async function sh(script, env = {}, stdin) {
-        return run(commandLine(["sh", "-c", script], env), stdin);
-    }
-    let sftpOpening = null;
-    /** The connection's SFTP channel, opened on first use (and again after it closes). */
-    function sftp() {
-        if (sftpOpening)
-            return sftpOpening;
-        const opening = connection().then((client) => new Promise((resolve, reject) => client.sftp((error, channel) => {
-            if (error)
-                return reject(error);
-            channel.on("close", () => {
-                if (sftpOpening === opening)
-                    sftpOpening = null;
-            });
-            resolve(channel);
-        })));
-        sftpOpening = opening;
-        opening.catch(() => {
-            if (sftpOpening === opening)
-                sftpOpening = null;
-        });
-        return opening;
-    }
-    const missing = (error) => error.code === SFTP_NO_SUCH_FILE;
-    /** Runs one SFTP request; a missing path becomes SandboxNotFoundError. */
-    async function sftpCall(what, path, request) {
-        const channel = await sftp();
-        return new Promise((resolve, reject) => request(channel, (error, value) => {
-            if (!error)
-                return resolve(value);
-            if (missing(error))
-                return reject(new SandboxNotFoundError(`Not found: "${path}"`));
-            reject(new Error(`${what} ${path} on ${host} failed: ${error.message}`));
-        }));
-    }
-    function statOf(full) {
-        return sftpCall("stat", full, (channel, done) => channel.stat(full, done));
-    }
-    async function sftpReadFile(path) {
-        const full = remotePath(path);
-        const data = await sftpCall("read", full, (channel, done) => channel.readFile(full, done));
-        return new Uint8Array(data);
-    }
-    async function sftpReadFileRange(path, start, end) {
-        const full = remotePath(path);
-        const channel = await sftp();
-        const handle = await sftpCall("read", full, (sftpChannel, done) => sftpChannel.open(full, "r", done));
-        try {
-            const buffer = Buffer.alloc(Math.max(0, end - start));
-            let filled = 0;
-            while (filled < buffer.length) {
-                const read = await new Promise((resolve, reject) => channel.read(handle, buffer, filled, buffer.length - filled, start + filled, (error, bytesRead) => {
-                    // The end of the file comes as an EOF status rather than a short read.
-                    if (error && error.code !== SFTP_EOF)
-                        return reject(new Error(`read ${full} on ${host} failed: ${error.message}`));
-                    resolve(error ? 0 : bytesRead);
-                }));
-                if (read === 0)
-                    break;
-                filled += read;
-            }
-            return new Uint8Array(buffer.subarray(0, filled));
-        }
-        finally {
-            channel.close(handle, () => { });
-        }
-    }
-    /** Writes `data` to a unique hidden file next to `full` (creating its directory) and returns its path. */
-    async function writeTemp(full, data) {
-        await createDirectory(posix.dirname(full));
-        const tmp = posix.join(posix.dirname(full), `.${posix.basename(full)}.${crypto.randomUUID()}.tmp`);
-        const bytes = typeof data === "string" ? Buffer.from(data) : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-        await sftpCall("write", full, (channel, done) => channel.writeFile(tmp, bytes, done));
-        return tmp;
-    }
-    const unlinkQuietly = (path) => sftpCall("remove", path, (channel, done) => channel.unlink(path, done)).catch(() => { });
-    // Written in full beside the target, then renamed over it (posix-rename replaces an existing file).
-    async function sftpWriteFile(path, data) {
-        const full = remotePath(path);
-        const tmp = await writeTemp(full, data);
-        try {
-            await sftpCall("write", full, (channel, done) => channel.ext_openssh_rename(tmp, full, done));
-        }
-        catch (error) {
-            await unlinkQuietly(tmp);
-            throw error;
-        }
-    }
-    // A hard link refuses to replace an existing file, and publishes the fully written temp file.
-    async function sftpWriteFileExclusive(path, data) {
-        const full = remotePath(path);
-        const tmp = await writeTemp(full, data);
-        try {
-            await sftpCall("write", full, (channel, done) => channel.ext_openssh_hardlink(tmp, full, done));
-            return true;
-        }
-        catch (error) {
-            if (await statOf(full).then(() => true, () => false))
-                return false;
-            throw error;
-        }
-        finally {
-            await unlinkQuietly(tmp);
-        }
-    }
-    async function sftpRemoveFile(path) {
-        const full = remotePath(path);
-        await sftpCall("remove", full, (channel, done) => channel.unlink(full, done)).catch((error) => {
-            if (!(error instanceof SandboxNotFoundError))
-                throw error;
-        });
-    }
-    // mkdir -p: each missing directory from the top; one that appears meanwhile is fine.
-    async function sftpCreateDirectory(path) {
-        const full = remotePath(path);
-        const parts = full.split("/").filter(Boolean);
-        for (let depth = parts.length; depth >= 0; depth--) {
-            const dir = `/${parts.slice(0, depth).join("/")}`;
-            const info = await statOf(dir).catch((error) => {
-                if (error instanceof SandboxNotFoundError)
-                    return null;
-                throw error;
-            });
-            if (!info)
-                continue;
-            if (!info.isDirectory())
-                throw new Error(`mkdir ${full} on ${host} failed: ${dir} is not a directory`);
-            for (let next = depth + 1; next <= parts.length; next++) {
-                const create = `/${parts.slice(0, next).join("/")}`;
-                await sftpCall("mkdir", create, (channel, done) => channel.mkdir(create, done)).catch(async (error) => {
-                    if (!(await statOf(create).then((s) => s.isDirectory(), () => false)))
-                        throw error;
-                });
-            }
-            return;
-        }
-    }
-    /** Throws SandboxNotFoundError for a missing path, and an Error for any other failure. */
-    function check(result, what, path) {
-        if (result.exitCode !== 0)
-            throw new Error(`${what} ${path} on ${host} failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
-    }
-    async function removeDirectory(path) {
-        const full = remotePath(path);
-        check(await sh('rm -rf -- "$P"', { P: full }), "remove", full);
-    }
-    async function sftpListDirectory(path) {
-        const full = remotePath(path);
-        const entries = await sftpCall("list", full, (channel, done) => channel.readdir(full, done));
-        return entries.map((entry) => entry.filename).filter((name) => name !== "." && name !== "..");
-    }
-    async function sftpStat(path) {
-        const info = await statOf(remotePath(path));
-        const type = info.isDirectory() ? "directory" : info.isFile() ? "file" : "other";
-        return { type, uid: info.uid, gid: info.gid, size: info.size };
-    }
-    // SFTP starts in the user's home directory. Asked once: storage paths start from it on every call.
-    let home = null;
-    function sftpHomeDirectory() {
-        return sftpCall("home of", user, (channel, done) => channel.realpath(".", done));
-    }
-    // Without SFTP (a server, or a proxy in front of one, that doesn't offer it), files go through
-    // shell commands instead; slower, and subject to sshd's session limits, but they work anywhere.
-    let sftpSupport = null;
-    function sftpAvailable() {
-        sftpSupport ??= sftp().then(() => true, (error) => {
-            if (/subsystem/i.test(error.message))
-                return false;
-            sftpSupport = null; // the connection failed, not SFTP: ask again next time
-            throw error;
-        });
-        return sftpSupport;
-    }
-    /** What the shell scripts below exit with for a missing path, and for an existing one. */
-    const NOT_FOUND = 44;
-    const EXISTS = 45;
-    function checkShell(result, what, path) {
-        if (result.exitCode === NOT_FOUND)
-            throw new SandboxNotFoundError(`Not found: "${path}"`);
-        check(result, what, path);
-    }
-    const shell = {
-        async readFile(full) {
-            const result = await runBytes(commandLine(["sh", "-c", `[ -e "$P" ] || exit ${NOT_FOUND}; cat -- "$P"`], { P: full }));
-            checkShell(result, "read", full);
-            return new Uint8Array(result.stdout);
-        },
-        async readFileRange(full, start, end) {
-            const script = `[ -e "$P" ] || exit ${NOT_FOUND}; tail -c +$(($S + 1)) -- "$P" | head -c "$L"`;
-            const result = await runBytes(commandLine(["sh", "-c", script], { P: full, S: String(start), L: String(Math.max(0, end - start)) }));
-            checkShell(result, "read", full);
-            return new Uint8Array(result.stdout);
-        },
-        /** Streams `data` into a temp file beside `full`, then runs `publish` ($T the temp file, $F the target). */
-        writeVia(full, data, publish) {
-            const tmp = posix.join(posix.dirname(full), `.${posix.basename(full)}.${crypto.randomUUID()}.tmp`);
-            const script = `mkdir -p -- "$D" && cat > "$T" || { rm -f -- "$T"; exit 1; }\n${publish}`;
-            return sh(script, { D: posix.dirname(full), T: tmp, F: full }, data);
-        },
-        async writeFile(full, data) {
-            checkShell(await shell.writeVia(full, data, 'mv -f -- "$T" "$F" || { rm -f -- "$T"; exit 1; }'), "write", full);
-        },
-        async writeFileExclusive(full, data) {
-            const result = await shell.writeVia(full, data, `if ln -- "$T" "$F" 2>/dev/null; then rm -f -- "$T"; exit 0; fi; rm -f -- "$T"; [ -e "$F" ] && exit ${EXISTS}; exit 1`);
-            if (result.exitCode === EXISTS)
-                return false;
-            checkShell(result, "write", full);
-            return true;
-        },
-        async removeFile(full) {
-            checkShell(await sh('rm -f -- "$P"', { P: full }), "remove", full);
-        },
-        async createDirectory(full) {
-            checkShell(await sh('mkdir -p -- "$P"', { P: full }), "mkdir", full);
-        },
-        async listDirectory(full) {
-            const result = await sh(`[ -e "$P" ] || exit ${NOT_FOUND}; ls -A1 -- "$P"`, { P: full });
-            checkShell(result, "list", full);
-            return result.stdout.split("\n").filter(Boolean);
-        },
-        async stat(full) {
-            const result = await sh(`[ -e "$P" ] || exit ${NOT_FOUND}; stat -c '%u:%g:%s:%F' -- "$P"`, { P: full });
-            checkShell(result, "stat", full);
-            const [uid = "", gid = "", size = "", kind = ""] = result.stdout.trim().split(":");
-            const type = kind === "directory" ? "directory" : kind.startsWith("regular") ? "file" : "other";
-            return { type, uid: Number(uid), gid: Number(gid), size: Number(size) };
-        },
-        // sshd always sets HOME for the session.
-        async homeDirectory() {
-            const result = await sh('printf %s "$HOME"');
-            check(result, "home of", user);
-            return result.stdout || "/";
-        },
-    };
-    const readFile = async (path) => ((await sftpAvailable()) ? sftpReadFile(path) : shell.readFile(remotePath(path)));
-    const readFileRange = async (path, start, end) => (await sftpAvailable()) ? sftpReadFileRange(path, start, end) : shell.readFileRange(remotePath(path), start, end);
-    const writeFile = async (path, data) => (await sftpAvailable()) ? sftpWriteFile(path, data) : shell.writeFile(remotePath(path), data);
-    const writeFileExclusive = async (path, data) => (await sftpAvailable()) ? sftpWriteFileExclusive(path, data) : shell.writeFileExclusive(remotePath(path), data);
-    const removeFile = async (path) => ((await sftpAvailable()) ? sftpRemoveFile(path) : shell.removeFile(remotePath(path)));
-    const createDirectory = async (path) => (await sftpAvailable()) ? sftpCreateDirectory(path) : shell.createDirectory(remotePath(path));
-    const listDirectory = async (path) => ((await sftpAvailable()) ? sftpListDirectory(path) : shell.listDirectory(remotePath(path)));
-    const stat = async (path) => ((await sftpAvailable()) ? sftpStat(path) : shell.stat(remotePath(path)));
-    const homeDirectory = () => {
-        home ??= sftpAvailable().then((available) => (available ? sftpHomeDirectory() : shell.homeDirectory()));
-        home.catch(() => (home = null));
-        return home;
-    };
-    async function runCommand(cmd, { cwd, env = {}, stdin } = {}) {
-        return run(commandLine(cmd, env, cwd === undefined ? undefined : remotePath(cwd)), stdin);
-    }
-    /** A stream to the remote unix socket at `full`, through stream-local forwarding. */
-    // Whether the server does stream-local forwarding: unknown until a socket has been reached one way
-    // or the other. Servers that don't (or a proxy in front of one) get the relay instead.
-    let forwarding = "unknown";
-    /**
-     * A stream to the remote unix socket at `full`: forwarded by sshd where it can, else through a
-     * relay command on the server.
-     */
-    async function forward(full) {
-        if (forwarding === "unsupported")
-            return relay(full);
-        const client = await connection();
-        try {
-            const stream = await new Promise((resolve, reject) => client.openssh_forwardOutStreamLocal(full, (error, opened) => (error ? reject(error) : resolve(opened))));
-            forwarding = "works";
-            return stream;
-        }
-        catch (error) {
-            const failure = new Error(`connecting to ${full} on ${host} failed: ${error.message}`);
-            if (forwarding === "works")
-                throw failure;
-            // The socket may just be missing (sshd says so in the same words); if the relay reaches it,
-            // it was the forwarding.
-            const stream = await relay(full).catch(() => {
-                throw failure;
-            });
-            forwarding = "unsupported";
-            return stream;
-        }
-    }
-    /**
-     * A stream to the remote unix socket at `full` through a command on the server that connects to it
-     * and copies between it and the channel (python3, which servers mostly have). Resolves once the
-     * relay has connected; rejects with why it couldn't.
-     */
-    async function relay(full) {
-        const channel = await exec(commandLine(["python3", "-c", RELAY, full]), "keep open");
-        return new Promise((resolve, reject) => {
-            let errors = "";
-            const failed = () => {
-                reject(new Error(`connecting to ${full} on ${host} failed: ${errors.trim() || "the relay exited"}`));
-                channel.close();
-            };
-            // Its first line on stderr says whether it connected.
-            const onError = (chunk) => {
-                errors += chunk.toString();
-                if (!errors.includes("\n"))
-                    return;
-                channel.stderr.off("data", onError);
-                channel.off("exit", failed);
-                channel.off("close", failed);
-                if (errors.startsWith("connected\n"))
-                    resolve(channel);
-                else
-                    failed();
-            };
-            channel.stderr.on("data", onError);
-            // With its input still open, the channel doesn't close when the relay exits; the exit says it.
-            channel.on("exit", failed);
-            channel.on("close", failed);
-        });
-    }
-    /**
-     * HTTP/1.1 over the remote unix socket `init.unix`, one forwarded stream per request (closed when
-     * the response ends). The response streams as it arrives; aborting `signal` closes the stream.
-     */
-    async function fetchRemote(url, init = {}) {
-        if (init.signal?.aborted)
-            throw init.signal.reason;
-        if (init.unix === undefined)
-            throw new Error("the SSH sandbox fetches only over unix sockets (init.unix)");
-        const target = new URL(url);
-        const stream = await forward(remotePath(init.unix));
-        const body = init.body === undefined ? undefined : typeof init.body === "string" ? Buffer.from(init.body) : Buffer.from(init.body);
-        const head = [`${init.method ?? "GET"} ${target.pathname}${target.search} HTTP/1.1`, `Host: ${target.host}`, "Connection: close"];
-        for (const [name, value] of Object.entries(init.headers ?? {}))
-            head.push(`${name}: ${value}`);
-        if (body)
-            head.push(`Content-Length: ${body.length}`);
-        stream.write(`${head.join("\r\n")}\r\n\r\n`);
-        if (body)
-            stream.write(body);
-        let idle;
-        let fail = () => { };
-        const touch = () => {
-            if (typeof init.timeout !== "number")
-                return;
-            clearTimeout(idle);
-            idle = setTimeout(() => fail(new Error(`fetch ${url} on ${host}: no data for ${init.timeout}ms`)), init.timeout);
-        };
-        const abort = () => fail(init.signal.reason instanceof Error ? init.signal.reason : new Error("aborted"));
-        init.signal?.addEventListener("abort", abort, { once: true });
-        const finish = () => {
-            clearTimeout(idle);
-            init.signal?.removeEventListener("abort", abort);
-            stream.destroy();
-        };
-        touch();
-        return new Promise((resolve, reject) => {
-            let buffer = Buffer.alloc(0);
-            let responded = false;
-            let controller = null;
-            // The body as framed: by Content-Length, chunked, or until the stream closes.
-            let framing = { kind: "close" };
-            let done = false;
-            const end = () => {
-                if (done)
-                    return;
-                done = true;
-                finish();
-                try {
-                    controller?.close();
-                }
-                catch {
-                    /* cancelled */
-                }
-            };
-            fail = (error) => {
-                if (done)
-                    return;
-                done = true;
-                finish();
-                if (!responded)
-                    reject(error);
-                else
-                    controller?.error(error);
-            };
-            /** Hands on what the buffer holds of the body; true once the body is complete. */
-            const pumpBody = () => {
-                if (framing.kind === "close") {
-                    if (buffer.length)
-                        controller?.enqueue(new Uint8Array(buffer));
-                    buffer = Buffer.alloc(0);
-                    return false;
-                }
-                if (framing.kind === "length") {
-                    const take = buffer.subarray(0, framing.left);
-                    if (take.length)
-                        controller?.enqueue(new Uint8Array(take));
-                    framing.left -= take.length;
-                    buffer = buffer.subarray(take.length);
-                    return framing.left === 0;
-                }
-                for (;;) {
-                    const lineEnd = buffer.indexOf("\r\n");
-                    if (lineEnd < 0)
-                        return false;
-                    const size = parseInt(buffer.subarray(0, lineEnd).toString(), 16);
-                    if (Number.isNaN(size))
-                        throw new Error("malformed chunked body");
-                    if (size === 0)
-                        return true;
-                    if (buffer.length < lineEnd + 2 + size + 2)
-                        return false;
-                    controller?.enqueue(new Uint8Array(buffer.subarray(lineEnd + 2, lineEnd + 2 + size)));
-                    buffer = buffer.subarray(lineEnd + 2 + size + 2);
-                }
-            };
-            const onData = (chunk) => {
-                if (done)
-                    return;
-                touch();
-                buffer = buffer.length ? Buffer.concat([buffer, chunk]) : chunk;
-                try {
-                    if (!responded) {
-                        const headEnd = buffer.indexOf("\r\n\r\n");
-                        if (headEnd < 0)
-                            return;
-                        const [statusLine = "", ...lines] = buffer.subarray(0, headEnd).toString("latin1").split("\r\n");
-                        buffer = buffer.subarray(headEnd + 4);
-                        const status = Number(statusLine.split(" ")[1]);
-                        if (status >= 100 && status < 200)
-                            return onData(Buffer.alloc(0)); // interim response
-                        const headers = new Headers();
-                        for (const line of lines) {
-                            const colon = line.indexOf(":");
-                            if (colon > 0)
-                                headers.append(line.slice(0, colon).trim(), line.slice(colon + 1).trim());
-                        }
-                        responded = true;
-                        // A null-body status can't be given a body, even an empty one.
-                        if (status === 204 || status === 304 || init.method === "HEAD") {
-                            resolve(new Response(null, { status, headers }));
-                            return end();
-                        }
-                        if (headers.get("transfer-encoding")?.toLowerCase().includes("chunked"))
-                            framing = { kind: "chunked" };
-                        else if (headers.has("content-length"))
-                            framing = { kind: "length", left: Number(headers.get("content-length")) };
-                        const responseBody = new ReadableStream({
-                            start(c) {
-                                controller = c;
-                            },
-                            cancel() {
-                                done = true;
-                                finish();
-                            },
-                        });
-                        resolve(new Response(responseBody, { status, headers }));
-                    }
-                    if (pumpBody())
-                        end();
-                }
-                catch (error) {
-                    fail(error);
-                }
-            };
-            stream.on("data", onData);
-            stream.on("error", (error) => fail(new Error(`fetch ${url} on ${host} failed: ${error.message}`)));
-            // The server is done sending at EOF. That may be all it does: docker only half-closes a hijacked
-            // connection (exec output) and waits for the client to close it.
-            const ended = () => {
-                if (!responded)
-                    return fail(new Error(`fetch ${url} on ${host} failed: the socket closed before a response`));
-                if (framing.kind === "close")
-                    end();
-                else
-                    fail(new Error(`fetch ${url} on ${host} failed: the response was cut short`));
-            };
-            stream.on("end", ended);
-            stream.on("close", ended);
-        });
-    }
-    async function connect(path) {
-        const full = remotePath(path);
-        return socketConnection(await forward(full), full, { opened: true });
-    }
-    function close() {
-        const pending = connecting;
-        connecting = null;
-        sftpOpening = null;
-        void pending?.then((client) => client.end()).catch(() => { });
-    }
-    const sandbox = {
-        readFile,
-        readFileRange,
-        writeFile,
-        writeFileExclusive,
-        removeFile,
-        createDirectory,
-        removeDirectory,
-        listDirectory,
-        stat,
-        homeDirectory,
-        runCommand,
-        fetch: fetchRemote,
-        connect,
-        close,
-    };
-    if (!endpoints)
-        return sandbox;
-    return { ...sandbox, ...createProxyEndpoints({ runCommand }, endpoints, host) };
-}
-/**
- * relay()'s command: connects to the unix socket in argv[1], says "connected" on stderr, then copies
- * stdin to the socket and the socket to stdout until the socket closes (its end of a half-close
- * passed on).
- */
-const RELAY = `
-import os, socket, sys, threading
-s = socket.socket(socket.AF_UNIX)
-try:
-    s.connect(sys.argv[1])
-except OSError as e:
-    sys.stderr.write(f"{e.strerror}\\n")
-    sys.exit(1)
-sys.stderr.write("connected\\n")
-sys.stderr.flush()
-def up():
-    while True:
-        data = os.read(0, 65536)
-        if not data:
-            break
-        s.sendall(data)
-    try:
-        s.shutdown(socket.SHUT_WR)
-    except OSError:
-        pass
-threading.Thread(target=up, daemon=True).start()
-while True:
-    data = s.recv(65536)
-    if not data:
-        break
-    os.write(1, data)
-`;
-/** Quotes a word for a POSIX shell. */
-function quote(word) {
-    return `'${word.replaceAll("'", `'\\''`)}'`;
-}