agencyx-cli 0.0.0-stage → 0.1.0-dev.4

package/dist/codex/options.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { fail } from "../diagnostics.js";
+import { configArguments, parseOverride } from "./toml.js";
+const CONFIG_FLAGS = {
+    "--model": "model",
+    "-m": "model",
+    "--sandbox": "sandbox_mode",
+    "-s": "sandbox_mode",
+    "--ask-for-approval": "approval_policy",
+    "-a": "approval_policy",
+};
+const VALUE_FLAGS = new Set([
+    "--config",
+    "-c",
+    "--profile",
+    "-p",
+    "--model",
+    "-m",
+    "--sandbox",
+    "-s",
+    "--ask-for-approval",
+    "-a",
+    "--enable",
+    "--disable",
+    "--cd",
+    "-C",
+    "--add-dir",
+    "--image",
+    "-i",
+    "--output-last-message",
+    "-o",
+    "--output-schema",
+    "--color",
+]);
+const SWITCHES = new Set([
+    "--no-alt-screen",
+    "--no-daemon",
+    "--search",
+    "--json",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "--help",
+    "-h",
+    "--version",
+    "-V",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--approve-for-me",
+    "--dangerously-bypass-hook-trust",
+]);
+export function parseCodexOptions(args, cwd) {
+    const options = {
+        original: [...args],
+        configArgs: [],
+        entry: "interactive",
+        frontendArgs: [],
+        addDirs: [],
+        bypassHookTrust: false,
+    };
+    let promptCount = 0;
+    for (let i = 0; i < args.length; i++) {
+        const raw = args[i];
+        if (raw === "exec" && i === 0) {
+            options.entry = "exec";
+            continue;
+        }
+        if (!raw.startsWith("-") || raw === "-") {
+            if ([
+                "resume",
+                "fork",
+                "review",
+                "app-server",
+                "mcp",
+                "login",
+                "logout",
+                "plugin",
+            ].includes(raw) &&
+                promptCount === 0)
+                fail("CODEX_ENTRY_UNSUPPORTED", "arguments", "This wrapper currently supports new interactive sessions and the native exec entry.", {}, 2);
+            if (++promptCount > 1)
+                fail("CODEX_ARGUMENT_UNSUPPORTED", "arguments", "Use a single native prompt argument, or stdin with the native exec entry.", {}, 2);
+            options.frontendArgs.push(raw);
+            continue;
+        }
+        const equals = raw.indexOf("=");
+        const attachedShort = /^-[cmpisaC].+/.test(raw) && !raw.startsWith("--");
+        const flag = attachedShort
+            ? raw.slice(0, 2)
+            : equals < 0
+                ? raw
+                : raw.slice(0, equals);
+        const inline = attachedShort
+            ? raw.slice(2)
+            : equals < 0
+                ? undefined
+                : raw.slice(equals + 1);
+        if (VALUE_FLAGS.has(flag)) {
+            const value = inline ?? args[++i];
+            if (value === undefined || value.includes("\0"))
+                fail("CODEX_ARGUMENT_INVALID", "arguments", "A native option is missing a valid value.", { field: flag }, 2);
+            if (flag === "--config" || flag === "-c") {
+                parseOverride(value);
+                options.configArgs.push("-c", value);
+            }
+            else if (flag === "--profile" || flag === "-p") {
+                if (!/^[A-Za-z0-9_-]+$/.test(value))
+                    fail("CODEX_ARGUMENT_INVALID", "arguments", "The native Codex profile name contains unsupported characters.", { field: flag }, 2);
+                options.nativeProfile = value;
+            }
+            else if (CONFIG_FLAGS[flag])
+                options.configArgs.push(...configArguments({ [CONFIG_FLAGS[flag]]: value }));
+            else if (flag === "--enable" || flag === "--disable")
+                options.configArgs.push(...configArguments({ features: { [value]: flag === "--enable" } }));
+            else if (flag === "--cd" || flag === "-C") {
+                if (path.resolve(cwd, value) !== path.resolve(cwd))
+                    fail("CWD_MISMATCH", "arguments", "Agency and Codex must resolve the same workspace. Run agencyx from the intended directory.", { field: flag }, 2);
+            }
+            else if (flag === "--add-dir")
+                options.addDirs.push(path.resolve(cwd, value));
+            else if (flag === "--image" || flag === "-i")
+                options.frontendArgs.push(flag, value);
+        }
+        else if (SWITCHES.has(flag) && inline === undefined) {
+            if (flag === "--search")
+                options.configArgs.push(...configArguments({ web_search: "live" }));
+            else if (flag === "--dangerously-bypass-approvals-and-sandbox")
+                options.configArgs.push(...configArguments({
+                    sandbox_mode: "danger-full-access",
+                    approval_policy: "never",
+                }));
+            else if (flag === "--approve-for-me")
+                options.configArgs.push(...configArguments({
+                    sandbox_mode: "workspace-write",
+                    approvals_reviewer: "auto_review",
+                }));
+            else if (flag === "--dangerously-bypass-hook-trust") {
+                options.bypassHookTrust = true;
+                options.configArgs.push(flag);
+            }
+            else if (flag === "--no-alt-screen")
+                options.frontendArgs.push(flag);
+        }
+        else {
+            fail("CODEX_ARGUMENT_UNSUPPORTED", "arguments", "This native option has not been validated with the wrapper configuration and session handoff.", { field: flag }, 2);
+        }
+    }
+    return options;
+}
+export function mergedOverrides(left, right) {
+    const result = { ...left };
+    for (const [key, value] of Object.entries(right)) {
+        const previous = Object.hasOwn(result, key) ? result[key] : undefined;
+        const next = typeof previous === "object" &&
+            previous !== null &&
+            !Array.isArray(previous) &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)
+            ? mergedOverrides(previous, value)
+            : value;
+        // Configuration names are data, including the literal key "__proto__".
+        Object.defineProperty(result, key, {
+            value: next,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=options.js.map

package/dist/codex/plugin-hooks.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { readJsonFile } from "../agency/prepared-input.js";
+import { fail } from "../diagnostics.js";
+import { isRecord, record } from "../validation.js";
+export function sessionHookCommand(handler, resourceRoot, platform = process.platform) {
+    if (platform === "win32") {
+        const root = `'${resourceRoot.replaceAll("'", "''")}'`;
+        const command = handler.command_windows ?? handler.powershell ?? handler.command;
+        return `$env:CLAUDE_PLUGIN_ROOT = ${root}; $CLAUDE_PLUGIN_ROOT = $env:CLAUDE_PLUGIN_ROOT; $env:CODEX_PLUGIN_ROOT = $env:CLAUDE_PLUGIN_ROOT; $CODEX_PLUGIN_ROOT = $env:CLAUDE_PLUGIN_ROOT; ${String(command)}`;
+    }
+    const root = `'${resourceRoot.replaceAll("'", "'\\''")}'`;
+    return `export CLAUDE_PLUGIN_ROOT=${root} CODEX_PLUGIN_ROOT=${root}; ${String(handler.command)}`;
+}
+export async function prepareSessionHooks(packages, inspection) {
+    const bindings = [];
+    const groups = [];
+    if (!packages.some(({ spec }) => spec.hooks.some((hook) => hook.count > 0)))
+        return { bindings, overrides: {} };
+    if (isRecord(inspection.config?.features) &&
+        inspection.config.features.hooks === false)
+        fail("PLUGIN_HOOK_RUNTIME_DISABLED", "compatibility", "Native hooks are disabled in the effective Codex configuration.");
+    if (inspection.sessionOverrides === undefined)
+        fail("PLUGIN_HOOK_SOURCE_UNVERIFIED", "compatibility", "Codex must report its session configuration layer to preserve existing inline hooks.");
+    const previous = isRecord(inspection.sessionOverrides.hooks)
+        ? inspection.sessionOverrides.hooks.SessionStart
+        : undefined;
+    if (previous !== undefined) {
+        if (!Array.isArray(previous))
+            fail("PLUGIN_HOOK_SOURCE_UNVERIFIED", "compatibility", "The existing inline SessionStart hooks have an unsupported shape.");
+        groups.push(...previous.map((group) => record(group, "native inline hook group")));
+    }
+    for (const { spec, resourceRoot } of packages) {
+        for (const hook of spec.hooks) {
+            if (!hook.count)
+                continue;
+            const source = path.join(resourceRoot, path.relative(spec.root, hook.file));
+            const document = record(await readJsonFile(source), "plugin hooks");
+            const events = record(document.hooks, "plugin hook events");
+            for (const raw of events.SessionStart) {
+                const group = record(raw, "hook group");
+                const handlers = [];
+                for (const rawHandler of group.hooks) {
+                    const handler = record(rawHandler, "hook handler");
+                    const command = sessionHookCommand(handler, resourceRoot);
+                    const { powershell: _powershell, command_windows: _windows, ...native } = handler;
+                    handlers.push({ ...native, command });
+                    bindings.push({
+                        pluginName: spec.name,
+                        sourcePath: hook.file,
+                        command,
+                        ...(typeof group.matcher === "string"
+                            ? { matcher: group.matcher }
+                            : {}),
+                    });
+                }
+                groups.push({ ...group, hooks: handlers });
+            }
+        }
+    }
+    return { bindings, overrides: { hooks: { SessionStart: groups } } };
+}
+export function verifySessionHooks(bindings, inspection) {
+    const expected = new Map();
+    for (const binding of bindings) {
+        const key = JSON.stringify([binding.command, binding.matcher ?? null]);
+        const previous = expected.get(key);
+        expected.set(key, { binding, count: (previous?.count ?? 0) + 1 });
+    }
+    for (const { binding, count } of expected.values()) {
+        const hooks = inspection.hooks.filter((hook) => hook.pluginId === null &&
+            hook.eventName.toLowerCase() === "sessionstart" &&
+            hook.command === binding.command &&
+            (hook.matcher ?? null) === (binding.matcher ?? null));
+        if (hooks.length !== count || hooks.some((hook) => !hook.enabled))
+            fail("PLUGIN_HOOK_MISSING", "compatibility", "A required session hook was omitted, duplicated or disabled by native discovery.", { component: binding.pluginName, path: binding.sourcePath });
+        if (hooks.some((hook) => !["trusted", "managed"].includes(hook.trustStatus)))
+            fail("PLUGIN_HOOK_UNTRUSTED", "compatibility", "The required hook needs native Codex trust review. Review the hook first; an explicitly supplied native --dangerously-bypass-hook-trust applies only to that invocation. The wrapper never enables it automatically.", { component: binding.pluginName, path: binding.sourcePath });
+    }
+}
+export function hookTrustOverrides(inspection) {
+    const state = Object.create(null);
+    for (const hook of inspection.hooks) {
+        if (!hook.enabled ||
+            ["trusted", "managed"].includes(hook.trustStatus) ||
+            hook.isManaged)
+            continue;
+        if (!hook.key || !hook.currentHash)
+            fail("CODEX_HOOK_TRUST_OVERRIDE_UNSUPPORTED", "compatibility", "Codex did not report the native hook key and content hash required for an explicit session-only hook-trust override.");
+        state[hook.key] = { trusted_hash: hook.currentHash };
+    }
+    return Object.keys(state).length ? { hooks: { state } } : {};
+}
+//# sourceMappingURL=plugin-hooks.js.map

package/dist/codex/rpc.js

@@ -0,0 +1,170 @@
+import { Duplex } from "node:stream";
+import { EventEmitter } from "node:events";
+import WebSocket from "ws";
+import { AgencyxError } from "../diagnostics.js";
+import { isRecord } from "../validation.js";
+import { JsonLinePeer } from "../runtime/ipc.js";
+export class RpcError extends AgencyxError {
+    rpcCode;
+    constructor(rpcCode, method) {
+        super({
+            code: rpcCode === -32601
+                ? "CODEX_PROTOCOL_UNSUPPORTED"
+                : "CODEX_REQUEST_FAILED",
+            stage: "codex",
+            reason: `The official app-server could not complete ${method}. Raw server error text was withheld.`,
+        }, 6);
+        this.rpcCode = rpcCode;
+    }
+}
+export class RpcClient extends EventEmitter {
+    connection;
+    nextId = 1;
+    pending = new Map();
+    closed = false;
+    constructor(connection) {
+        super();
+        this.connection = connection;
+        connection.events.on("message", (message) => this.receive(message));
+        connection.events.on("closed", () => this.disconnect());
+        connection.events.on("fault", () => this.disconnect());
+    }
+    receive(message) {
+        if (!isRecord(message)) {
+            this.disconnect();
+            return;
+        }
+        if (typeof message.method === "string") {
+            if (message.id !== undefined) {
+                // Never invent an approval decision while the original frontend is absent.
+                this.connection.send({
+                    id: message.id,
+                    error: {
+                        code: -32601,
+                        message: "No interactive frontend is attached to this preparation client.",
+                    },
+                });
+            }
+            else
+                this.emit("notification", message);
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const request = this.pending.get(message.id);
+        if (!request)
+            return;
+        clearTimeout(request.timer);
+        this.pending.delete(message.id);
+        if (isRecord(message.error))
+            request.reject(new RpcError(typeof message.error.code === "number"
+                ? message.error.code
+                : undefined, "request"));
+        else if (Object.hasOwn(message, "result"))
+            request.resolve(message.result);
+        else
+            request.reject(new RpcError(undefined, "malformed response"));
+    }
+    request(method, params, timeoutMs = 15_000) {
+        if (this.closed)
+            return Promise.reject(new RpcError(undefined, method));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new AgencyxError({
+                    code: "CODEX_REQUEST_TIMEOUT",
+                    stage: "codex",
+                    reason: `The official app-server did not answer ${method} in time.`,
+                }, 6));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.connection.send({ id, method, params });
+            }
+            catch {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(new RpcError(undefined, method));
+            }
+        });
+    }
+    notify(method, params) {
+        if (!this.closed)
+            this.connection.send({ method, params });
+    }
+    async initialize() {
+        const result = await this.request("initialize", {
+            clientInfo: { name: "agencyx", version: "0.1.0" },
+            capabilities: { experimentalApi: true },
+        });
+        this.notify("initialized", {});
+        return result;
+    }
+    disconnect() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const request of this.pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(new RpcError(undefined, "connection"));
+        }
+        this.pending.clear();
+        this.emit("closed");
+    }
+    close() {
+        this.disconnect();
+        this.connection.close();
+    }
+}
+export function stdioClient(running) {
+    const duplex = Duplex.from({
+        readable: running.child.stdout,
+        writable: running.child.stdin,
+    });
+    const peer = new JsonLinePeer(duplex);
+    void running.completion.then(() => duplex.destroy(), () => duplex.destroy());
+    return new RpcClient({
+        events: peer,
+        send: (value) => peer.send(value),
+        close: () => duplex.destroy(),
+    });
+}
+export async function websocketClient(endpoint, token, timeoutMs = 2_000) {
+    const socket = new WebSocket(endpoint, {
+        headers: { Authorization: `Bearer ${token}` },
+        handshakeTimeout: timeoutMs,
+        maxPayload: 16 * 1024 * 1024,
+    });
+    const events = new EventEmitter();
+    socket.on("error", () => events.emit("fault"));
+    socket.on("close", () => events.emit("closed"));
+    socket.on("message", (data) => {
+        try {
+            events.emit("message", JSON.parse(data.toString()));
+        }
+        catch {
+            events.emit("fault");
+            socket.terminate();
+        }
+    });
+    await new Promise((resolve, reject) => {
+        const onError = () => {
+            socket.off("open", onOpen);
+            socket.terminate();
+            reject(new RpcError(undefined, "WebSocket connection"));
+        };
+        const onOpen = () => {
+            socket.off("error", onError);
+            resolve();
+        };
+        socket.once("open", onOpen);
+        socket.once("error", onError);
+    });
+    return new RpcClient({
+        events,
+        send: (value) => socket.send(JSON.stringify(value)),
+        close: () => socket.close(),
+    });
+}
+//# sourceMappingURL=rpc.js.map

package/dist/codex/session-proxy.js

@@ -0,0 +1,258 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { timingSafeEqual } from "node:crypto";
+import WebSocket, { WebSocketServer } from "ws";
+import { asDiagnostic, fail } from "../diagnostics.js";
+import { isRecord } from "../validation.js";
+import { combineInstructions } from "../adapters/instructions.js";
+import { mergedOverrides } from "./options.js";
+import { assertUserSkillInvocation, filterUserSkillCatalogue, } from "./skill-policy.js";
+const MAX_BUFFER = 16 * 1024 * 1024;
+async function sameDirectory(left, right) {
+    const [a, b] = await Promise.all([
+        realpath(left).catch(() => path.resolve(left)),
+        realpath(right).catch(() => path.resolve(right)),
+    ]);
+    return process.platform === "win32"
+        ? a.toLowerCase() === b.toLowerCase()
+        : a === b;
+}
+export async function injectSessionRequest(value, plan) {
+    if (!isRecord(value))
+        fail("CODEX_PROTOCOL_INVALID", "codex", "The frontend sent an invalid protocol message.", {}, 6);
+    assertUserSkillInvocation(value, plan.skillViews ?? []);
+    if (value.method === "skills/extraRoots/set" &&
+        (plan.skillViews?.length ?? 0) > 0) {
+        if (!isRecord(value.params) ||
+            !Array.isArray(value.params.extraRoots) ||
+            !value.params.extraRoots.every((root) => typeof root === "string"))
+            fail("CODEX_PROTOCOL_INVALID", "codex", "The frontend sent invalid native skill roots.", {}, 6);
+        return {
+            ...value,
+            params: {
+                ...value.params,
+                extraRoots: [
+                    ...new Set([
+                        ...value.params.extraRoots,
+                        ...plan.skillViews.flatMap((view) => view.extraRoots),
+                    ]),
+                ],
+            },
+        };
+    }
+    if (value.method === "thread/resume" || value.method === "thread/fork")
+        fail("CODEX_ENTRY_UNSUPPORTED", "compatibility", "This Agency session supports new Codex threads. Resume and fork require a separately verified resource contract.");
+    if (value.method !== "thread/start")
+        return value;
+    const params = value.params === null || value.params === undefined ? {} : value.params;
+    if (!isRecord(params) ||
+        (params.config !== undefined &&
+            params.config !== null &&
+            !isRecord(params.config)))
+        fail("CODEX_PROTOCOL_INVALID", "codex", "The frontend sent invalid thread configuration.", {}, 6);
+    if (params.cwd !== undefined &&
+        params.cwd !== null &&
+        (typeof params.cwd !== "string" ||
+            !(await sameDirectory(params.cwd, plan.cwd))))
+        fail("CWD_MISMATCH", "compatibility", "A new thread cannot change the workspace after Agency prepared its resources.");
+    const next = {
+        ...params,
+        cwd: plan.cwd,
+        config: mergedOverrides(isRecord(params.config) ? params.config : {}, plan.overrides),
+    };
+    if (plan.developerInstructions !== undefined) {
+        if (params.developerInstructions !== undefined &&
+            params.developerInstructions !== null &&
+            typeof params.developerInstructions !== "string")
+            fail("CODEX_PROTOCOL_INVALID", "codex", "The frontend sent invalid developer instructions.", {}, 6);
+        const instructions = typeof params.developerInstructions === "string"
+            ? combineInstructions(params.developerInstructions, plan.additionalDeveloperInstructions
+                ? [plan.additionalDeveloperInstructions]
+                : [], {})
+            : plan.developerInstructions;
+        if (instructions !== undefined)
+            Object.assign(next, { developerInstructions: instructions });
+    }
+    return { ...value, params: next };
+}
+export async function createSessionProxy(backendEndpoint, backendToken, frontendToken, plan) {
+    let failure;
+    let active = false;
+    const connections = new Set();
+    const expected = Buffer.from(`Bearer ${frontendToken}`);
+    const server = new WebSocketServer({
+        host: "127.0.0.1",
+        port: 0,
+        maxPayload: MAX_BUFFER,
+        verifyClient: ({ req }) => {
+            const actual = Buffer.from(req.headers.authorization ?? "");
+            return (!req.headers.origin &&
+                actual.length === expected.length &&
+                timingSafeEqual(actual, expected));
+        },
+    });
+    await new Promise((resolve, reject) => {
+        server.once("listening", resolve);
+        server.once("error", reject);
+    });
+    server.on("error", () => {
+        failure = {
+            code: "CODEX_PROXY_FAILED",
+            stage: "codex",
+            reason: "The private frontend connection failed.",
+        };
+    });
+    server.on("connection", (frontend) => {
+        if (active) {
+            frontend.close(1008, "One frontend per Agency session.");
+            return;
+        }
+        active = true;
+        connections.add(frontend);
+        const backend = new WebSocket(backendEndpoint, {
+            headers: { Authorization: `Bearer ${backendToken}` },
+            maxPayload: MAX_BUFFER,
+            handshakeTimeout: 5_000,
+        });
+        connections.add(backend);
+        const skillListRequests = new Set();
+        const opened = new Promise((resolve, reject) => {
+            backend.once("open", resolve);
+            backend.once("error", reject);
+        });
+        void opened.catch(() => undefined);
+        const end = () => {
+            frontend.terminate();
+            backend.terminate();
+            connections.delete(frontend);
+            connections.delete(backend);
+        };
+        frontend.on("error", end);
+        backend.on("error", () => {
+            failure = {
+                code: "CODEX_BACKEND_CONNECTION_FAILED",
+                stage: "codex",
+                reason: "The private backend connection failed.",
+            };
+            end();
+        });
+        frontend.on("close", end);
+        backend.on("close", end);
+        backend.on("message", (data, binary) => {
+            if (frontend.readyState !== WebSocket.OPEN)
+                return;
+            if (frontend.bufferedAmount > MAX_BUFFER) {
+                failure = {
+                    code: "CODEX_PROXY_BUFFER_LIMIT",
+                    stage: "codex",
+                    reason: "The frontend exceeded its bounded transport buffer.",
+                };
+                end();
+                return;
+            }
+            // Only frontend skill-menu responses are adapted. Backend discovery,
+            // approvals, model events and tool results retain their native data.
+            let outgoing = data;
+            if (!binary && skillListRequests.size) {
+                let response;
+                try {
+                    response = JSON.parse(data.toString());
+                }
+                catch {
+                    response = undefined;
+                }
+                if (isRecord(response) &&
+                    (typeof response.id === "number" ||
+                        typeof response.id === "string") &&
+                    skillListRequests.delete(response.id)) {
+                    const filtered = filterUserSkillCatalogue(response, plan.skillViews ?? []);
+                    if (filtered !== response)
+                        outgoing = Buffer.from(JSON.stringify(filtered));
+                }
+            }
+            frontend.send(outgoing, { binary });
+        });
+        let ordered = Promise.resolve();
+        let queuedBytes = 0;
+        frontend.on("message", (data, binary) => {
+            const bytes = Buffer.byteLength(data.toString());
+            queuedBytes += bytes;
+            if (queuedBytes > MAX_BUFFER) {
+                failure = {
+                    code: "CODEX_PROXY_BUFFER_LIMIT",
+                    stage: "codex",
+                    reason: "The frontend exceeded its bounded request queue.",
+                };
+                end();
+                return;
+            }
+            ordered = ordered
+                .then(async () => {
+                await opened;
+                if (binary)
+                    fail("CODEX_PROTOCOL_INVALID", "codex", "Binary protocol frames are not supported.", {}, 6);
+                let value;
+                try {
+                    value = JSON.parse(data.toString());
+                }
+                catch {
+                    fail("CODEX_PROTOCOL_INVALID", "codex", "The frontend sent invalid JSON.", {}, 6);
+                }
+                try {
+                    const injected = await injectSessionRequest(value, plan);
+                    if (isRecord(value) &&
+                        value.method === "skills/list" &&
+                        (typeof value.id === "number" || typeof value.id === "string"))
+                        skillListRequests.add(value.id);
+                    if (backend.bufferedAmount > MAX_BUFFER)
+                        fail("CODEX_PROXY_BUFFER_LIMIT", "codex", "The backend exceeded its bounded transport buffer.", {}, 6);
+                    if (backend.readyState === WebSocket.OPEN)
+                        backend.send(injected === value ? data : JSON.stringify(injected), { binary: false });
+                }
+                catch (error) {
+                    const diagnostic = asDiagnostic(error);
+                    if (isRecord(value) &&
+                        value.id !== undefined &&
+                        frontend.readyState === WebSocket.OPEN)
+                        frontend.send(JSON.stringify({
+                            id: value.id,
+                            error: {
+                                code: -32602,
+                                message: `${diagnostic.code}: ${diagnostic.reason}`,
+                            },
+                        }));
+                    else {
+                        failure = diagnostic;
+                        end();
+                    }
+                }
+            })
+                .catch(() => {
+                failure = {
+                    code: "CODEX_PROXY_FAILED",
+                    stage: "codex",
+                    reason: "The private frontend protocol connection failed.",
+                };
+                end();
+            })
+                .finally(() => {
+                queuedBytes -= bytes;
+            });
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        fail("BACKEND_ADDRESS_INVALID", "codex", "The private frontend proxy did not return a loopback address.", {}, 6);
+    }
+    return {
+        endpoint: `ws://127.0.0.1:${address.port}`,
+        failure: () => failure,
+        close: async () => {
+            for (const connection of connections)
+                connection.terminate();
+            await new Promise((resolve) => server.close(() => resolve()));
+        },
+    };
+}
+//# sourceMappingURL=session-proxy.js.map