UNPKG

@bitkyc08/opencodex

Version:

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

150 lines (139 loc) • 6.91 kB
/** Bounded, serial observation of fixed management read surfaces. */ import { readBoundedResponseBytes } from "../lib/bounded-body"; import { runningProxyUpdateHeaders } from "../oauth/login-cli"; import { findLiveProxy, type LiveProxy } from "../server/proxy-liveness"; import { runtimeBaseUrl, type RuntimeApiDeps } from "./runtime-api"; const POLL_MS = 1_000; const REQUEST_MS = 10_000; const RESPONSE_BYTES = 32 * 1024 * 1024; type ObservationPath = "/api/logs" | "/api/debug/injection-logs" | "/api/companion/settings" | "/api/usage"; export interface ObserveStreamDeps extends RuntimeApiDeps { signal?: AbortSignal; /** Reduced timings for isolated tests only; never command-line options. */ pollIntervalMs?: number; requestTimeoutMs?: number; /** Frozen clock for usage-compare tests; never a command-line option. */ now?: () => number; } export class ObservationError extends Error {} function reduced(value: number | undefined, ceiling: number): number { return value !== undefined && Number.isFinite(value) && value > 0 && value <= ceiling ? value : ceiling; } function interrupted<T>(work: Promise<T>, signal: AbortSignal): Promise<T> { return new Promise((resolve, reject) => { const abort = () => { cleanup(); reject(signal.reason); }; const cleanup = () => signal.removeEventListener("abort", abort); signal.addEventListener("abort", abort, { once: true }); work.then(value => { cleanup(); resolve(value); }, error => { cleanup(); reject(error); }); if (signal.aborted) abort(); }); } function waitForPoll(ms: number, signal: AbortSignal): Promise<void> { return new Promise((resolve, reject) => { const cleanup = () => { clearTimeout(timer); signal.removeEventListener("abort", abort); }; const abort = () => { cleanup(); reject(signal.reason); }; const timer = setTimeout(() => { cleanup(); resolve(); }, ms); signal.addEventListener("abort", abort, { once: true }); if (signal.aborted) abort(); }); } function identity(live: LiveProxy | undefined): string { return JSON.stringify(live ? [live.pid, live.port, live.hostname, live.role] : null); } export interface ObserveStream { signal: AbortSignal; get(path: ObservationPath, query: URLSearchParams): Promise<unknown>; wait(): Promise<void>; } export interface ObservationContext { kind: "follow" | "snapshot"; limitOption?: "--limit" | "--scan-limit"; } /** Each invocation owns its signals, in-flight request and pinned runtime identity. */ export async function withObserveStream( deps: ObserveStreamDeps, run: (stream: ObserveStream) => Promise<void | number>, context: ObservationContext = { kind: "follow", limitOption: "--limit" }, ): Promise<number> { const retry = context.kind === "follow" ? "restart follow" : "retry the command"; const controller = new AbortController(); let exit = 0; const stop = (code: number) => { if (controller.signal.aborted) return; exit = code; controller.abort(); }; const onInt = () => stop(130); const onTerm = () => stop(143); process.on("SIGINT", onInt); process.on("SIGTERM", onTerm); deps.signal?.addEventListener("abort", onInt, { once: true }); if (deps.signal?.aborted) onInt(); let pinned: { origin: string; identity: string } | undefined; const signal = controller.signal; const timeoutMs = reduced(deps.requestTimeoutMs, REQUEST_MS); const get = async (path: ObservationPath, query: URLSearchParams): Promise<unknown> => { signal.throwIfAborted(); let live: LiveProxy | undefined; const origin = await interrupted(runtimeBaseUrl({ ...deps, findLiveProxy: async () => { const found = await (deps.findLiveProxy ?? findLiveProxy)(); live = found ? { ...found } : undefined; // Snapshot recovery comes from our observed target, never arbitrary transport text. if (context.kind === "snapshot") { if (!found) throw new ObservationError("Proxy is not running. Start it with: ocx start"); if (found.role === "client") { const { readLinkChildContext, linkChildRefusal } = await import("./link-child"); const link = readLinkChildContext(); throw new ObservationError(link ? linkChildRefusal(link) : "This listener runs in the client role and has no management API. Run this command on its serving hub, or open the hub dashboard."); } } return found; } }), signal); signal.throwIfAborted(); const current = { origin, identity: identity(live) }; if (pinned && (pinned.origin !== current.origin || pinned.identity !== current.identity)) { throw new ObservationError(`The runtime changed. ${context.kind === "follow" ? "Restart follow" : "Retry the command"} to observe the current runtime.`); } pinned = current; const request = new AbortController(); const abort = () => request.abort(); signal.addEventListener("abort", abort, { once: true }); const timer = setTimeout(abort, timeoutMs); try { signal.throwIfAborted(); const responsePromise = (deps.fetchImpl ?? fetch)(`${origin}${path}?${query}`, { method: "GET", headers: runningProxyUpdateHeaders(), credentials: "omit", redirect: "error", signal: request.signal, }); // A test transport or late fetch may settle after abort. Release its body too. void responsePromise.then(response => { if (request.signal.aborted) void response.body?.cancel().catch(() => {}); }, () => {}); const response = await interrupted(responsePromise, request.signal); const result = await readBoundedResponseBytes(response, { maxBytes: RESPONSE_BYTES, signal: request.signal }); signal.throwIfAborted(); request.signal.throwIfAborted(); if (result.oversized) throw new ObservationError(`The observation window exceeds 32 MiB. ${context.limitOption ? `Reduce ${context.limitOption} and ${retry}` : "Check the runtime response size and retry the command"}.`); if (!response.ok) throw new ObservationError(`The observation request was refused. Check runtime access and ${retry}.`); return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(result.bytes)); } finally { clearTimeout(timer); signal.removeEventListener("abort", abort); request.abort(); } }; try { signal.throwIfAborted(); const result = await run({ signal, get, wait: () => waitForPoll(reduced(deps.pollIntervalMs, POLL_MS), signal) }); return exit || result || 0; } catch (error) { if (exit) return exit; console.error(`Error: ${error instanceof ObservationError ? error.message : `Observation failed or timed out. Check the runtime and ${retry}.`}`); return 1; } finally { controller.abort(); process.removeListener("SIGINT", onInt); process.removeListener("SIGTERM", onTerm); deps.signal?.removeEventListener("abort", onInt); } }