@loucompanion/forge-bridge 0.1.3-dev.b3bce6ba65a6 → 0.1.3-dev.ba7d36726eda

package/dist/sandbox/preflight.js

@@ -0,0 +1,300 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { BoundedCommandRunner } from "./command-runner.js";
+const minimumWorkspaceBytes = 10 * 1024 * 1024 * 1024;
+const defaultHostMemoryReserveBytes = 2 * 1024 ** 3;
+export class DockerPreflight {
+    commands;
+    cacheMs;
+    generation = 0;
+    cached = null;
+    cacheAt = 0;
+    options;
+    docker;
+    ownership = new DockerContextOwnershipLock();
+    diskPressureLatched = false;
+    constructor(options = {}, commands = new BoundedCommandRunner(), cacheMs = 30_000) {
+        this.commands = commands;
+        this.cacheMs = cacheMs;
+        this.options = typeof options === "string" ? { dockerExecutable: options } : options;
+        this.docker = this.options.dockerExecutable ?? process.env.FORGE_DOCKER_EXECUTABLE ?? "docker";
+    }
+    current() {
+        return this.cached;
+    }
+    async refresh() {
+        await fs.mkdir(this.options.stateRoot ?? path.join(os.homedir(), ".forge", "bridge", "sandboxes"), { recursive: true, mode: 0o700 });
+        const result = await this.run(true);
+        if (canRunDockerMaintenance(result)) {
+            await this.ownership.acquire(this.options.dockerContext);
+        }
+        return result;
+    }
+    async release() {
+        await this.ownership.release();
+    }
+    async run(force = false) {
+        if (!force && this.cached && Date.now() - this.cacheAt < this.cacheMs)
+            return this.cached;
+        this.generation += 1;
+        const result = await this.inspect().catch((error) => unavailable(this.generation, "docker_unreachable", error instanceof Error ? error.message : String(error)));
+        this.cached = result;
+        this.cacheAt = Date.now();
+        return result;
+    }
+    async inspect() {
+        if (!new Set(["linux", "darwin", "win32"]).has(process.platform)) {
+            return unavailable(this.generation, "platform_unsupported", `Docker sandboxes are not supported on ${process.platform}.`);
+        }
+        const dockerArgs = this.options.dockerContext ? ["--context", this.options.dockerContext] : [];
+        const infoResult = await this.commands.run(this.docker, [...dockerArgs, "info", "--format", "{{json .}}"], { timeoutMs: 10_000, maxOutputBytes: 512 * 1024 });
+        if (infoResult.exitCode !== 0)
+            return unavailable(this.generation, "docker_unreachable", singleLine(infoResult.stderr || infoResult.stdout || "Docker daemon is unreachable."));
+        const info = parseInfo(infoResult.stdout);
+        if (String(info.OSType ?? "").toLowerCase() !== "linux")
+            return unavailable(this.generation, "docker_linux_required", "Forge sandbox images require a Linux Docker daemon.");
+        const securityOptions = strings(info.SecurityOptions).map((value) => value.toLowerCase());
+        const rootless = securityOptions.some((value) => value.includes("rootless"));
+        const userNamespaces = rootless || securityOptions.some((value) => value.includes("userns"));
+        const cgroupV2 = String(info.CgroupVersion ?? "") === "2";
+        const seccomp = securityOptions.some((value) => value.includes("seccomp"));
+        const lsm = securityOptions.some((value) => value.includes("apparmor") || value.includes("selinux"));
+        const storageDriver = String(info.Driver ?? "").toLowerCase();
+        const storageQuota = storageDriver === "overlay2" && Boolean(info.DriverStatus?.some?.((entry) => JSON.stringify(entry).toLowerCase().includes("project quota")));
+        const desktopDeveloperMode = process.platform !== "linux" && process.env.FORGE_ALLOW_DOCKER_DESKTOP_SANDBOX === "true";
+        const requireRootless = this.options.requireRootless ?? process.env.FORGE_SANDBOX_REQUIRE_ROOTLESS !== "false";
+        if (!rootless && !desktopDeveloperMode && requireRootless) {
+            return unavailable(this.generation, "docker_rootless_required", "Docker daemon is reachable but is not running rootless.", {
+                rootless, userNamespaces, cgroupV2, seccomp, lsm, storageQuota, storagePolicy: false, compose: false, internalNetwork: true, buildkit: false, imagePolicy: false, securityProfile: false, egressProxy: false
+            });
+        }
+        const composeResult = await this.commands.run(this.docker, [...dockerArgs, "compose", "version", "--short"], { timeoutMs: 5_000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+        const compose = composeResult?.exitCode === 0;
+        const buildxResult = await this.commands.run(this.docker, [...dockerArgs, "buildx", "version"], { timeoutMs: 5_000, maxOutputBytes: 16 * 1024 }).catch(() => null);
+        const buildxHelp = await this.commands.run(this.docker, [...dockerArgs, "buildx", "build", "--help"], { timeoutMs: 5_000, maxOutputBytes: 256 * 1024 }).catch(() => null);
+        const buildxPruneHelp = await this.commands.run(this.docker, [...dockerArgs, "buildx", "prune", "--help"], { timeoutMs: 5_000, maxOutputBytes: 256 * 1024 }).catch(() => null);
+        const containerUpdateHelp = await this.commands.run(this.docker, [...dockerArgs, "container", "update", "--help"], { timeoutMs: 5_000, maxOutputBytes: 256 * 1024 }).catch(() => null);
+        const buildkit = buildxResult?.exitCode === 0
+            && buildxHelp?.exitCode === 0
+            && ["--ulimit", "--shm-size"].every(flag => buildxHelp.stdout.includes(flag))
+            && buildxPruneHelp?.exitCode === 0
+            && ["--max-used-space", "--min-free-space", "--reserved-space"].every(flag => buildxPruneHelp.stdout.includes(flag))
+            && containerUpdateHelp?.exitCode === 0
+            && ["--pids-limit", "--memory", "--memory-swap"].every(flag => containerUpdateHelp.stdout.includes(flag));
+        const imagePolicy = process.env.FORGE_SANDBOX_IMAGE_POLICY_ENFORCED === "true"
+            && Boolean(process.env.FORGE_SANDBOX_SBOM_EXECUTABLE?.trim())
+            && Boolean(process.env.FORGE_SANDBOX_VULNERABILITY_EXECUTABLE?.trim())
+            && Boolean(process.env.FORGE_SANDBOX_PROVENANCE_SIGNING_KEY?.trim())
+            && Boolean(process.env.FORGE_SANDBOX_SIGNATURE_EXECUTABLE?.trim())
+            && Boolean(process.env.FORGE_SANDBOX_SIGNATURE_PUBLIC_KEY?.trim())
+            && process.env.FORGE_SANDBOX_BUILD_EGRESS_ENFORCED === "true";
+        const securityProfile = Boolean(process.env.FORGE_SANDBOX_SECCOMP_PROFILE?.trim())
+            && Boolean(process.env.FORGE_SANDBOX_LSM_SECURITY_OPT?.trim())
+            && seccomp && lsm;
+        const egressProxy = process.env.FORGE_SANDBOX_EGRESS_ENFORCED === "true"
+            && /@sha256:[0-9a-f]{64}$/iu.test(process.env.FORGE_SANDBOX_EGRESS_PROXY_IMAGE?.trim() ?? "");
+        const storagePolicy = storagePolicyAvailable(storageQuota);
+        const configuredStateRoot = this.options.stateRoot ?? path.join(os.homedir(), ".forge", "bridge", "sandboxes");
+        const dockerRoot = process.platform === "linux" && typeof info.DockerRootDir === "string" && path.isAbsolute(info.DockerRootDir)
+            ? info.DockerRootDir
+            : configuredStateRoot;
+        const disk = await diskSpace(dockerRoot);
+        const requiredWorkspaceBytes = this.options.minimumWorkspaceBytes ?? minimumWorkspaceBytes;
+        const highWatermark = Math.min(99, Math.max(1, this.options.diskHighWatermarkPercent ?? 90));
+        const lowWatermark = Math.min(highWatermark - 1, Math.max(0, this.options.diskLowWatermarkPercent ?? highWatermark - 10));
+        const diskLow = evaluateDiskPressure(disk.available, disk.total, requiredWorkspaceBytes, highWatermark, lowWatermark, this.diskPressureLatched);
+        this.diskPressureLatched = diskLow;
+        const hostAvailableMemoryBytes = os.freemem();
+        let totalMemoryBytes = os.totalmem();
+        let availableMemoryBytes = hostAvailableMemoryBytes;
+        const dockerDesktop = process.platform !== "linux"
+            && String(info.OperatingSystem ?? "").toLowerCase().includes("docker desktop");
+        const dockerMemoryBytes = Number(info.MemTotal);
+        if (dockerDesktop && Number.isFinite(dockerMemoryBytes) && dockerMemoryBytes > 0) {
+            totalMemoryBytes = dockerMemoryBytes;
+            const stats = await this.commands.run(this.docker, [...dockerArgs, "stats", "--no-stream", "--format", "{{.MemUsage}}"], { timeoutMs: 10_000, maxOutputBytes: 512 * 1024 }).catch(() => null);
+            if (stats?.exitCode === 0) {
+                const dockerUsedMemoryBytes = stats.stdout
+                    .split(/\r?\n/gu)
+                    .map(line => parseDockerMemoryUsage(line))
+                    .reduce((total, value) => total + value, 0);
+                availableMemoryBytes = Math.max(0, dockerMemoryBytes - dockerUsedMemoryBytes);
+            }
+        }
+        const cpuCount = Math.max(1, os.availableParallelism?.() ?? os.cpus().length);
+        const availableCpuMillis = Math.max(0, (cpuCount - 1) * 1000);
+        const memoryReserveBytes = positiveInteger(this.options.hostMemoryReserveBytes, defaultHostMemoryReserveBytes);
+        const workerMemoryLimitBytes = positiveInteger(this.options.defaultWorkerMemoryLimitBytes, 2 * 1024 ** 3);
+        const serviceMemoryLimitBytes = nonNegativeInteger(this.options.defaultServiceMemoryLimitBytes, 0);
+        const runtimeOverheadBytes = Math.max(128 * 1024 ** 2, nonNegativeInteger(this.options.runtimeOverheadBytes, 128 * 1024 ** 2));
+        const sandboxMemoryBytes = workerMemoryLimitBytes + serviceMemoryLimitBytes + runtimeOverheadBytes;
+        const minimumAdmissionMemoryBytes = 128 * 1024 ** 2 + Math.max(128 * 1024 ** 2, runtimeOverheadBytes);
+        const sandboxCpuMillis = 2_000;
+        const cpuSlots = Math.max(0, Math.floor(availableCpuMillis / sandboxCpuMillis));
+        const configuredMax = positiveInteger(this.options.maxConcurrentSandboxes, positiveInteger(process.env.FORGE_MAX_CONCURRENT_SANDBOXES, 3));
+        const availableForAdmissionBytes = Math.max(0, availableMemoryBytes - memoryReserveBytes);
+        const capacityLowCode = !diskLow && availableForAdmissionBytes < minimumAdmissionMemoryBytes
+            ? "docker_memory_low"
+            : !diskLow && cpuSlots <= 0
+                ? "docker_cpu_low"
+                : null;
+        const maxConcurrentSandboxes = diskLow || capacityLowCode ? 0 : Math.min(3, configuredMax, cpuSlots);
+        const unavailableCode = diskLow ? "docker_disk_low" : capacityLowCode;
+        const unavailableReason = diskLow
+            ? `Docker workspace has only ${disk.available} bytes available.`
+            : unavailableCode === "docker_memory_low"
+                ? `Docker reports ${availableMemoryBytes} bytes available and Forge reserves ${memoryReserveBytes} host bytes, leaving ${availableForAdmissionBytes} bytes for admission; the smallest supported sandbox requires ${minimumAdmissionMemoryBytes} bytes. Exact attempt memory is calculated dynamically from its worker profile, sidecars, and runtime helpers.`
+                : unavailableCode === "docker_cpu_low"
+                    ? `Docker host has ${availableCpuMillis} available CPU millis; at least ${sandboxCpuMillis} are needed for one sandbox.`
+                    : null;
+        const features = { rootless, userNamespaces, cgroupV2, seccomp, lsm, storageQuota, storagePolicy, compose, internalNetwork: true, buildkit, imagePolicy, securityProfile, egressProxy };
+        const capacityAvailable = unavailableCode === null;
+        return {
+            available: capacityAvailable,
+            healthy: capacityAvailable,
+            generation: this.generation,
+            runtimeVersion: `docker/${String(info.ServerVersion ?? "unknown")}${rootless ? "-rootless" : "-desktop"}`,
+            maxConcurrentSandboxes,
+            totalMemoryBytes,
+            availableMemoryBytes,
+            hostReserveBytes: memoryReserveBytes,
+            admissionMemoryBytes: sandboxMemoryBytes,
+            availableCpuMillis,
+            availableWorkspaceBytes: disk.available,
+            diskLow,
+            unavailableCode,
+            unavailableReason,
+            features,
+        };
+    }
+}
+const dockerMaintenanceUnavailableCodes = new Set(["docker_disk_low", "docker_memory_low", "docker_cpu_low"]);
+export function canRunDockerMaintenance(preflight) {
+    return preflight.healthy || dockerMaintenanceUnavailableCodes.has(preflight.unavailableCode ?? "");
+}
+export function evaluateDiskPressure(availableBytes, totalBytes, minimumAvailableBytes, highWatermarkPercent, lowWatermarkPercent, pressureLatched) {
+    if (availableBytes < minimumAvailableBytes)
+        return true;
+    if (!(totalBytes > 0))
+        return true;
+    const usedPercent = (1 - availableBytes / totalBytes) * 100;
+    if (usedPercent >= highWatermarkPercent)
+        return true;
+    return pressureLatched && usedPercent > lowWatermarkPercent;
+}
+export function storagePolicyAvailable(storageQuota, environment = process.env) {
+    return storageQuota || environment.FORGE_SANDBOX_DEDICATED_DISK === "true";
+}
+export class DockerContextOwnershipLock {
+    lockPath = null;
+    async acquire(contextName) {
+        if (this.lockPath)
+            return;
+        contextName = contextName?.trim() || process.env.DOCKER_CONTEXT?.trim() || process.env.DOCKER_HOST?.trim() || "default";
+        const key = createHash("sha256").update(contextName).digest("hex").slice(0, 24);
+        const lockPath = path.join(os.tmpdir(), `forge-docker-context-${key}.lock`);
+        await fs.mkdir(path.dirname(lockPath), { recursive: true });
+        try {
+            const handle = await fs.open(lockPath, "wx", 0o600);
+            await handle.writeFile(JSON.stringify({ pid: process.pid, contextName, acquiredAt: new Date().toISOString() }));
+            await handle.sync();
+            await handle.close();
+        }
+        catch (error) {
+            const owner = await readLock(lockPath);
+            if (owner?.pid && !processExists(owner.pid)) {
+                await fs.rm(lockPath, { force: true });
+                return await this.acquire(contextName);
+            }
+            throw new Error(`docker_context_owned: Docker context '${contextName}' is already owned by Forge runner pid ${owner?.pid ?? "unknown"}.`, { cause: error });
+        }
+        this.lockPath = lockPath;
+    }
+    async release() {
+        if (!this.lockPath)
+            return;
+        await fs.rm(this.lockPath, { force: true });
+        this.lockPath = null;
+    }
+}
+function parseInfo(stdout) {
+    try {
+        const value = JSON.parse(stdout.trim());
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("not an object");
+        return value;
+    }
+    catch (error) {
+        throw new Error("Docker returned an invalid info document.", { cause: error });
+    }
+}
+function unavailable(generation, code, reason, features = {
+    rootless: false, userNamespaces: false, cgroupV2: false, seccomp: false, lsm: false, storageQuota: false, storagePolicy: false, compose: false, internalNetwork: false, buildkit: false, imagePolicy: false, securityProfile: false, egressProxy: false
+}) {
+    return {
+        available: false,
+        healthy: false,
+        generation,
+        runtimeVersion: null,
+        maxConcurrentSandboxes: 0,
+        totalMemoryBytes: os.totalmem(),
+        availableMemoryBytes: os.freemem(),
+        hostReserveBytes: defaultHostMemoryReserveBytes,
+        admissionMemoryBytes: 2 * 1024 ** 3 + 128 * 1024 ** 2,
+        availableCpuMillis: Math.max(0, (os.availableParallelism?.() ?? os.cpus().length) * 1000),
+        availableWorkspaceBytes: 0,
+        diskLow: code === "docker_disk_low",
+        unavailableCode: code,
+        unavailableReason: singleLine(reason),
+        features,
+    };
+}
+async function diskSpace(inputPath) {
+    const stats = await fs.statfs(inputPath, { bigint: true }).catch(() => null);
+    if (!stats)
+        return { available: 0, total: 0 };
+    return {
+        available: safeNumber(stats.bavail * stats.bsize),
+        total: safeNumber(stats.blocks * stats.bsize),
+    };
+}
+function safeNumber(value) {
+    return Number(value > BigInt(Number.MAX_SAFE_INTEGER) ? BigInt(Number.MAX_SAFE_INTEGER) : value);
+}
+function strings(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function positiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function singleLine(value) {
+    return value.replace(/[\r\n\t]+/gu, " ").trim().slice(0, 1000);
+}
+function nonNegativeInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+export function parseDockerMemoryUsage(value) {
+    const usage = value.split("/", 1)[0]?.trim().replaceAll(" ", "") ?? "";
+    const match = /^(\d+(?:\.\d+)?)(b|kib|mib|gib|tib)$/iu.exec(usage);
+    if (!match)
+        return 0;
+    const amount = Number(match[1]);
+    const multiplier = { b: 1, kib: 1024, mib: 1024 ** 2, gib: 1024 ** 3, tib: 1024 ** 4 }[match[2].toLowerCase()];
+    return Number.isFinite(amount) ? Math.round(amount * multiplier) : 0;
+}
+async function readLock(lockPath) {
+    return await fs.readFile(lockPath, "utf8").then((value) => JSON.parse(value)).catch(() => null);
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sandbox/process.d.ts

@@ -0,0 +1,20 @@
+export interface SandboxProcessRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd?: string;
+    readonly input?: string | Buffer;
+    readonly timeoutMs?: number;
+    readonly maxOutputBytes?: number;
+    readonly signal?: AbortSignal;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly onStdoutLine?: (line: string) => void | Promise<void>;
+    readonly terminateOnOutputLimit?: boolean;
+}
+export interface SandboxProcessResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly truncated: boolean;
+}
+export declare function runSandboxProcess(request: SandboxProcessRequest): Promise<SandboxProcessResult>;
+export declare function requireSandboxProcess(request: SandboxProcessRequest): Promise<SandboxProcessResult>;

package/dist/sandbox/process.js

@@ -0,0 +1,209 @@
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+const terminationSigkillDelayMs = 5_000;
+const forcedCloseSettleDelayMs = 5_000;
+const expectedStdinCloseErrorCodes = new Set(["EPIPE", "ECONNRESET", "ERR_STREAM_DESTROYED"]);
+function isExpectedStdinCloseError(error) {
+    return "code" in error
+        && typeof error.code === "string"
+        && expectedStdinCloseErrorCodes.has(error.code);
+}
+export async function runSandboxProcess(request) {
+    const limit = Math.max(1024, request.maxOutputBytes ?? 1024 * 1024);
+    return await new Promise((resolve, reject) => {
+        const child = spawn(request.command, [...request.args], {
+            cwd: request.cwd,
+            env: request.env,
+            shell: false,
+            windowsHide: true,
+            stdio: [request.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+        });
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let truncated = false;
+        let settled = false;
+        let terminating = false;
+        let discardStdoutLineCallbacks = false;
+        let stdoutText = "";
+        const stdoutDecoder = new StringDecoder("utf8");
+        let stdoutLineChain = Promise.resolve();
+        let stdoutLineError = null;
+        let timeout = null;
+        let sigkillTimer = null;
+        let forcedSettleTimer = null;
+        const append = (current, chunk) => {
+            if (current.length >= limit) {
+                truncated = true;
+                return current;
+            }
+            const remaining = limit - current.length;
+            if (chunk.length > remaining) {
+                truncated = true;
+                if (request.terminateOnOutputLimit)
+                    terminate(`sandbox_log_limit: process output exceeded ${limit} bytes`);
+            }
+            return Buffer.concat([current, chunk.subarray(0, remaining)]);
+        };
+        const appendStderrLine = (line) => {
+            stderr = append(stderr, Buffer.from(`\n${line}\n`));
+        };
+        const cleanup = () => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (sigkillTimer)
+                clearTimeout(sigkillTimer);
+            if (forcedSettleTimer)
+                clearTimeout(forcedSettleTimer);
+            child.stdout.removeListener("data", onStdoutData);
+            child.stderr.removeListener("data", onStderrData);
+            child.removeListener("error", onProcessError);
+            child.removeListener("close", onProcessClose);
+            request.signal?.removeEventListener("abort", abort);
+        };
+        const settle = async (code, force) => {
+            if (settled)
+                return;
+            settled = true;
+            discardStdoutLineCallbacks = force;
+            cleanup();
+            if (stdoutLineError) {
+                reject(stdoutLineError);
+                return;
+            }
+            if (!force) {
+                if (request.onStdoutLine)
+                    stdoutText += stdoutDecoder.end();
+                if (request.onStdoutLine && stdoutText) {
+                    stdoutLineChain = stdoutLineChain.then(() => request.onStdoutLine(stdoutText));
+                }
+                await stdoutLineChain.catch(error => { stdoutLineError ??= error; });
+                if (stdoutLineError) {
+                    reject(stdoutLineError);
+                    return;
+                }
+            }
+            resolve({
+                exitCode: code ?? 1,
+                stdout: stdout.toString("utf8"),
+                stderr: stderr.toString("utf8"),
+                truncated
+            });
+        };
+        const forceSettle = (reason) => {
+            if (settled)
+                return;
+            appendStderrLine(reason);
+            void settle(1, true);
+        };
+        const killChild = (signal) => {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            try {
+                child.kill(signal);
+            }
+            catch {
+                // The process may have exited between timeout/abort and close. Still let the
+                // supervisor timers settle if close never arrives.
+            }
+        };
+        const terminate = (reason) => {
+            if (settled || terminating)
+                return;
+            terminating = true;
+            appendStderrLine(reason);
+            killChild("SIGTERM");
+            sigkillTimer = setTimeout(() => {
+                killChild("SIGKILL");
+                forcedSettleTimer = setTimeout(() => forceSettle("process did not close after SIGKILL; forcing supervisor settlement"), forcedCloseSettleDelayMs);
+                forcedSettleTimer.unref?.();
+            }, terminationSigkillDelayMs);
+            sigkillTimer.unref?.();
+        };
+        const abort = () => terminate(String(request.signal?.reason ?? "process aborted"));
+        const onStdoutData = (chunk) => {
+            if (settled)
+                return;
+            stdout = append(stdout, chunk);
+            if (!request.onStdoutLine || settled)
+                return;
+            stdoutText += stdoutDecoder.write(chunk);
+            if (Buffer.byteLength(stdoutText, "utf8") > 1024 * 1024 && !stdoutText.includes("\n")) {
+                stdoutLineError = new Error("sandbox process emitted an oversized stdout line");
+                terminate("oversized stdout line");
+                return;
+            }
+            const lines = stdoutText.split(/\r?\n/u);
+            stdoutText = lines.pop() ?? "";
+            if (lines.length === 0)
+                return;
+            child.stdout.pause();
+            for (const line of lines) {
+                stdoutLineChain = stdoutLineChain.then(async () => {
+                    if (discardStdoutLineCallbacks)
+                        return;
+                    if (Buffer.byteLength(line, "utf8") > 1024 * 1024)
+                        throw new Error("sandbox process emitted an oversized stdout line");
+                    await request.onStdoutLine(line);
+                });
+            }
+            stdoutLineChain = stdoutLineChain
+                .catch(error => {
+                stdoutLineError = error;
+                terminate("stdout event handler failed");
+            })
+                .finally(() => {
+                if (!settled)
+                    child.stdout.resume();
+            });
+        };
+        const onStderrData = (chunk) => {
+            if (!settled)
+                stderr = append(stderr, chunk);
+        };
+        const onProcessError = (error) => {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                reject(error);
+            }
+        };
+        const onStdinError = (error) => {
+            if (isExpectedStdinCloseError(error))
+                return;
+            onProcessError(error);
+        };
+        const onProcessClose = (code) => {
+            void settle(code, false);
+        };
+        child.stdout.on("data", onStdoutData);
+        child.stderr.on("data", onStderrData);
+        child.on("error", onProcessError);
+        child.on("close", onProcessClose);
+        // Keep this listener for the lifetime of stdin. A pipe error can be emitted
+        // after the child close event has settled the supervisor promise.
+        child.stdin?.on("error", onStdinError);
+        timeout = request.timeoutMs
+            ? setTimeout(() => terminate(`process timeout after ${request.timeoutMs}ms`), request.timeoutMs)
+            : null;
+        timeout?.unref?.();
+        request.signal?.addEventListener("abort", abort, { once: true });
+        if (request.signal?.aborted) {
+            abort();
+        }
+        if (request.input !== undefined) {
+            try {
+                child.stdin.end(request.input);
+            }
+            catch (error) {
+                onStdinError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    });
+}
+export async function requireSandboxProcess(request) {
+    const result = await runSandboxProcess(request);
+    if (result.exitCode !== 0) {
+        throw new Error(`${request.command} ${request.args[0] ?? ""} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`}`);
+    }
+    return result;
+}

package/dist/sandbox/provider-auth/codex.d.ts

@@ -0,0 +1,26 @@
+export interface SandboxAuthDoctorResult {
+    readonly available: boolean;
+    readonly code: "ok" | "sandbox_auth_unavailable";
+    readonly message: string;
+    readonly authPath?: string;
+}
+export interface SandboxProviderCredentialFile {
+    readonly name: string;
+    readonly contentBase64: string;
+}
+export interface SandboxPreparedProviderAuth {
+    readonly files: readonly SandboxProviderCredentialFile[];
+    readonly containerMountPath: string;
+    readonly writable: boolean;
+}
+export interface SandboxProviderAuthAdapter {
+    readonly provider: "codex";
+    readonly authKind: "bridge_cli";
+    readonly containerMountPath: string;
+    readonly writable: boolean;
+    doctor(environment?: NodeJS.ProcessEnv): SandboxAuthDoctorResult;
+    prepareAttemptAuth(environment?: NodeJS.ProcessEnv): Promise<SandboxPreparedProviderAuth>;
+}
+export declare const codexSandboxProviderAuthAdapter: SandboxProviderAuthAdapter;
+export declare function sandboxProviderAuthAdapterFor(provider: string, authKind: string): SandboxProviderAuthAdapter | null;
+export declare function sandboxProviderAuthUnavailableMessage(provider: string, authKind: string): string | null;