@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.bca7d0ccee53

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;

package/dist/sandbox/provider-auth/codex.js

@@ -0,0 +1,212 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const maxCredentialFileBytes = 1024 * 1024;
+// Capability and heartbeat paths call doctor() synchronously; keep validation
+// fresh enough for auth changes without rereading auth.json for every offer.
+const authDoctorCacheTtlMs = 5_000;
+let authDoctorCache = null;
+export const codexSandboxProviderAuthAdapter = {
+    provider: "codex",
+    authKind: "bridge_cli",
+    containerMountPath: "/home/forge/.codex",
+    // Codex refreshes OAuth tokens in place, so the container mount is writable.
+    // The writable state is an attempt-scoped Docker volume copy only; no code path
+    // syncs modified container credentials back to the host ~/.codex directory.
+    writable: true,
+    doctor(environment = process.env) {
+        return codexAuthDoctor(environment);
+    },
+    async prepareAttemptAuth(environment = process.env) {
+        const doctor = codexAuthDoctor(environment);
+        if (!doctor.available || !doctor.authPath) {
+            throw new Error(`sandbox_auth_unavailable: ${doctor.message}`);
+        }
+        let content;
+        try {
+            content = await readValidatedCodexAuthFile(doctor.authPath);
+        }
+        catch (error) {
+            throw new Error(`sandbox_auth_unavailable: ${error instanceof Error ? error.message : "Codex Local CLI auth.json could not be validated."}`, { cause: error });
+        }
+        return {
+            files: [
+                {
+                    name: "auth.json",
+                    contentBase64: content.toString("base64")
+                }
+            ],
+            containerMountPath: this.containerMountPath,
+            writable: this.writable
+        };
+    }
+};
+export function sandboxProviderAuthAdapterFor(provider, authKind) {
+    if (authKind.trim().toLowerCase() !== "bridge_cli") {
+        return null;
+    }
+    return provider.trim().toLowerCase() === "codex"
+        ? codexSandboxProviderAuthAdapter
+        : null;
+}
+export function sandboxProviderAuthUnavailableMessage(provider, authKind) {
+    if (authKind.trim().toLowerCase() !== "bridge_cli") {
+        return null;
+    }
+    return provider.trim().toLowerCase() === "codex"
+        ? null
+        : `Provider ${provider} Local CLI auth is not portable into Docker yet.`;
+}
+function codexAuthDoctor(environment) {
+    const authPath = path.join(resolveCodexHome(environment), "auth.json");
+    const now = Date.now();
+    if (authDoctorCache?.authPath === authPath && authDoctorCache.expiresAt > now) {
+        return authDoctorCache.result;
+    }
+    let result;
+    try {
+        readValidatedCodexAuthFileSync(authPath);
+        result = {
+            available: true,
+            code: "ok",
+            message: "Codex Local CLI auth is portable into an attempt-scoped Docker volume.",
+            authPath
+        };
+    }
+    catch (error) {
+        result = unavailable(error instanceof Error ? error.message : "Codex Local CLI auth.json could not be validated.");
+    }
+    authDoctorCache = {
+        authPath,
+        expiresAt: now + authDoctorCacheTtlMs,
+        result
+    };
+    return result;
+}
+async function readValidatedCodexAuthFile(authPath) {
+    let pathStat;
+    try {
+        pathStat = await fsp.lstat(authPath);
+    }
+    catch {
+        throw new Error("Codex Local CLI auth is not available on the bridge host.");
+    }
+    validateCodexAuthStat(pathStat);
+    let handle;
+    try {
+        handle = await fsp.open(authPath, codexAuthOpenFlags());
+    }
+    catch (error) {
+        throw codexAuthOpenError(error);
+    }
+    try {
+        const openedStat = await handle.stat();
+        validateSameCodexAuthFile(pathStat, openedStat);
+        validateCodexAuthStat(openedStat);
+        const content = await handle.readFile();
+        const afterStat = await handle.stat();
+        validateSameCodexAuthFile(openedStat, afterStat);
+        validateCodexAuthStat(afterStat);
+        validateCodexAuthReadSize(content, openedStat, afterStat);
+        validateCodexAuthJson(content);
+        return content;
+    }
+    finally {
+        await handle.close();
+    }
+}
+function readValidatedCodexAuthFileSync(authPath) {
+    let pathStat;
+    try {
+        pathStat = fs.lstatSync(authPath);
+    }
+    catch {
+        throw new Error("Codex Local CLI auth is not available on the bridge host.");
+    }
+    validateCodexAuthStat(pathStat);
+    let fd;
+    try {
+        fd = fs.openSync(authPath, codexAuthOpenFlags());
+    }
+    catch (error) {
+        throw codexAuthOpenError(error);
+    }
+    try {
+        const openedStat = fs.fstatSync(fd);
+        validateSameCodexAuthFile(pathStat, openedStat);
+        validateCodexAuthStat(openedStat);
+        const content = fs.readFileSync(fd);
+        const afterStat = fs.fstatSync(fd);
+        validateSameCodexAuthFile(openedStat, afterStat);
+        validateCodexAuthStat(afterStat);
+        validateCodexAuthReadSize(content, openedStat, afterStat);
+        validateCodexAuthJson(content);
+        return content;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function codexAuthOpenFlags() {
+    return fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW;
+}
+function validateCodexAuthStat(stat) {
+    if (stat.isSymbolicLink()) {
+        throw new Error("Codex Local CLI auth.json must not be a symlink.");
+    }
+    if (!stat.isFile()) {
+        throw new Error("Codex Local CLI auth.json is not a regular file.");
+    }
+    if (stat.size <= 0) {
+        throw new Error("Codex Local CLI auth.json is empty.");
+    }
+    if (stat.size > maxCredentialFileBytes) {
+        throw new Error("Codex Local CLI auth.json exceeds the 1 MiB sandbox auth limit.");
+    }
+}
+function validateSameCodexAuthFile(before, after) {
+    if (before.dev !== 0 && before.ino !== 0 && after.dev !== 0 && after.ino !== 0
+        && (before.dev !== after.dev || before.ino !== after.ino)) {
+        throw new Error("Codex Local CLI auth.json changed while being copied.");
+    }
+}
+function validateCodexAuthReadSize(content, openedStat, afterStat) {
+    if (openedStat.size !== afterStat.size || content.length !== afterStat.size) {
+        throw new Error("Codex Local CLI auth.json changed while being copied.");
+    }
+}
+function validateCodexAuthJson(content) {
+    try {
+        JSON.parse(content.toString("utf8"));
+    }
+    catch {
+        throw new Error("Codex Local CLI auth.json is not valid JSON.");
+    }
+}
+function codexAuthOpenError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? error.code
+        : undefined;
+    if (code === "ELOOP") {
+        return new Error("Codex Local CLI auth.json must not be a symlink.");
+    }
+    if (code === "ENOENT") {
+        return new Error("Codex Local CLI auth is not available on the bridge host.");
+    }
+    if (code === "EACCES" || code === "EPERM") {
+        return new Error("Codex Local CLI auth.json could not be read.");
+    }
+    return error instanceof Error ? error : new Error("Codex Local CLI auth.json could not be read.");
+}
+function unavailable(message) {
+    return {
+        available: false,
+        code: "sandbox_auth_unavailable",
+        message
+    };
+}
+function resolveCodexHome(environment) {
+    const configured = environment.FORGE_CODEX_HOME?.trim();
+    return configured ? path.resolve(configured) : path.join(os.homedir(), ".codex");
+}

package/dist/sandbox/repository-lock.d.ts

@@ -0,0 +1,5 @@
+export declare class RepositoryCoordinatorLock {
+    private readonly stateRoot;
+    constructor(stateRoot: string);
+    withLock<T>(repoPath: string, action: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+}

package/dist/sandbox/repository-lock.js

@@ -0,0 +1,119 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+const LOCK_HEARTBEAT_INTERVAL_MS = 30_000;
+const LOCK_STALE_AFTER_MS = 2 * 60_000;
+export class RepositoryCoordinatorLock {
+    stateRoot;
+    constructor(stateRoot) {
+        this.stateRoot = stateRoot;
+    }
+    async withLock(repoPath, action, signal) {
+        const resolved = path.resolve(repoPath);
+        const key = createHash("sha256").update(resolved.toLowerCase()).digest("hex");
+        const root = path.join(this.stateRoot, "repo-locks");
+        const target = path.join(root, `${key}.lock`);
+        const token = randomUUID();
+        await fs.mkdir(root, { recursive: true, mode: 0o700 });
+        const started = Date.now();
+        while (true) {
+            if (signal?.aborted)
+                throw new Error("sandbox_import_cancelled: repository coordination was cancelled.");
+            try {
+                const handle = await fs.open(target, "wx", 0o600);
+                try {
+                    await handle.writeFile(`${JSON.stringify({ schemaVersion: 1, token, pid: process.pid, repoPath: resolved, acquiredAt: new Date().toISOString() })}\n`);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                if (await staleLock(target)) {
+                    await fs.rm(target, { force: true });
+                    continue;
+                }
+                if (Date.now() - started >= 2 * 60_000) {
+                    throw new Error("sandbox_import_unavailable: repository coordinator lock timed out.", { cause: error });
+                }
+                await abortableDelay(50, signal);
+            }
+        }
+        const heartbeat = startHeartbeat(target, token);
+        try {
+            return await action();
+        }
+        finally {
+            clearInterval(heartbeat);
+            const owner = await readOwner(target);
+            if (owner?.token === token)
+                await fs.rm(target, { force: true });
+        }
+    }
+}
+async function staleLock(target) {
+    const stat = await fs.lstat(target).catch(() => null);
+    if (!stat || stat.isSymbolicLink() || !stat.isFile() || stat.size > 16 * 1024)
+        return true;
+    const owner = await readOwner(target);
+    if (!owner || typeof owner.pid !== "number" || !Number.isInteger(owner.pid) || owner.pid <= 0)
+        return true;
+    if (Date.now() - stat.mtimeMs >= LOCK_STALE_AFTER_MS)
+        return true;
+    try {
+        process.kill(owner.pid, 0);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function startHeartbeat(target, token) {
+    let refreshing = false;
+    const timer = setInterval(() => {
+        if (refreshing)
+            return;
+        refreshing = true;
+        void refreshHeartbeat(target, token).finally(() => { refreshing = false; });
+    }, LOCK_HEARTBEAT_INTERVAL_MS);
+    timer.unref?.();
+    return timer;
+}
+async function refreshHeartbeat(target, token) {
+    let handle = null;
+    try {
+        handle = await fs.open(target, fsConstants.O_RDWR | fsConstants.O_NOFOLLOW);
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 16 * 1024)
+            return;
+        const owner = await handle.readFile("utf8").then(value => JSON.parse(value)).catch(() => null);
+        if (owner?.token !== token)
+            return;
+        const now = new Date();
+        await handle.utimes(now, now);
+    }
+    catch {
+        // A missing or replaced lock is no longer owned by this action.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function readOwner(target) {
+    return await fs.readFile(target, "utf8").then(value => JSON.parse(value)).catch(() => null);
+}
+async function abortableDelay(delayMs, signal) {
+    if (!signal)
+        return await new Promise(resolve => setTimeout(resolve, delayMs));
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { signal.removeEventListener("abort", abort); resolve(); }, delayMs);
+        const abort = () => { clearTimeout(timer); reject(new Error("sandbox_import_cancelled: repository coordination was cancelled.")); };
+        signal.addEventListener("abort", abort, { once: true });
+        timer.unref?.();
+    });
+}