@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
142 lines (137 loc) • 8.26 kB
text/typescript
/** Child-owned watch: authenticated reads only; local reconciliation stays with the runtime scheduler. */
import type { OcxClientConnectionConfig } from "../types";
import { LINK_ROUTE_INTENT_PATH } from "../link/management-routes";
import { parseHomeRouteIntentDocument, routeIntentDigest, ROUTE_INTENT_DIGEST_PATTERN, type HomeRouteIntentDocument } from "../link/route-intent";
import { ROUTE_INTENT_AFTER_HEADER, ROUTE_INTENT_WAKE_HEADER, ROUTE_INTENT_WATCH_HEADER } from "../link/route-intent-watch";
import { readBoundedResponseBytes } from "../lib/bounded-body";
import { signalWithTimeout } from "../lib/abort";
import { fetchBoundLinkRelay } from "./link-relay-transport";
const WATCH_READ_TIMEOUT_MS = 40_000; // Home wait (30 s), relay proof and bounded body share one budget.
const WATCH_MAX_BYTES = 64 * 1024;
const WATCH_MAX_HEADER_BYTES = 8 * 1024;
const WATCH_RETRY_MS = 5_000;
export type RouteIntentWatchKey = string | (() => string | null);
export interface RouteIntentWatchReadDeps {
/** Trusted complete-send test seam; production always uses the connection-bound relay. */
fetchImpl?: typeof fetch;
signal?: AbortSignal;
timeoutMs?: number;
}
export type RouteIntentWatchResult = { kind: "fresh"; document: HomeRouteIntentDocument; watchSupported: boolean; wakeReason?: "changed" | "notified" | "timeout" }
| { kind: "unsupported" } | { kind: "cancelled" } | { kind: "failed"; reason: "route_intent_watch_unavailable" };
function cancel(response: Response): void {
try { void response.body?.cancel().catch(() => {}); } catch { /* no untrusted cleanup can extend the deadline */ }
}
/** No selectors, redirects, management writes, cached fallback or durable receipt writes. */
export async function watchHomeRouteIntent(
connection: OcxClientConnectionConfig, key: RouteIntentWatchKey, afterDigest?: string, deps: RouteIntentWatchReadDeps = {},
): Promise<RouteIntentWatchResult> {
const failed = (): RouteIntentWatchResult => ({ kind: "failed", reason: "route_intent_watch_unavailable" });
if (deps.signal?.aborted) return { kind: "cancelled" };
if (connection.transport !== "link" || !connection.link || !connection.apiKeyId
|| (afterDigest !== undefined && !ROUTE_INTENT_DIGEST_PATTERN.test(afterDigest))) return failed();
const budget = deps.timeoutMs ?? WATCH_READ_TIMEOUT_MS;
if (!Number.isInteger(budget) || budget < 1 || budget > WATCH_READ_TIMEOUT_MS) return failed();
const deadline = signalWithTimeout(budget, deps.signal);
let response: Response | undefined;
try {
// A long-lived runtime survives key rotation. Never retain the resolved credential across GETs.
const admissionKey = typeof key === "function" ? key() : key;
if (!admissionKey) return failed();
const target = { tunnelPort: connection.link.tunnelPort, linkId: connection.link.linkId, apiKeyId: connection.apiKeyId, admissionKey };
const destination = `http://127.0.0.1:${target.tunnelPort}${LINK_ROUTE_INTENT_PATH}`;
const init: RequestInit = { method: "GET", redirect: "manual", signal: deadline.signal,
headers: { accept: "application/json", authorization: `Bearer ${admissionKey}`, [ROUTE_INTENT_WATCH_HEADER]: "1",
...(afterDigest === undefined ? {} : { [ROUTE_INTENT_AFTER_HEADER]: afterDigest }) } };
response = deps.fetchImpl ? await deps.fetchImpl(destination, init) : await fetchBoundLinkRelay(target, destination, init);
if (response.status === 404) return { kind: "unsupported" };
if (response.status !== 200) return failed();
let headerBytes = 0;
for (const [name, value] of response.headers) headerBytes += Buffer.byteLength(name) + Buffer.byteLength(value) + 4;
const support = response.headers.get(ROUTE_INTENT_WATCH_HEADER);
const wakeReason = response.headers.get(ROUTE_INTENT_WAKE_HEADER);
const declared = response.headers.get("content-length");
if (headerBytes > WATCH_MAX_HEADER_BYTES || (support !== null && support !== "1")
|| (wakeReason !== null && wakeReason !== "changed" && wakeReason !== "notified" && wakeReason !== "timeout")
|| response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json"
|| (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > WATCH_MAX_BYTES))) return failed();
const read = await readBoundedResponseBytes(response, { maxBytes: WATCH_MAX_BYTES, signal: deadline.signal });
if (read.oversized) return failed();
const document = parseHomeRouteIntentDocument(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(read.bytes)));
return document ? { kind: "fresh", document, watchSupported: support === "1", ...(wakeReason === null ? {} : { wakeReason }) } : failed();
} catch { return deps.signal?.aborted ? { kind: "cancelled" } : failed(); }
finally { if (response) cancel(response); deadline.cleanup(); }
}
export interface RouteIntentRuntimeWatchDeps extends Omit<RouteIntentWatchReadDeps, "signal"> {
/** Share this with the periodic tick. Resolve after apply/report; reject busy/failure to retain the event. */
requestSync: () => Promise<unknown>;
setTimer?: (callback: () => void, ms: number) => unknown;
clearTimer?: (timer: unknown) => void;
}
export interface RouteIntentRuntimeWatch { stop(): void }
const liveWatches = new Map<string, RouteIntentRuntimeWatch>();
/** One GET per live link; one in-flight scheduler request plus one coalesced pending event. */
export function startRouteIntentWatch(
connection: OcxClientConnectionConfig, key: RouteIntentWatchKey, deps: RouteIntentRuntimeWatchDeps,
): RouteIntentRuntimeWatch {
if (connection.transport !== "link" || !connection.link) return { stop() {} };
const linkId = connection.link.linkId;
const existing = liveWatches.get(linkId);
if (existing) return existing;
// Do not let caller mutation redirect a long-lived watch onto a different connection.
const owner = structuredClone(connection);
const abort = new AbortController();
const set = deps.setTimer ?? ((cb, ms) => { const timer = setTimeout(cb, ms); timer.unref(); return timer; });
const clear = deps.clearTimer ?? (timer => clearTimeout(timer as ReturnType<typeof setTimeout>));
let timer: unknown, retry: unknown;
let stopped = false, syncing = false, pending = false;
let after: string | undefined;
const drain = async () => {
if (stopped || syncing) return;
syncing = true;
try {
while (pending && !stopped) {
pending = false;
try { await deps.requestSync(); }
catch {
pending = true;
if (!stopped) retry = set(() => { retry = undefined; void drain(); }, WATCH_RETRY_MS);
break;
}
}
} finally { syncing = false; }
};
const request = () => {
pending = true;
if (retry === undefined) void drain();
};
const schedule = (ms: number) => { if (!stopped) timer = set(() => { timer = undefined; void poll(); }, ms); };
const poll = async () => {
if (stopped) return;
const started = Date.now();
const result = await watchHomeRouteIntent(owner, key, after, { ...deps, signal: abort.signal });
if (stopped || result.kind === "cancelled") return;
// A pre-watch Home answers immediately forever. Its existing periodic sync remains authoritative.
if (result.kind === "unsupported" || (result.kind === "fresh" && !result.watchSupported)) return;
if (result.kind === "failed") { schedule(WATCH_RETRY_MS); return; }
const next = routeIntentDigest(result.document);
const unchanged = after === next;
after = next;
if (!unchanged || result.wakeReason !== "timeout") request();
// Broken peers advertising support but never waiting cannot make a tight loop.
schedule(unchanged ? Math.max(0, 1_000 - (Date.now() - started)) : 0);
};
const handle: RouteIntentRuntimeWatch = { stop() {
if (stopped) return;
stopped = true; pending = false;
abort.abort();
if (timer !== undefined) clear(timer);
if (retry !== undefined) clear(retry);
timer = retry = undefined;
liveWatches.delete(linkId);
// An already-entered local apply is owned/fenced by requestSync, never cancelled mid-write here.
} };
liveWatches.set(linkId, handle);
schedule(0);
return handle;
}