UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

388 lines (362 loc) • 14.3 kB
import { chmodSync, mkdtempSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { randomUUID } from "node:crypto"; import { findExecutableOnPath } from "./workspace-executable"; import { remoteWorkspaceProcessInvocation, removeRemoteWorkspaceIsolation, runRemoteWorkspaceCleanupSteps, stopRemoteWorkspaceProcess, waitForRemoteWorkspaceProcessExit, } from "./workspace-process"; import { startRemoteWorkspaceToolBridge } from "./workspace-tool-bridge"; import { REMOTE_WORKSPACE_DYNAMIC_TOOLS } from "./workspace-tools"; import type { RemoteWorkspaceRuntimeFactory, RemoteWorkspaceRuntimeHandle, } from "./workspace-sessions"; const MAX_JSON_LINE_BYTES = 2 * 1024 * 1024; interface PendingResponse { resolve(value: Record<string, unknown>): void; reject(error: Error): void; timer: ReturnType<typeof setTimeout>; } function record(value: unknown): Record<string, unknown> | null { return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null; } function safeError(value: unknown, fallback: string): string { return (value instanceof Error ? value.message : typeof value === "string" ? value : fallback) .replace(/[^\x20-\x7e\n\t]/g, " ") .slice(0, 4_096); } function messageText(value: unknown): string | null { const message = record(value); if (!message || message.role !== "assistant" || !Array.isArray(message.content)) return null; const text = message.content.flatMap(raw => { const part = record(raw); return part?.type === "text" && typeof part.text === "string" ? [part.text] : []; }).join(""); return text || null; } function remotePiInstructions(deviceName: string, tools: readonly string[]): string { const name = deviceName.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 120) || "remote executor"; const remoteTools = tools.map(tool => `remote_${tool}`).join(", "); return [ `You operate only on the OpenCodex remote executor named ${JSON.stringify(name)}.`, `Use only these tools for filesystem and command work: ${remoteTools}.`, "The Hub working directory is an empty isolation boundary, not the user's project.", "If a remote tool fails or the executor is offline, stop and report it. Never substitute local operations.", ].join(" "); } function extensionSource(tools: readonly string[]): string { const allowed = new Set(tools); const definitions = REMOTE_WORKSPACE_DYNAMIC_TOOLS[0].tools.filter(tool => allowed.has(tool.name)).map(tool => ({ remoteName: `remote_${tool.name}`, tool: tool.name, description: tool.description, parameters: tool.inputSchema, })); return `const definitions = ${JSON.stringify(definitions)}; const endpoint = process.env.OCX_REMOTE_WORKSPACE_BRIDGE_URL; const token = process.env.OCX_REMOTE_WORKSPACE_BRIDGE_TOKEN; export default function registerRemoteWorkspace(pi) { if (!endpoint || !token) throw new Error("Remote Workspace bridge is unavailable"); for (const definition of definitions) { pi.registerTool({ name: definition.remoteName, label: definition.remoteName, description: definition.description, parameters: definition.parameters, async execute(_toolCallId, parameters, signal) { const response = await fetch(endpoint + "/invoke", { method: "POST", headers: { "content-type": "application/json", authorization: "Bearer " + token }, body: JSON.stringify({ tool: definition.tool, arguments: parameters }), signal, }); const result = await response.json(); if (!response.ok || !result || result.success !== true) { throw new Error(result && typeof result.text === "string" ? result.text : "Remote Workspace tool failed"); } return { content: [{ type: "text", text: result.text }], details: { remote: true } }; }, }); } } `; } class PiRpcProcess { private readonly pending = new Map<string, PendingResponse>(); private nextId = 0; private closed = false; private activeSettle: { resolve(): void; reject(error: Error): void } | null = null; onEvent: ((event: Record<string, unknown>) => void) | null = null; constructor(private readonly child: Bun.Subprocess<"pipe", "pipe", "pipe">) { void this.read(); void this.drainStderr(); void child.exited.then(code => this.fail(new Error(`Pi RPC exited with code ${code}`))); } async command(type: string, fields: Record<string, unknown> = {}, timeoutMs = 15_000): Promise<Record<string, unknown>> { if (this.closed) throw new Error("Pi RPC is closed"); const id = `ocx-${++this.nextId}`; const result = new Promise<Record<string, unknown>>((resolve, reject) => { const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Pi RPC ${type} timed out`)); }, timeoutMs); this.pending.set(id, { resolve, reject, timer }); }); try { this.send({ id, type, ...fields }); } catch (error) { const pending = this.pending.get(id); if (pending) { clearTimeout(pending.timer); this.pending.delete(id); pending.reject(error instanceof Error ? error : new Error("Pi RPC write failed")); } } return result; } async prompt(message: string): Promise<void> { if (this.activeSettle) throw new Error("Pi Remote Workspace turn is already active"); const settled = new Promise<void>((resolve, reject) => { this.activeSettle = { resolve, reject }; }); const active = this.activeSettle; try { // Either operation can fail first. Observe both immediately, including an // extension error or child exit that arrives before the prompt response. await Promise.all([ this.command("prompt", { message }).then(accepted => { if (accepted.success !== true) throw new Error(safeError(accepted.error, "Pi rejected the prompt")); }), settled, ]); } finally { if (this.activeSettle === active) this.activeSettle = null; } } async abort(): Promise<void> { if (!this.activeSettle) return; await this.command("abort", {}, 3_000).catch(() => {}); } async close(): Promise<void> { try { if (!this.closed) { try { this.child.stdin.end(); } catch { /* already closed */ } } const graceful = await waitForRemoteWorkspaceProcessExit(this.child, 1_500); if (!graceful) { await stopRemoteWorkspaceProcess(this.child); } } finally { // Active and pending RPC waiters cannot survive a failed process teardown. this.fail(new Error("Pi Remote Workspace session closed")); } } private send(value: Record<string, unknown>): void { const line = `${JSON.stringify(value)}\n`; if (Buffer.byteLength(line, "utf8") > MAX_JSON_LINE_BYTES) throw new Error("Pi RPC message is too large"); this.child.stdin.write(line); this.child.stdin.flush(); } private async read(): Promise<void> { const reader = this.child.stdout.getReader(); const decoder = new TextDecoder("utf-8", { fatal: true }); let buffer = ""; try { while (true) { const next = await reader.read(); if (next.done) break; buffer += decoder.decode(next.value, { stream: true }); if (Buffer.byteLength(buffer, "utf8") > MAX_JSON_LINE_BYTES && !buffer.includes("\n")) { throw new Error("Pi RPC output line is too large"); } let newline = buffer.indexOf("\n"); while (newline >= 0) { const line = buffer.slice(0, newline).replace(/\r$/, ""); buffer = buffer.slice(newline + 1); if (Buffer.byteLength(line, "utf8") > MAX_JSON_LINE_BYTES) throw new Error("Pi RPC output line is too large"); if (line) { const event = record(JSON.parse(line)); if (!event) throw new Error("invalid Pi RPC event"); this.receive(event); } newline = buffer.indexOf("\n"); } } } catch (error) { void stopRemoteWorkspaceProcess(this.child).catch(() => {}); this.fail(new Error(safeError(error, "Pi RPC output failed"))); } finally { reader.releaseLock(); } } private async drainStderr(): Promise<void> { const reader = this.child.stderr.getReader(); try { while (!(await reader.read()).done) { /* drain without retaining secrets */ } } catch { /* stdout/exit code owns the failure */ } finally { reader.releaseLock(); } } private receive(event: Record<string, unknown>): void { if (event.type === "response" && typeof event.id === "string") { const pending = this.pending.get(event.id); if (!pending) return; clearTimeout(pending.timer); this.pending.delete(event.id); pending.resolve(event); return; } if (event.type === "agent_settled") { const active = this.activeSettle; this.activeSettle = null; active?.resolve(); } if (event.type === "extension_error") { const active = this.activeSettle; this.activeSettle = null; active?.reject(new Error(safeError(event.error, "Pi Remote Workspace extension failed"))); } this.onEvent?.(event); } private fail(error: Error): void { if (this.closed) return; this.closed = true; for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(error); } this.pending.clear(); const active = this.activeSettle; this.activeSettle = null; active?.reject(error); } } export interface PiRemoteWorkspaceRuntimeOptions { command?: readonly string[]; env?: Record<string, string | undefined>; version?: string; } export class PiRemoteWorkspaceRuntimeFactory implements RemoteWorkspaceRuntimeFactory { readonly profile = "pi" as const; constructor(private readonly options: PiRemoteWorkspaceRuntimeOptions = {}) {} async available(): Promise<{ available: boolean; version?: string; reason?: string }> { const command = this.options.command && this.options.command.length > 0 ? this.options.command[0] : findExecutableOnPath("pi"); return command ? { available: true, ...(this.options.version ? { version: this.options.version } : {}) } : { available: false, reason: "Pi is not installed on this Hub." }; } async start(options: Parameters<RemoteWorkspaceRuntimeFactory["start"]>[0]): Promise<RemoteWorkspaceRuntimeHandle> { const configuredCommand = this.options.command && this.options.command.length > 0 ? [...this.options.command] : null; const executable = configuredCommand?.[0] ?? findExecutableOnPath("pi"); if (!executable) throw new Error("Pi is not installed on this Hub"); const commandPrefix = configuredCommand ?? [executable]; const isolation = mkdtempSync(join(tmpdir(), "ocx-remote-pi-")); try { chmodSync(isolation, 0o700); } catch (error) { removeRemoteWorkspaceIsolation(isolation); throw error; } const extensionPath = join(isolation, "remote-workspace-extension.js"); try { writeFileSync(extensionPath, extensionSource(options.tools), { mode: 0o600 }); } catch (error) { removeRemoteWorkspaceIsolation(isolation); throw error; } const threadId = options.resumeThreadId ?? randomUUID(); const bridge = (() => { try { return startRemoteWorkspaceToolBridge({ coordinator: options.coordinator, threadId, tools: options.tools, onTool: tool => options.emit("tool", `Running ${tool} on ${options.deviceName}/${options.rootLabel}`), }); } catch (error) { removeRemoteWorkspaceIsolation(isolation); throw error; } })(); const childEnv = { ...process.env, ...this.options.env, OCX_REMOTE_WORKSPACE_BRIDGE_URL: bridge.url, OCX_REMOTE_WORKSPACE_BRIDGE_TOKEN: bridge.token, }; const invocation = remoteWorkspaceProcessInvocation([ ...commandPrefix, "--mode", "rpc", "--session-id", threadId, "--name", `OCX Remote: ${options.deviceName}`, "--no-builtin-tools", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files", "--no-approve", "--extension", extensionPath, "--tools", options.tools.map(tool => `remote_${tool}`).join(","), "--system-prompt", remotePiInstructions(options.deviceName, options.tools), ], { env: childEnv }); let child: Bun.Subprocess<"pipe", "pipe", "pipe">; try { child = Bun.spawn([invocation.file, ...invocation.args], { cwd: isolation, env: childEnv, stdin: "pipe", stdout: "pipe", stderr: "pipe", ...invocation.options, }); } catch (error) { await bridge.stop(); removeRemoteWorkspaceIsolation(isolation); throw error; } const rpc = new PiRpcProcess(child); rpc.onEvent = event => { if (event.type === "message_end") { const text = messageText(event.message); if (text) options.emit("assistant", text); } if (event.type === "tool_execution_start" && typeof event.toolName === "string") { options.emit("tool", `Pi requested ${event.toolName}`); } }; try { const state = await rpc.command("get_state"); if (state.success !== true) throw new Error(safeError(state.error, "Pi RPC failed to initialize")); } catch (error) { await rpc.close().catch(() => {}); await bridge.stop(); removeRemoteWorkspaceIsolation(isolation); throw error; } let stopped = false; let stopOperation: Promise<void> | null = null; return { threadId, prompt: text => rpc.prompt(text), stop(): Promise<void> { if (stopOperation) return stopOperation; stopped = true; stopOperation = runRemoteWorkspaceCleanupSteps([ () => rpc.abort(), () => rpc.close(), () => bridge.stop(), () => removeRemoteWorkspaceIsolation(isolation), ]); return stopOperation; }, }; } }