UNPKG

@bitkyc08/opencodex

Version:

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

232 lines (219 loc) • 8.81 kB
import { randomUUID } from "node:crypto"; import { isAbsolute } from "node:path"; import { resolveTrustedWindowsSystemDirectory } from "../lib/windows-elevation"; import { REMOTE_WORKSPACE_MAX_TOOL_RESULT_BYTES, REMOTE_WORKSPACE_TOOL_NAMESPACE, parseRemoteWorkspaceToolCall, remoteWorkspaceCodexDeveloperInstructions, remoteWorkspaceCapabilityForTool, remoteWorkspaceDeveloperInstructions, remoteWorkspaceToolsForCapabilities, type RemoteWorkspaceCapability, type RemoteWorkspaceToolName, type RemoteWorkspaceToolCallParams, type RemoteWorkspaceToolResult, } from "./workspace-tools"; import type { RemoteWorkspaceExecutionRequest } from "./workspace-executor"; export interface RemoteWorkspaceSessionBinding { sessionId: string; threadId: string; executorDeviceId: string; executorName: string; rootId: string; capabilities: RemoteWorkspaceCapability[]; tools: RemoteWorkspaceToolName[]; } export interface RemoteWorkspaceTransport { isOnline(deviceId: string): boolean; invoke(request: RemoteWorkspaceExecutionRequest): Promise<RemoteWorkspaceToolResult>; } export interface AppServerDynamicToolRequest { method: "item/tool/call"; id: string | number; params: unknown; } export interface AppServerDynamicToolResponse { id: string | number; result: { contentItems: Array<{ type: "inputText"; text: string }>; success: boolean; }; } function identifier(value: string, label: string): string { if (value.length < 1 || value.length > 256 || /[\x00-\x1f\x7f]/.test(value)) { throw new Error(`invalid remote workspace ${label}`); } return value; } function boundedResult(result: RemoteWorkspaceToolResult): { text: string; success: boolean } { const encoded = JSON.stringify(result); if (Buffer.byteLength(encoded, "utf8") > REMOTE_WORKSPACE_MAX_TOOL_RESULT_BYTES) { return { text: JSON.stringify({ ok: false, error: "remote workspace tool result exceeded the coordinator limit" }), success: false }; } return { text: encoded, success: result.ok }; } export function remoteWorkspaceThreadStartParams(options: { executorName: string; coordinatorIsolationPath: string; tools: readonly RemoteWorkspaceToolName[]; platform?: NodeJS.Platform; windowsSystemDirectory?: string; mcp?: { url: string; bearerTokenEnvVar: string; disabledServerNames?: readonly string[]; disabledHookNames?: readonly string[]; hubRuntimeReadPaths?: readonly string[]; }; }): Record<string, unknown> { if (!isAbsolute(options.coordinatorIsolationPath) || options.coordinatorIsolationPath.includes("\0")) { throw new Error("remote workspace coordinator isolation path must be absolute"); } const platform = options.platform ?? process.platform; const shellEnvironment = platform === "win32" ? { HOME: options.coordinatorIsolationPath, USERPROFILE: options.coordinatorIsolationPath, TEMP: options.coordinatorIsolationPath, TMP: options.coordinatorIsolationPath, PATH: options.windowsSystemDirectory ?? resolveTrustedWindowsSystemDirectory(), } : { HOME: options.coordinatorIsolationPath, PATH: platform === "darwin" ? "/usr/bin:/bin" : "/usr/local/bin:/usr/bin:/bin", LANG: "C.UTF-8", }; const config = options.mcp ? { // A Remote Workspace thread may authenticate/model-call from the Hub, but every // model-visible action must either be the one OCX MCP server or fail closed. default_permissions: "ocx-remote-deny-local", permissions: { "ocx-remote-deny-local": { description: "Deny Hub-local command filesystem and network access for Remote Workspace.", filesystem: { ":minimal": "read", ":workspace_roots": { ".": "read" }, ...Object.fromEntries((options.mcp.hubRuntimeReadPaths ?? []).map(path => [path, "read"])), }, network: { enabled: false }, }, }, approval_policy: "never", allow_login_shell: false, shell_environment_policy: { inherit: "none", ignore_default_excludes: false, set: shellEnvironment, }, web_search: "disabled", tools: { view_image: false, web_search: false }, agents: { enabled: false }, apps: { _default: { enabled: false } }, features: { apps: false, browser_use: false, computer_use: false, in_app_browser: false, memories: false, multi_agent: false, plugins: false, remote_plugin: false, }, memories: { use_memories: false, generate_memories: false }, hooks: Object.fromEntries((options.mcp.disabledHookNames ?? []).map(name => [name, []])), mcp_servers: { ...Object.fromEntries((options.mcp.disabledServerNames ?? []) .filter(name => name !== REMOTE_WORKSPACE_TOOL_NAMESPACE) .map(name => [name, { enabled: false }])), [REMOTE_WORKSPACE_TOOL_NAMESPACE]: { enabled: true, required: true, url: options.mcp.url, bearer_token_env_var: options.mcp.bearerTokenEnvVar, enabled_tools: [...options.tools], default_tools_approval_mode: "approve", startup_timeout_sec: 5, tool_timeout_sec: 65, }, }, } : undefined; return { cwd: options.coordinatorIsolationPath, runtimeWorkspaceRoots: [options.coordinatorIsolationPath], approvalPolicy: "never", ephemeral: false, serviceName: "opencodex_remote_workspace", developerInstructions: options.mcp ? remoteWorkspaceCodexDeveloperInstructions(options.executorName, options.tools) : remoteWorkspaceDeveloperInstructions(options.executorName, options.tools), ...(config ? { config } : {}), }; } export class RemoteWorkspaceCoordinator { private readonly sessions = new Map<string, RemoteWorkspaceSessionBinding>(); constructor(private readonly transport: RemoteWorkspaceTransport) {} register(binding: RemoteWorkspaceSessionBinding): () => void { const capabilities = [...binding.capabilities]; const tools = remoteWorkspaceToolsForCapabilities(capabilities); if (tools.length < 1) throw new Error("remote workspace binding has no usable tools"); const normalized: RemoteWorkspaceSessionBinding = { sessionId: identifier(binding.sessionId, "session ID"), threadId: identifier(binding.threadId, "thread ID"), executorDeviceId: identifier(binding.executorDeviceId, "executor device ID"), executorName: identifier(binding.executorName, "executor name"), rootId: identifier(binding.rootId, "root ID"), capabilities, tools, }; if (this.sessions.has(normalized.threadId)) throw new Error("remote workspace thread is already bound"); this.sessions.set(normalized.threadId, normalized); return () => { if (this.sessions.get(normalized.threadId)?.sessionId === normalized.sessionId) { this.sessions.delete(normalized.threadId); } }; } async handle(request: AppServerDynamicToolRequest): Promise<AppServerDynamicToolResponse> { if (request.method !== "item/tool/call") throw new Error("unsupported App Server request"); let call: RemoteWorkspaceToolCallParams; try { call = parseRemoteWorkspaceToolCall(request.params); } catch (error) { return this.response(request.id, { ok: false, error: error instanceof Error ? error.message : "invalid remote tool call" }); } const binding = this.sessions.get(call.threadId); if (!binding) return this.response(request.id, { ok: false, error: "remote workspace thread is not bound" }); if (!binding.tools.includes(call.tool) || !binding.capabilities.includes(remoteWorkspaceCapabilityForTool(call.tool))) { return this.response(request.id, { ok: false, error: "remote workspace tool is not supported by this executor" }); } if (!this.transport.isOnline(binding.executorDeviceId)) { return this.response(request.id, { ok: false, error: "remote executor is offline; local fallback is disabled" }); } let result: RemoteWorkspaceToolResult; try { result = await this.transport.invoke({ requestId: randomUUID(), sessionId: binding.sessionId, executorDeviceId: binding.executorDeviceId, rootId: binding.rootId, tool: call.tool, arguments: call.arguments, }); } catch { result = { ok: false, error: "remote executor transport failed; local fallback is disabled" }; } return this.response(request.id, result); } private response(id: string | number, result: RemoteWorkspaceToolResult): AppServerDynamicToolResponse { const bounded = boundedResult(result); return { id, result: { contentItems: [{ type: "inputText", text: bounded.text }], success: bounded.success, }, }; } }