@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
108 lines (105 loc) • 6.21 kB
text/typescript
import { spawn } from "node:child_process";
import { statSync } from "node:fs";
import { isAbsolute } from "node:path";
import { validatedCodexExecInvocationAsync } from "../codex/exec-boundary";
import { MessageBudget } from "./budget";
import { isRecord } from "./types";
export interface QueueMcpOptions { codex: string; codexHome: string; allowReplyRead?: boolean; allowResume?: boolean; resumeSocket?: string; resumePermissions?: string }
export type QueueRpcResult = { status: "response"; result: Record<string, unknown> }
| { status: "not_sent" | "unknown"; error: { code: string } };
/** Execute only explicit stored-thread RPCs; bodies never enter argv or diagnostics. */
export async function queueMcpRpc(options: QueueMcpOptions, method: "thread/list" | "thread/queue/add" | "thread/items/list" | "thread/items/read" | "thread/turns/list",
params: Record<string, unknown>, signal?: AbortSignal, onOutcomeBeforeCleanup?: () => void): Promise<QueueRpcResult> {
const reads = ["thread/items/list", "thread/items/read", "thread/turns/list"];
if (!["thread/list", "thread/queue/add", ...reads].includes(method) || (reads.includes(method) && !options.allowReplyRead)) {
return { status: "not_sent", error: { code: "queue_mcp_method_not_allowed" } };
}
const budget = new MessageBudget(20_000, signal);
try {
budget.throwIfEnded();
if (process.platform === "win32" || !isAbsolute(options.codex) || !isAbsolute(options.codexHome)
|| !statSync(options.codexHome).isDirectory()) {
return { status: "not_sent", error: { code: "unsupported_queue_mcp_environment" } };
}
const env: NodeJS.ProcessEnv = { ...process.env, CODEX_HOME: options.codexHome };
delete env.CODEX_THREAD_ID;
const invocation = await validatedCodexExecInvocationAsync(options.codex, ["app-server", "--listen", "stdio://"],
{ env, cwd: options.codexHome, signal: budget.signal, verifyAnyAppBundle: true });
budget.throwIfEnded();
return await new Promise<QueueRpcResult>(resolve => {
const child = spawn(invocation.file, invocation.args, {
...invocation.options, env, cwd: options.codexHome, detached: true, stdio: ["pipe", "pipe", "ignore"],
});
const decoder = new TextDecoder("utf-8", { fatal: true });
let pending = "", bytes = 0, submitted = false, stage = "initialize";
let outcome: QueueRpcResult | undefined;
let termTimer: ReturnType<typeof setTimeout> | undefined, killTimer: ReturnType<typeof setTimeout> | undefined;
const stopGroup = (kind: NodeJS.Signals): void => {
if (!child.pid) return;
try { process.kill(-child.pid, kind); }
catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ESRCH") child.kill(kind);
}
};
const finish = (value: QueueRpcResult): void => {
if (outcome) return;
outcome = value;
onOutcomeBeforeCleanup?.();
clearTimeout(deadline);
child.stdin.end();
termTimer = setTimeout(() => stopGroup("SIGTERM"), 300);
killTimer = setTimeout(() => stopGroup("SIGKILL"), 600);
};
const fail = (code: string): void => finish({ status: submitted ? "unknown" : "not_sent", error: { code } });
const cancel = (): void => fail("queue_mcp_cancelled");
const write = (frame: unknown): void => { child.stdin.write(JSON.stringify(frame) + "\n"); };
const deadline = setTimeout(() => fail("queue_mcp_timeout"), budget.remainingMs(12_000));
budget.signal.addEventListener("abort", cancel, { once: true });
child.stdin.on("error", () => fail("queue_mcp_stdin_failed"));
child.on("error", () => fail("queue_mcp_launch_failed"));
child.stdout.on("data", (chunk: Buffer) => {
if (outcome) return;
bytes += chunk.byteLength;
if (bytes > 1024 * 1024) { fail("queue_mcp_output_limit"); return; }
try { pending += decoder.decode(chunk, { stream: true }); }
catch { fail("queue_mcp_invalid_utf8"); return; }
let newline: number;
while (!outcome && (newline = pending.indexOf("\n")) >= 0) {
const line = pending.slice(0, newline); pending = pending.slice(newline + 1);
if (!line.trim()) continue;
let frame: unknown;
try { frame = JSON.parse(line); } catch { fail("queue_mcp_invalid_json"); break; }
if (!isRecord(frame)) { fail("queue_mcp_invalid_response"); break; }
if (frame.id === undefined) continue;
if ((stage === "initialize" && frame.id !== 1) || (stage === "request" && frame.id !== 2)) {
fail("queue_mcp_mismatched_response"); break;
}
if (frame.error !== undefined) {
if (!isRecord(frame.error) || !Number.isInteger(frame.error.code) || typeof frame.error.message !== "string" || frame.result !== undefined) { fail("queue_mcp_invalid_error"); break; }
finish({ status: "not_sent", error: { code: stage === "initialize" ? "queue_mcp_initialize_rejected" : "queue_mcp_request_rejected" } });
break;
}
if (!isRecord(frame.result)) { fail("queue_mcp_invalid_response"); break; }
if (stage === "initialize") {
stage = "request";
write({ method: "initialized", params: {} });
submitted = method === "thread/queue/add";
write({ id: 2, method, params });
} else finish({ status: "response", result: frame.result });
}
});
child.on("close", () => {
clearTimeout(deadline); clearTimeout(termTimer); clearTimeout(killTimer);
budget.signal.removeEventListener("abort", cancel);
stopGroup("SIGKILL");
resolve(outcome ?? { status: submitted ? "unknown" : "not_sent", error: { code: "queue_mcp_disconnected" } });
});
if (budget.signal.aborted) cancel();
else write({ id: 1, method: "initialize", params: {
clientInfo: { name: "opencodex_queue_mcp", version: "1.0.0" }, capabilities: { experimentalApi: true, explicitGatewayOauth: true },
} });
});
} catch {
return { status: "not_sent", error: { code: "queue_mcp_preflight_failed" } };
} finally { budget.dispose(); }
}