UNPKG

@bitkyc08/opencodex

Version:

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

367 lines (348 loc) • 15.1 kB
import type { RemoteControlIdentityKeyPair } from "./crypto"; import { RemoteControlClientHandshake, acceptRemoteControlClientHello, } from "./crypto"; import type { RemoteWorkspaceExecutor } from "./workspace-executor"; import { REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE } from "./protocol"; import { EncryptedRemoteWorkspaceExecutorEndpoint, EncryptedRemoteWorkspaceTransport, } from "./workspace-rpc"; import { REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, parseRemoteWorkspaceAgentMessage, parseRemoteWorkspaceHubMessage, serializeRemoteWorkspaceAgentMessage, serializeRemoteWorkspaceHubMessage, type RemoteWorkspaceAgentProfile, } from "./workspace-agent-protocol"; import { parseRemoteWorkspaceCapabilities, type RemoteWorkspaceCapability, } from "./workspace-tools"; import { truncateRemoteWorkspaceUtf8 } from "./workspace-utf8"; const SESSION_OPEN_TIMEOUT_MS = 10_000; export interface RemoteWorkspaceControlSocket { send(value: string): void | Promise<void>; close(code: number, reason: string): void; } interface PendingHubSession { handshake: RemoteControlClientHandshake; resolve(transport: EncryptedRemoteWorkspaceTransport): void; reject(error: Error): void; timer: ReturnType<typeof setTimeout>; } function safeReason(value: string): string { const cleaned = value.replace(/[\x00-\x1f\x7f]/g, " ").trim(); const selected = cleaned || "remote workspace session closed"; return truncateRemoteWorkspaceUtf8(selected, 120); } /** Hub-side representation of one authenticated, online OCX-only executor. */ export class RemoteWorkspaceHubAgentConnection { private readonly pending = new Map<string, PendingHubSession>(); private readonly active = new Map<string, EncryptedRemoteWorkspaceTransport>(); private readonly cancelledSessionIds = new Set<string>(); private closed = false; private presenceAccepted = false; private presencePending = false; private currentCapabilities: RemoteWorkspaceCapability[]; constructor(private readonly options: { deviceId: string; devicePublicKey: string; hubIdentity: RemoteControlIdentityKeyPair; socket: RemoteWorkspaceControlSocket; capabilities?: readonly RemoteWorkspaceCapability[]; onCapabilities?: (capabilities: readonly RemoteWorkspaceCapability[]) => void; sessionOpenTimeoutMs?: number; }) { this.currentCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities); } isOnline(): boolean { return !this.closed && this.presenceAccepted; } capabilities(): RemoteWorkspaceCapability[] { return [...this.currentCapabilities]; } async openSession(options: { sessionId: string; rootId: string; profile: RemoteWorkspaceAgentProfile; capabilities: readonly RemoteWorkspaceCapability[]; }): Promise<EncryptedRemoteWorkspaceTransport> { if (!this.isOnline()) throw new Error("remote workspace executor is offline"); if (this.pending.has(options.sessionId) || this.active.has(options.sessionId)) { throw new Error("remote workspace session already exists"); } if (this.pending.size + this.active.size >= REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE) { throw new Error("remote workspace executor session limit reached"); } if (!Array.isArray(options.capabilities)) throw new Error("remote workspace session requires explicit capabilities"); const requestedCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities); if (requestedCapabilities.some(capability => !this.currentCapabilities.includes(capability))) { throw new Error("remote workspace session requests an unavailable capability"); } const handshake = RemoteControlClientHandshake.create({ sessionId: options.sessionId, deviceId: this.options.deviceId, commandProfile: options.profile, capabilities: requestedCapabilities, accountPrivateKey: this.options.hubIdentity.privateKey, }); const timeoutMs = this.options.sessionOpenTimeoutMs ?? SESSION_OPEN_TIMEOUT_MS; const opened = new Promise<EncryptedRemoteWorkspaceTransport>((resolve, reject) => { const timer = setTimeout(() => { this.pending.delete(options.sessionId); this.rememberCancelledSession(options.sessionId); reject(new Error("remote workspace session handshake timed out")); }, timeoutMs); this.pending.set(options.sessionId, { handshake, resolve, reject, timer }); }); try { await this.options.socket.send(serializeRemoteWorkspaceHubMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "session_open", rootId: options.rootId, clientHello: handshake.hello, })); } catch (error) { const pending = this.pending.get(options.sessionId); if (pending) { clearTimeout(pending.timer); this.pending.delete(options.sessionId); pending.reject(error instanceof Error ? error : new Error("remote workspace session send failed")); } } return await opened; } receive(raw: string | Uint8Array): void { if (this.closed) throw new Error("remote workspace executor is offline"); const message = parseRemoteWorkspaceAgentMessage(raw); if (message.type === "presence") { if (this.presenceAccepted || this.presencePending) { throw new Error("remote workspace executor sent duplicate presence"); } const approved = parseRemoteWorkspaceCapabilities(this.options.capabilities); const capabilities = parseRemoteWorkspaceCapabilities(message.capabilities.filter(capability => approved.includes(capability))); this.presencePending = true; const accept = () => { if (this.closed) return; this.options.onCapabilities?.(capabilities); this.currentCapabilities = capabilities; this.presenceAccepted = true; this.presencePending = false; }; let sent: void | Promise<void>; try { sent = this.options.socket.send(serializeRemoteWorkspaceHubMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "presence_ack", capabilities, })); } catch (error) { this.presencePending = false; throw error; } if (sent && typeof sent.then === "function") { void sent.then(accept).catch(() => this.close("remote workspace presence acknowledgement failed")); } else { accept(); } return; } if (!this.presenceAccepted) { throw new Error("remote workspace executor presence is required before session traffic"); } if (message.type === "heartbeat") return; if (message.type === "session_accept") { const pending = this.pending.get(message.sessionId); if (!pending) { if (!this.cancelledSessionIds.delete(message.sessionId)) { throw new Error("remote workspace accepted an unknown session"); } void Promise.resolve(this.options.socket.send(serializeRemoteWorkspaceHubMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "session_close", sessionId: message.sessionId, reason: "remote workspace session was already cancelled", }))).catch(() => this.close("remote workspace cancelled-session cleanup failed")); return; } const cipher = pending.handshake.complete(message.hostHello, this.options.devicePublicKey); const transport = new EncryptedRemoteWorkspaceTransport({ executorDeviceId: this.options.deviceId, cipher, sendCiphertext: value => this.options.socket.send(serializeRemoteWorkspaceHubMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "ciphertext", sessionId: message.sessionId, payload: value, })), }); clearTimeout(pending.timer); this.pending.delete(message.sessionId); this.active.set(message.sessionId, transport); pending.resolve(transport); return; } if (message.type === "session_reject") { const pending = this.pending.get(message.sessionId); if (!pending) return; clearTimeout(pending.timer); this.pending.delete(message.sessionId); pending.reject(new Error(safeReason(message.reason))); return; } const transport = this.active.get(message.sessionId); if (!transport) throw new Error("remote workspace ciphertext targeted an unknown session"); transport.receiveCiphertext(message.payload); } async closeSession(sessionId: string, reason = "remote workspace session closed"): Promise<void> { const pending = this.pending.get(sessionId); if (pending) { clearTimeout(pending.timer); this.pending.delete(sessionId); this.rememberCancelledSession(sessionId); pending.reject(new Error(safeReason(reason))); } const transport = this.active.get(sessionId); if (transport) { this.active.delete(sessionId); transport.close(safeReason(reason)); } if (this.closed) return; await this.options.socket.send(serializeRemoteWorkspaceHubMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "session_close", sessionId, reason: safeReason(reason), })); } close(reason = "remote workspace executor disconnected"): void { if (this.closed) return; this.closed = true; for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(new Error(safeReason(reason))); } this.pending.clear(); for (const transport of this.active.values()) transport.close(safeReason(reason)); this.active.clear(); this.cancelledSessionIds.clear(); try { this.options.socket.close(1008, safeReason(reason)); } catch { /* socket is already gone */ } } private rememberCancelledSession(sessionId: string): void { this.cancelledSessionIds.add(sessionId); while (this.cancelledSessionIds.size > 16) { const oldest = this.cancelledSessionIds.values().next(); if (oldest.done) break; this.cancelledSessionIds.delete(oldest.value); } } } /** Executor-side connection. It owns no Codex, Claude Code, Pi, provider key, or model session. */ export class RemoteWorkspaceExecutorAgentConnection { private readonly sessions = new Map<string, EncryptedRemoteWorkspaceExecutorEndpoint>(); private closed = false; constructor(private readonly options: { deviceId: string; deviceIdentity: RemoteControlIdentityKeyPair; hubPublicKey: string; executor: RemoteWorkspaceExecutor; capabilities?: readonly RemoteWorkspaceCapability[]; onPresenceAccepted?: () => void; socket: RemoteWorkspaceControlSocket; }) { this.currentCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities); } private currentCapabilities: RemoteWorkspaceCapability[]; async receive(raw: string | Uint8Array): Promise<void> { if (this.closed) throw new Error("remote workspace agent connection is closed"); const message = parseRemoteWorkspaceHubMessage(raw); if (message.type === "presence_ack") { if (message.capabilities.some(capability => !this.currentCapabilities.includes(capability))) { throw new Error("remote workspace Hub acknowledged different executor capabilities"); } this.currentCapabilities = [...message.capabilities]; this.options.onPresenceAccepted?.(); return; } if (message.type === "session_open") { let endpoint: EncryptedRemoteWorkspaceExecutorEndpoint | null = null; try { if (this.sessions.has(message.clientHello.sessionId)) { throw new Error("remote workspace executor session already exists"); } if (this.sessions.size >= REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE) { throw new Error("remote workspace executor session limit reached"); } if (message.clientHello.deviceId !== this.options.deviceId) { throw new Error("remote workspace session targeted another executor"); } if (!this.options.executor.hasApprovedRoot(message.rootId)) { throw new Error("remote workspace root is not approved"); } const accepted = acceptRemoteControlClientHello(message.clientHello, { expectedSessionId: message.clientHello.sessionId, expectedDeviceId: this.options.deviceId, accountPublicKey: this.options.hubPublicKey, devicePrivateKey: this.options.deviceIdentity.privateKey, allowedCapabilities: this.currentCapabilities, }); endpoint = new EncryptedRemoteWorkspaceExecutorEndpoint({ executorDeviceId: this.options.deviceId, sessionId: message.clientHello.sessionId, rootId: message.rootId, capabilities: parseRemoteWorkspaceCapabilities(accepted.hello.capabilities), cipher: accepted.cipher, executor: this.options.executor, sendCiphertext: value => this.options.socket.send(serializeRemoteWorkspaceAgentMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "ciphertext", sessionId: message.clientHello.sessionId, payload: value, })), }); this.sessions.set(message.clientHello.sessionId, endpoint); await this.options.socket.send(serializeRemoteWorkspaceAgentMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "session_accept", sessionId: message.clientHello.sessionId, hostHello: accepted.hello, })); } catch (error) { if (endpoint) { this.sessions.delete(message.clientHello.sessionId); endpoint.close(); } await this.options.socket.send(serializeRemoteWorkspaceAgentMessage({ version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION, type: "session_reject", sessionId: message.clientHello.sessionId, reason: safeReason(error instanceof Error ? error.message : "remote workspace session refused"), })); } return; } if (message.type === "session_close") { this.sessions.get(message.sessionId)?.close(); this.sessions.delete(message.sessionId); return; } const endpoint = this.sessions.get(message.sessionId); if (!endpoint) throw new Error("remote workspace ciphertext targeted an unknown executor session"); // Decryption and counter validation happen synchronously before this returns. The execution // promise is intentionally detached so an unencrypted session_close control frame can abort a // long-running command instead of waiting behind that command on the socket's ordered queue. void endpoint.receiveCiphertext(message.payload).catch(() => { this.close(); this.options.socket.close(1008, "remote workspace protocol error"); }); } close(): void { if (this.closed) return; this.closed = true; for (const endpoint of this.sessions.values()) endpoint.close(); this.sessions.clear(); } }