UNPKG

@bitkyc08/opencodex

Version:

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

603 lines (568 loc) • 29.5 kB
/** * Selection rounds for a link with several routes (structure/remote-link.md, "Routes"). A round * probes the eligible routes in order with the pinned route probe, starts the -R tunnel on the * first that answers as a CANDIDATE, waits for OpenSSH to confirm the remote listener was granted * to it, and then proves readiness end to end: the Child fetches its own /v1/catalog with a fresh * proof id, its link relay carries that request to this Home with relay authentication, and the * Home must see the id admitted under this tunnel's generation while the same request completes * with a catalog. Only then is the link connected. * * One-route links never come here. Nothing in this module stops a tunnel that may carry traffic * for a non-failure reason; a candidate that has not proven readiness by its deadline is a failed * route and is stopped, which is today's reconnect contract for any request on it. */ import { randomBytes } from "node:crypto"; import { buildExecArgv, buildRouteProbeArgv, remoteOcxArgv } from "./ssh-argv"; import { isChildHealth, parseChildHttp, remoteChildHttpArgv } from "./remote-probe"; import { requireRemotePlatform } from "./remote-platform"; import { aggregateRouteClass, composeGrantTap, routeCooldownMs, routeOutcomeOfStderr, type RouteOutcomeClass } from "./route-select"; import type { RouteProofHandle, RouteProofRegistry } from "./route-proof"; import { SSH_MAX_OUTPUT_BYTES, type SshChild, type SshRunner } from "./ssh-runner"; import { effectiveLinkRoutes, type LinkRecord } from "./store"; import { exitCause, type TunnelCause } from "./tunnel-history"; import { classifySshStderr, type StderrClass, type TunnelEvent, type TunnelState } from "./tunnel-state"; /** One route probe, supervisor clock. */ export const ROUTE_PROBE_MS = 10_000; /** * A candidate's budget, twice: from its spawn to the grant of its remote listener, and then from that * grant to its proven readiness (discovery, health and every trigger). A slow route that spends most * of the first budget on the ssh handshake still has the whole second one for its readiness execs. * Not measured on a real slow route. A candidate's readiness deadline is at most 2 x READY_PROOF_MS * after its spawn; the first supervisor tick at or after that deadline stops it (SIGTERM, then SIGKILL * after CANDIDATE_KILL_GRACE_MS). */ export const READY_PROOF_MS = 30_000; /** One correlated trigger at most. */ export const PROOF_ATTEMPT_MS = 15_000; /** Between the end of one failed trigger and the next. */ export const PROOF_RETRY_MS = 2_000; /** SIGTERM to SIGKILL, and SIGKILL to giving up on observing a stopped candidate's exit. */ export const CANDIDATE_KILL_GRACE_MS = 2_000; /** The ssh client check, and how long an unsupported answer stands. */ export const CLIENT_CHECK_MS = 5_000; export const CLIENT_RECHECK_MS = 10 * 60_000; // The Child's whole effective config: enrollment accepts up to the runner maximum (#8380), so a // Child that enrolled with a large config must also pass this step on every route. const CONFIG_MAX_BYTES = SSH_MAX_OUTPUT_BYTES; const CATALOG_MAX_BYTES = 4 * 1024 * 1024; export type RouteBlock = "ssh_client_unsupported" | "stop_unconfirmed"; export interface LinkRouteStatus { routes: Array<{ name: string; eligibleAt: number | null; lastOutcome: { class: RouteOutcomeClass; at: number } | null }>; /** The route of the proven tunnel and when it was proven; null while none is proven. */ route: { name: string; index: number; since: number } | null; blocked: RouteBlock | null; } /** What the supervisor lends a round. Every call is synchronous except the runner. */ export interface RouteRoundHost { runner: Pick<SshRunner, "run">; now(): number; random(): number; knownHostsFile(): string; listenerPort(): number | null; /** The record as the supervisor currently holds it. */ record(linkId: string): LinkRecord | undefined; /** stopping, held, or an earlier tunnel that may still live (orphan-unverified). */ blocked(linkId: string): boolean; /** Lifecycle work (reload, stop, reconnect) is running: deadlines advance, no new probe or tunnel starts. */ busy(): boolean; /** Is this child still the link's registered tunnel? */ ownsChild(linkId: string, child: SshChild): boolean; /** Start the -R tunnel on a route, register it as the link's child, and name its generation. */ spawnTunnel(record: LinkRecord, destination: string, stderrLine: (line: string) => boolean): { child: SshChild; generation: string; setupFailed?: boolean }; /** The operator's capture tap for this spawn, if a capture window is open. */ captureTap(linkId: string): ((line: string) => boolean) | undefined; setEvent(linkId: string, event: TunnelEvent, cause?: TunnelCause | null): TunnelState; /** Push a scheduled retry later without recording a transition. */ deferRetry(linkId: string, at: number): void; /** Count one ssh attempt in the tunnel history (once per round). */ attempted(linkId: string): void; routeProof?: RouteProofRegistry; warn(message: string): void; } interface RouteBook { name: string; outcome: RouteOutcomeClass | null; outcomeAt: number | null; probeFailures: number; tunnelFailures: number; eligibleAt: number; remoteForwardConflict?: boolean; } interface Proof { platform?: "posix" | "windows"; port?: number; healthy?: boolean; inFlight: boolean; nextAt: number; handle?: RouteProofHandle; } type Phase = | { kind: "client" } | { kind: "probe"; route: string; startedAt: number; abort: AbortController } | { kind: "candidate"; route: string; child: SshChild; generation: string; spawnedAt: number; grantedAt?: number; refused?: boolean; failure?: RouteOutcomeClass; stopAt?: number; killed?: boolean; abort: AbortController; proof: Proof; } | { kind: "halted"; route: string; child: SshChild; failure: RouteOutcomeClass } /** A probe that settled while lifecycle work ran: no deadline applies; round.resume continues it. */ | { kind: "deferred" }; interface Round { token: number; queue: string[]; phase: Phase; /** New work held back while lifecycle work runs; the next free tick starts it. */ resume?: () => void; } interface LinkRoutes { books: Map<string, RouteBook>; round?: Round; active?: { route: string; child: SshChild; since: number }; blocked: RouteBlock | null; } type ClientState = { kind: "unknown" } | { kind: "checking"; abort: AbortController; epoch: number } | { kind: "ok" } | { kind: "unsupported"; at: number }; export interface RouteRounds { isMultiRoute(record: LinkRecord): boolean; /** Start a round for a due attempt. False when the link is not multi-route. */ begin(record: LinkRecord): boolean; tick(linkId: string): void; /** True when this child belonged to a multi-route round or proven tunnel (the exit is handled). */ exited(linkId: string, child: SshChild, stderr: string, deferForwardRelease?: (resume: (allowed: boolean) => void) => boolean): boolean; /** Drop rounds and proofs: a stop, hold, reconnect or removal is taking the link down. */ cancel(linkId: string): void; /** Forget everything about a link (removed, or no longer multi-route). */ forget(linkId: string): void; /** A reload changed this link's route list but kept its tunnel. */ routesChanged(record: LinkRecord): void; /** Adopt a running one-route tunnel on the alias when the link gains routes. */ adopt(record: LinkRecord, child: SshChild, connectedSince: number | null): void; /** Proven or candidate route of a link's live child, for the reload check. */ liveRoute(linkId: string): string | undefined; inRound(linkId: string): boolean; status(linkId: string): LinkRouteStatus | undefined; /** The ssh client answer changes (a reload of a multi-route record re-reads it). */ recheckClient(): void; stop(): void; } export function createRouteRounds(host: RouteRoundHost): RouteRounds { const links = new Map<string, LinkRoutes>(); let tokens = 0; let client: ClientState = { kind: "unknown" }; let clientEpoch = 0; let stopped = false; const isMultiRoute = (record: LinkRecord): boolean => record.direction === "hub-initiated" && effectiveLinkRoutes(record).length > 1; const linkFor = (record: LinkRecord): LinkRoutes => { let link = links.get(record.id); if (!link) { link = { books: new Map(), blocked: null }; links.set(record.id, link); } const names = effectiveLinkRoutes(record); for (const name of names) if (!link.books.has(name)) link.books.set(name, { name, outcome: null, outcomeAt: null, probeFailures: 0, tunnelFailures: 0, eligibleAt: 0 }); for (const name of [...link.books.keys()]) if (!names.includes(name)) link.books.delete(name); return link; }; const current = (linkId: string, round: Round): boolean => !stopped && links.get(linkId)?.round === round && !host.blocked(linkId); const fail = (link: LinkRoutes, route: string, outcome: RouteOutcomeClass, kind: "probe" | "tunnel", remoteForwardConflict = false): void => { const book = link.books.get(route); if (!book) return; const n = kind === "probe" ? ++book.probeFailures : ++book.tunnelFailures; book.outcome = outcome; book.outcomeAt = host.now(); book.remoteForwardConflict = remoteForwardConflict; book.eligibleAt = host.now() + routeCooldownMs(outcome, n, host.random); }; const minEligible = (link: LinkRoutes): number => Math.min(...[...link.books.values()].map(book => book.eligibleAt)); const aggregate = (link: LinkRoutes): StderrClass => aggregateRouteClass([...link.books.values()].map(book => book.outcome)); /** The round is over without a proven route: one reducer exit with the aggregate class. */ const endRound = (linkId: string, link: LinkRoutes): void => { link.round = undefined; host.routeProof?.forget(linkId); const outcome = aggregate(link); const cls = outcome === "forward" && [...link.books.values()].some(book => book.outcome === "forward" && book.remoteForwardConflict) ? "remote_forward" : outcome; host.setEvent(linkId, { type: "exit", now: host.now(), stderrClass: cls }, exitCause(cls)); host.deferRetry(linkId, minEligible(link)); }; const next = (linkId: string, link: LinkRoutes, round: Round): void => { if (!current(linkId, round)) return; if (host.busy()) { round.phase = { kind: "deferred" }; round.resume = () => next(linkId, link, round); return; } const record = host.record(linkId); if (!record) { link.round = undefined; return; } const route = round.queue.shift(); if (route === undefined) { endRound(linkId, link); return; } if (!link.books.has(route)) { next(linkId, link, round); return; } probe(linkId, link, round, record, route); }; const probe = (linkId: string, link: LinkRoutes, round: Round, record: LinkRecord, route: string): void => { const abort = new AbortController(); const phase: Phase = { kind: "probe", route, startedAt: host.now(), abort }; round.phase = phase; let argv: string[]; try { argv = buildRouteProbeArgv({ alias: record.alias, destination: route, knownHostsFile: host.knownHostsFile(), route: record.explicitRoute ?? null }); } catch { fail(link, route, "transient", "probe"); next(linkId, link, round); return; } void host.runner.run(argv, { timeoutMs: ROUTE_PROBE_MS, signal: abort.signal }).then(result => { if (!current(linkId, round) || round.phase !== phase) return; // Past its deadline on the supervisor clock, a result is a timeout even if the tick has not run yet. const inTime = host.now() < phase.startedAt + ROUTE_PROBE_MS; if (inTime && result.code === 0 && result.stdout.trim() === "ocx-link-probe") { const book = link.books.get(route); if (book) book.probeFailures = 0; if (host.busy()) { const deferred: Phase = { kind: "deferred" }; round.phase = deferred; round.resume = () => { if (current(linkId, round) && round.phase === deferred) candidate(linkId, link, round, route); }; } else { candidate(linkId, link, round, route); } return; } // A late answer is a timeout whatever it says: a late host-key or auth message never decides the route. fail(link, route, !inTime || result.code === 0 ? "transient" : routeOutcomeOfStderr(result.stderr), "probe"); next(linkId, link, round); }, () => { if (!current(linkId, round) || round.phase !== phase) return; fail(link, route, "transient", "probe"); next(linkId, link, round); }); }; const candidate = (linkId: string, link: LinkRoutes, round: Round, route: string): void => { const record = host.record(linkId); const listenerPort = host.listenerPort(); if (!record || listenerPort === null) { endRound(linkId, link); return; } let phase: Extract<Phase, { kind: "candidate" }> | undefined; const tap = composeGrantTap(record.tunnelPort, listenerPort, verdict => { if (!phase || round.phase !== phase) return; if (verdict === "refused") { phase.refused = true; return; } if (phase.grantedAt === undefined) { phase.grantedAt = host.now(); phase.proof.nextAt = host.now(); } }, host.captureTap(linkId)); let spawned: { child: SshChild; generation: string }; let setupFailed = false; try { const result = host.spawnTunnel(record, route, tap); spawned = result; setupFailed = result.setupFailed === true; } catch { fail(link, route, "transient", "tunnel"); next(linkId, link, round); return; } phase = { kind: "candidate", route, child: spawned.child, generation: spawned.generation, spawnedAt: host.now(), abort: new AbortController(), proof: { inFlight: false, nextAt: Number.POSITIVE_INFINITY } }; round.phase = phase; // The tunnel started but could not be recorded: stop it and wait for its exit before moving on. if (setupFailed) stopCandidate(linkId, phase, "transient"); }; /** Stop a candidate that failed as a route (today's reconnect contract for anything on it). */ const stopCandidate = (linkId: string, phase: Extract<Phase, { kind: "candidate" }>, failure: RouteOutcomeClass): void => { if (phase.stopAt !== undefined) return; phase.failure = failure; phase.stopAt = host.now(); phase.abort.abort(); phase.proof.handle?.dispose(); host.routeProof?.forget(linkId); try { phase.child.kill("SIGTERM"); } catch { /* already gone */ } }; /** * Until the grant: READY_PROOF_MS from spawn. After it: READY_PROOF_MS from the grant, and a grant * seen after that first deadline (before the next tick stopped the candidate) counts from it, so the * deadline is never later than spawn + 2 x READY_PROOF_MS. */ const readinessDeadline = (phase: Extract<Phase, { kind: "candidate" }>): number => (phase.grantedAt === undefined ? phase.spawnedAt : Math.min(phase.grantedAt, phase.spawnedAt + READY_PROOF_MS)) + READY_PROOF_MS; const proven = (linkId: string, link: LinkRoutes, round: Round, phase: Extract<Phase, { kind: "candidate" }>): void => { // A child whose exit was already observed is never promoted, however late its proof settles. if (!host.ownsChild(linkId, phase.child)) return; phase.proof.handle?.dispose(); host.routeProof?.forget(linkId); link.round = undefined; link.active = { route: phase.route, child: phase.child, since: host.now() }; const book = link.books.get(phase.route); if (book) { book.tunnelFailures = 0; book.probeFailures = 0; book.outcome = null; book.outcomeAt = null; book.eligibleAt = 0; } host.setEvent(linkId, { type: "ready", now: host.now() }); void round; }; const execOnRoute = (record: LinkRecord, route: string, argv: readonly string[], deadline: number, signal: AbortSignal, maxOutputBytes?: number) => host.runner.run(buildExecArgv({ alias: record.alias, destination: route, argv, knownHostsFile: host.knownHostsFile(), route: record.explicitRoute ?? null }), { timeoutMs: Math.max(1, Math.ceil(deadline - host.now())), signal, ...(maxOutputBytes === undefined ? {} : { maxOutputBytes }), }); /** One readiness attempt: discovery and identity once per candidate, then a correlated trigger. */ const attempt = async (linkId: string, link: LinkRoutes, round: Round, phase: Extract<Phase, { kind: "candidate" }>): Promise<void> => { const record = host.record(linkId); if (!record) return; const live = (): boolean => current(linkId, round) && round.phase === phase && phase.stopAt === undefined && host.ownsChild(linkId, phase.child); const candidateDeadline = readinessDeadline(phase); const { proof, abort } = phase; try { if (!proof.platform) { proof.platform = record.remotePlatform ?? await requireRemotePlatform(host.runner, record.alias, record.explicitRoute ?? null, host.knownHostsFile(), { destination: phase.route, timeoutMs: Math.max(1, Math.min(10_000, Math.ceil(candidateDeadline - host.now()))), signal: abort.signal, }); if (!live()) return; } if (proof.port === undefined) { const configured = await execOnRoute(record, phase.route, remoteOcxArgv(["config", "show", "--json"], proof.platform), candidateDeadline, abort.signal, CONFIG_MAX_BYTES); if (!live()) return; const port = configured.code === 0 ? childPortOf(configured.stdout) : undefined; if (port === undefined) return; proof.port = port; } if (!proof.healthy) { const health = await execOnRoute(record, phase.route, remoteChildHttpArgv(proof.port, "healthz", candidateDeadline - host.now(), proof.platform), candidateDeadline, abort.signal); if (!live()) return; let body: unknown = null; try { body = health.code === 0 ? parseChildHttp(health.stdout) : null; } catch { body = null; } if (!isChildHealth(body, "client", proof.port)) return; proof.healthy = true; } if (!host.routeProof) return; const attemptDeadline = Math.min(host.now() + PROOF_ATTEMPT_MS, candidateDeadline); const proofId = randomBytes(16).toString("hex"); proof.handle?.dispose(); proof.handle = host.routeProof.register({ linkId, apiKeyId: record.apiKeyId, generation: phase.generation, proofId, expiresAt: attemptDeadline }); const catalog = await execOnRoute(record, phase.route, remoteChildHttpArgv(proof.port, "v1/catalog", attemptDeadline - host.now(), proof.platform, proofId), attemptDeadline, abort.signal, CATALOG_MAX_BYTES); if (!live()) return; let body: unknown = null; try { body = catalog.code === 0 ? parseChildHttp(catalog.stdout) : null; } catch { body = null; } const handle = proof.handle; // Both deadlines hold at promotion too: a result that settles late, before the next tick, does not count. const settledAt = host.now(); if (isCatalog(body) && handle?.admitted() && settledAt <= attemptDeadline && settledAt < candidateDeadline) { proven(linkId, link, round, phase); return; } } catch { /* a failed or aborted step; retried below while time remains */ } finally { proof.inFlight = false; proof.nextAt = host.now() + PROOF_RETRY_MS; } }; const startClientCheck = (): void => { if (client.kind === "checking") return; const abort = new AbortController(); const epoch = ++clientEpoch; client = { kind: "checking", abort, epoch }; void host.runner.run(["ssh", "-V"], { timeoutMs: CLIENT_CHECK_MS, signal: abort.signal }).then(result => { if (stopped || clientEpoch !== epoch) return; client = result.code === 0 && /OpenSSH/.test(result.stderr + result.stdout) ? { kind: "ok" } : { kind: "unsupported", at: host.now() }; }, () => { if (stopped || clientEpoch !== epoch) return; client = { kind: "unsupported", at: host.now() }; }); }; /** A round waiting for the client answer, or a fresh round that may need it. */ const proceed = (linkId: string, link: LinkRoutes, round: Round): void => { if (client.kind === "unsupported" && host.now() >= client.at + CLIENT_RECHECK_MS) client = { kind: "unknown" }; if (client.kind === "unknown") startClientCheck(); if (client.kind === "checking") { round.phase = { kind: "client" }; return; } if (client.kind === "unsupported") { link.round = undefined; link.blocked = "ssh_client_unsupported"; host.setEvent(linkId, { type: "exit", now: host.now(), stderrClass: "network" }, "unknown"); host.deferRetry(linkId, client.at + CLIENT_RECHECK_MS); return; } if (link.blocked === "ssh_client_unsupported") link.blocked = null; next(linkId, link, round); }; return { isMultiRoute, begin(record) { if (!isMultiRoute(record)) return false; if (stopped || host.blocked(record.id)) return true; const link = linkFor(record); if (link.round || link.active) return true; const now = host.now(); const queue = effectiveLinkRoutes(record).filter(name => (link.books.get(name)?.eligibleAt ?? 0) <= now); if (queue.length === 0) { host.deferRetry(record.id, minEligible(link)); return true; } const round: Round = { token: ++tokens, queue, phase: { kind: "client" } }; link.round = round; host.attempted(record.id); host.setEvent(record.id, { type: "spawn", now }); proceed(record.id, link, round); return true; }, tick(linkId) { const link = links.get(linkId); const round = link?.round; if (!link || !round || stopped) return; const now = host.now(); const phase = round.phase; if (round.resume && !host.busy()) { const resume = round.resume; round.resume = undefined; resume(); return; } if (phase.kind === "client") { if (client.kind !== "checking") proceed(linkId, link, round); return; } if (phase.kind === "probe") { if (now - phase.startedAt >= ROUTE_PROBE_MS) { phase.abort.abort(); fail(link, phase.route, "transient", "probe"); next(linkId, link, round); } return; } if (phase.kind === "halted" || phase.kind === "deferred") return; if (phase.stopAt !== undefined) { if (!phase.killed && now - phase.stopAt >= CANDIDATE_KILL_GRACE_MS) { phase.killed = true; try { phase.child.kill("SIGKILL"); } catch { /* already gone */ } } if (now - phase.stopAt >= 2 * CANDIDATE_KILL_GRACE_MS) { // The stopped candidate's exit was never observed: fail closed until it is. round.phase = { kind: "halted", route: phase.route, child: phase.child, failure: phase.failure ?? "readiness" }; link.blocked = "stop_unconfirmed"; host.warn(`[link] route candidate exit unconfirmed link=${linkId}`); } return; } if (now >= readinessDeadline(phase)) { // Unlike a one-route tunnel, which reads connected after its 5 s grace and is never stopped // for lacking proof, a candidate with no proof by now is stopped: a granted forward whose // relay cannot authenticate or serve looks the same as a slow one, and keeping it would // starve the next route forever. A request already on it fails toward its caller, as on // any reconnect; once a route is proven it is never stopped for lack of later proofs. stopCandidate(linkId, phase, phase.grantedAt === undefined ? "grant_unobserved" : "readiness"); return; } if (phase.grantedAt !== undefined && !phase.proof.inFlight && now >= phase.proof.nextAt) { phase.proof.inFlight = true; void attempt(linkId, link, round, phase); } }, exited(linkId, child, stderr, deferForwardRelease) { const link = links.get(linkId); if (!link) return false; if (link.active?.child === child) { const route = link.active.route; link.active = undefined; fail(link, route, routeOutcomeOfStderr(stderr), "tunnel"); if (!stopped) endRoundAfterActive(linkId, link); return true; } const round = link.round; const phase = round?.phase; if (!round || !phase || (phase.kind !== "candidate" && phase.kind !== "halted") || phase.child !== child) return false; const stderrClass = classifySshStderr(stderr); const remoteRefused = phase.kind === "candidate" && phase.stopAt === undefined && phase.grantedAt === undefined && (stderrClass === "remote_forward" || (phase.refused && stderrClass !== "auth" && stderrClass !== "hostkey")); const failure = phase.kind === "halted" ? phase.failure : phase.failure ?? (remoteRefused ? "forward" : routeOutcomeOfStderr(stderr)); if (phase.kind === "candidate") { phase.abort.abort(); phase.proof.handle?.dispose(); } host.routeProof?.forget(linkId); if (link.blocked === "stop_unconfirmed") link.blocked = null; const advance = (): void => { fail(link, phase.route, failure, "tunnel", remoteRefused); if (current(linkId, round)) next(linkId, link, round); }; if (remoteRefused && deferForwardRelease) { const deferred: Phase = { kind: "deferred" }; if (deferForwardRelease(allowed => { if (!current(linkId, round) || round.phase !== deferred) return; if (allowed) candidate(linkId, link, round, phase.route); else advance(); })) { round.phase = deferred; return true; } } advance(); return true; }, cancel(linkId) { const link = links.get(linkId); if (!link) return; const phase = link.round?.phase; if (phase?.kind === "probe" || phase?.kind === "candidate") phase.abort.abort(); if (phase?.kind === "candidate") phase.proof.handle?.dispose(); link.round = undefined; link.active = undefined; if (link.blocked === "stop_unconfirmed") link.blocked = null; host.routeProof?.forget(linkId); }, forget(linkId) { this.cancel(linkId); links.delete(linkId); }, routesChanged(record) { const link = links.get(record.id); if (!link) return; linkFor(record); const round = link.round; if (round?.phase.kind === "probe" || round?.phase.kind === "client" || round?.phase.kind === "deferred") { // Nothing carries traffic yet: start over on the new list. if (round.phase.kind === "probe") round.phase.abort.abort(); round.resume = undefined; round.queue = effectiveLinkRoutes(record).filter(name => (link.books.get(name)?.eligibleAt ?? 0) <= host.now()); proceed(record.id, link, round); return; } if (round) round.queue = round.queue.filter(name => link.books.has(name)); }, adopt(record, child, connectedSince) { if (!isMultiRoute(record)) return; const link = linkFor(record); if (link.round || link.active) return; if (connectedSince !== null) link.active = { route: record.alias, child, since: connectedSince }; }, liveRoute(linkId) { const link = links.get(linkId); const phase = link?.round?.phase; return link?.active?.route ?? (phase && (phase.kind === "candidate" || phase.kind === "halted") ? phase.route : undefined); }, inRound(linkId) { return links.get(linkId)?.round !== undefined; }, status(linkId) { const link = links.get(linkId); const record = host.record(linkId); if (!link || !record) return undefined; const names = effectiveLinkRoutes(record); return { routes: names.map(name => { const book = link.books.get(name); return { name, eligibleAt: book && book.eligibleAt > host.now() ? book.eligibleAt : null, lastOutcome: book?.outcome && book.outcomeAt !== null ? { class: book.outcome, at: book.outcomeAt } : null, }; }), route: link.active ? { name: link.active.route, index: names.indexOf(link.active.route), since: link.active.since } : null, blocked: link.blocked, }; }, recheckClient() { if (client.kind === "checking") client.abort.abort(); clientEpoch += 1; client = { kind: "unknown" }; }, stop() { stopped = true; if (client.kind === "checking") client.abort.abort(); for (const linkId of [...links.keys()]) this.cancel(linkId); }, }; function endRoundAfterActive(linkId: string, link: LinkRoutes): void { const cls = aggregate(link); host.setEvent(linkId, { type: "exit", now: host.now(), stderrClass: cls }, exitCause(cls)); host.deferRetry(linkId, minEligible(link)); } } function childPortOf(stdout: string): number | undefined { try { const value: unknown = JSON.parse(stdout); if (!value || typeof value !== "object" || Array.isArray(value)) return undefined; const port = (value as Record<string, unknown>).port; return typeof port === "number" && Number.isInteger(port) && port >= 1 && port <= 65535 ? port : undefined; } catch { return undefined; } } function isCatalog(value: unknown): boolean { return !!value && typeof value === "object" && !Array.isArray(value) && Array.isArray((value as Record<string, unknown>).models); }