@bitkyc08/opencodex 2.55.0 → 2.57.0

package/src/server/index/startup-warnings.ts

@@ -0,0 +1,213 @@
+import { currentServiceHomes, serviceStatePathsForOpenCodexHome } from "../../service";
+import {
+  createWindowsTaskListingCache,
+  inspectNativeCodexOwnership,
+  type NativeCodexOwnership,
+  type OwnershipInspection,
+} from "../../integrations/native/ownership-preflight";
+import { registerCodexQuotaAutoRefreshWorker } from "../../codex/quota-auto-refresh";
+import {
+  consumeForInspection,
+  relaySseWithHeartbeat,
+  relayWithAbort,
+  responseWithDeferredRequestLog,
+  sanitizePassthroughHeaders,
+} from "../relay";
+import {
+  assertServerAuthConfig,
+  corsHeaders,
+  managementCorsHeaders,
+  isAllowedRequestOrigin,
+  isAllowedManagementOrigin,
+  isApiAuthRequired,
+  isLoopbackHostname,
+  jsonResponse,
+  admissionFields,
+  resolveApiAuth,
+  resolveResponsesApiAuth,
+  requestPolicyView,
+  type DataPlaneAdmission,
+  type RequestPolicyView,
+  safeConfigDTO,
+  setCorsOrigin,
+  withCors,
+  withManagementCors,
+} from "../auth-cors";
+import {
+  bindNativeMainStartupLifecycle,
+  blockNativeMainStartupForUnownedServiceHome,
+  prepareNativeMainStartupLifecycle,
+  releaseNativeMainStartupLifecycle,
+  type NativeMainStartupGateDeps,
+  type NativeMainStartupLifecycle,
+} from "../../codex/native-profile-startup";
+import { fetchAllModels, handleManagementAPI, VERSION, type ManagementApiDeps } from "../management-api";
+import {
+  createManagementSessionControl,
+  initializeManagementAuthState,
+  issueGuiSession,
+  managementPrincipal,
+  requireManagementAuth,
+  type ManagementAuthState,
+} from "../management-auth";
+import { createReadinessGate, type ReadinessGate } from "../readiness";
+import {
+  createRuntimePackageTreeIntegrityGuard,
+  type PackageTreeIntegrityGuard,
+} from "../../lib/package-tree-integrity";
+import type { LiveSidebandWebSocketFactory } from "./live-sideband";
+
+// GUI static serving extracted to ./server/gui-static. Re-exported below to keep the
+// "../src/server" import surface stable for tests/callers.
+
+// Adapter resolution + wire-protocol override extracted to ./server/adapter-resolve.
+
+// Source invariant for tests/responses/passthrough-abort.test.ts after the pure module split:
+// if (isEventStream && upstreamResponse.body) {
+// const repairConfig = route.provider.responsesItemIdRepair;
+// const needsClientRewrite = imageGenCallAliases.size > 0
+// #314 gated shape: win32 always uses the terminal-aware eager relay so a keep-alive
+// upstream cannot hold Codex open after response.completed; darwin no-rewrite traffic
+// requires explicit config-eager opt-in (`auto` always stays tee on darwin).
+// selectEagerPath(process.platform, needsClientRewrite, config.streamMode ?? "auto")
+// Codex upstream WS runtime gating and the forced bounded single-reader branch
+// are owned by responses/ws-upstream.ts and responses/core.ts respectively.
+// relaySseEagerBounded(upstreamResponse.body, turnAc,
+// new Response(eagerBody,
+// Default shape (tee + background inspection):
+// upstreamResponse.body.tee()
+// const repairedBody = hasResponsesItemIdRepair(repairConfig)
+// relaySseWithFailedTail(repairedBody, upstream)
+// new Response(clientBody
+// markNativePassthroughSseResponse
+// const body = relayWithAbort(upstreamResponse.body, upstream);
+// function responseWithDeferredRequestLog
+// isNativePassthroughSseResponse(response)
+// trackSseForRequestLog(
+// export function relaySseWithHeartbeat
+
+const REQUEST_LOG_ID_RESPONSE_HEADER = "x-opencodex-request-id";
+
+export function withRequestLogId(response: Response, requestId: string): Response {
+  const headers = new Headers(response.headers);
+  headers.set(REQUEST_LOG_ID_RESPONSE_HEADER, requestId);
+  // A custom `x-` header is not CORS-safelisted, so cross-origin JavaScript gets null from
+  // `response.headers.get()` even though the header is on the wire. Naming it here is what
+  // makes the id readable by a browser client — the only caller that needs a correlation id
+  // it did not send itself.
+  //
+  // Appending to whatever `withCors` already set, rather than overwriting, keeps this
+  // independent of the CORS layer: if the data plane later exposes another header, both
+  // survive. Duplicate names are harmless, and the header stays absent from responses that
+  // never reach this wrapper, so no management or rejected-origin response is widened.
+  const exposed = headers.get("Access-Control-Expose-Headers");
+  const already = (exposed ?? "")
+    .split(",")
+    .some(name => name.trim().toLowerCase() === REQUEST_LOG_ID_RESPONSE_HEADER);
+  if (!already) {
+    headers.set(
+      "Access-Control-Expose-Headers",
+      exposed ? `${exposed}, ${REQUEST_LOG_ID_RESPONSE_HEADER}` : REQUEST_LOG_ID_RESPONSE_HEADER,
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+export interface StartServerDeps {
+  /** Test-only seam; production always initializes its own management credential state. */
+  managementAuthState?: ManagementAuthState;
+  /** Test-only route dependencies, forwarded only after management admission succeeds. */
+  managementApi?: ManagementApiDeps;
+  /** Test-only native-main recovery dependencies; production constructs the normal manager. */
+  nativeMainStartup?: NativeMainStartupGateDeps;
+  /** Test-only ownership evidence; production inspects the installed service state. */
+  inspectNativeCodexOwnership?: typeof inspectNativeCodexOwnership;
+  /** Test-only service-home resolver; production resolves the current homes directly. */
+  resolveServiceHomes?: typeof currentServiceHomes;
+  /** Test-only seam for an upstream that cannot complete its WebSocket close handshake. */
+  liveSidebandWebSocketFactory?: LiveSidebandWebSocketFactory;
+  /** Test-only seam; production derives a fresh local-attestation secret per process. */
+  localAttestationSecret?: string;
+  /** Optional readiness gate; a fresh pending gate is created when omitted. */
+  readinessGate?: ReadinessGate;
+  /** Test-only package-tree observation; production captures package.json identity at boot. */
+  packageTreeIntegrity?: PackageTreeIntegrityGuard;
+  /** Test-only seam for observing quota-worker registration ownership. */
+  registerCodexQuotaAutoRefreshWorker?: typeof registerCodexQuotaAutoRefreshWorker;
+}
+
+export function inspectStartupOwnership(
+  deps: StartServerDeps,
+  currentHomes: ReturnType<typeof currentServiceHomes> | null,
+  statePaths: readonly string[] | null,
+  windowsTaskListingCache?: ReturnType<typeof createWindowsTaskListingCache>,
+): OwnershipInspection {
+  try {
+    if (currentHomes === null || statePaths === null) {
+      return {
+        ownership: "unknown",
+        reason: "startup service-home resolution failed",
+      };
+    }
+    if (deps.inspectNativeCodexOwnership) {
+      return deps.inspectNativeCodexOwnership({ currentHomes, statePaths, windowsTaskListingCache });
+    }
+    return inspectNativeCodexOwnership({ currentHomes, statePaths, windowsTaskListingCache });
+  } catch {
+    return {
+      ownership: "unknown",
+      reason: "service-home ownership inspection failed",
+    };
+  }
+}
+
+/*
+ * #1046. `startServer` rewrites the Codex models cache during boot, and an
+ * app-server that started earlier keeps its own in-memory model list. The stale
+ * warning is not emitted here: `handleStart` runs a catalog sync moments later,
+ * so warning now would read an mtime that write is about to move, and both sites
+ * calling the helper independently would warn twice. This records the fact; the
+ * CLI start path owns the single decision.
+ *
+ * A caller that starts a server without `handleStart` (tests, embedded use)
+ * deliberately gets no warning — lifecycle diagnostics belong to whoever owns
+ * the lifecycle.
+ */
+let startupCacheInvalidationWrote = false;
+
+/** #1046: did this process's startup cache invalidation actually write? */
+/**
+ * The composition root owns WHEN the startup cache invalidation runs, but the flag lives here
+ * with its reader. An ES import binding is read-only, so the root cannot assign to it across
+ * the module boundary the way it did when both sides were one file. This setter is that
+ * assignment, kept next to the reader so the two cannot drift apart.
+ */
+export function setStartupCacheInvalidationWrite(wrote: boolean): void {
+  startupCacheInvalidationWrote = wrote;
+}
+
+export function consumeStartupCacheInvalidationWrite(): boolean {
+  const wrote = startupCacheInvalidationWrote;
+  startupCacheInvalidationWrote = false;
+  return wrote;
+}
+
+export function warnAgentTaskRecoveryStartup(config: {
+  agentTaskRecovery?: { enabled?: boolean };
+}): void {
+  if (config.agentTaskRecovery?.enabled !== true) return;
+  console.warn("⚠️  Experimental encrypted V2 task recovery is enabled.");
+  console.warn("   A scoped cache miss may send an additional authenticated request to ChatGPT and may consume quota or add latency; concurrent misses can share one request.");
+  console.warn("   Recovered plaintext assignment data is retained only in a bounded, process-local in-memory cache; exact fidelity is not guaranteed and the path depends on undocumented backend behavior.");
+}
+
+export function warnPlaintextV2AgentMessagesStartup(config: { plaintextV2AgentMessages?: boolean }): void {
+  if (config.plaintextV2AgentMessages !== true) return;
+  console.warn("⚠️  Experimental plaintext V2 agent messages are enabled.");
+  console.warn("   Eligible ChatGPT collaboration calls may carry plaintext message arguments. HTTPS remains encrypted, but task text may be retained in Codex history, selected providers, and local response/debug state.");
+  console.warn("   This depends on undocumented ChatGPT and Codex behavior; it does not decrypt existing tasks.");
+}

package/src/server/index/websocket-handler.ts

@@ -0,0 +1,339 @@
+import type { Server, ServerWebSocket } from "bun";
+import {
+  LIVE_SIDEBAND_UPSTREAM_OPEN_TIMEOUT_MS,
+  MAX_WS_FRAME_BYTES,
+  WEBSOCKET_IDLE_TIMEOUT_SECONDS,
+  attachLiveSidebandUpstream,
+  clientCloseForUpstream,
+  closeLiveSideband,
+  closeLiveSidebandBeforeUpgrade,
+  enqueueLiveSidebandPendingFrame,
+  exceedsLiveSidebandFrameByteLimit,
+  openLiveSidebandUpstream,
+  sendUpstreamFrame,
+  webSocketFrameBytes,
+} from "./live-sideband";
+import { markActivity } from "../../lib/sidecar-tracker";
+import {
+  buildWarmupCompletionFrames,
+  buildWsErrorFrame,
+  selectForwardHeaders,
+  sendJsonFrame,
+  buildResponsesWsData,
+  sendResponseToWebSocket,
+  sendTextFrame,
+  type WsData,
+} from "../ws-bridge";
+import {
+  CodexAccountCooldownError,
+  cooldownErrorMessage,
+} from "../../codex/auth-context";
+import { codexAccountNamespaceForModel } from "../../codex/account-namespace-match";
+import {
+  registerCodexWebSocket,
+  tryReserveCodexWebSocket,
+  unregisterCodexWebSocket,
+  updateCodexWebSocketAuthContext,
+} from "../../codex/websocket-registry";
+import {
+  formatErrorResponse,
+  type ResponsesTerminalStatus,
+} from "../../bridge";
+import {
+  isDraining,
+  registerTurn,
+  tryAdmitTurn,
+  unregisterTurn,
+  type ActiveTurnLease,
+} from "../lifecycle";
+import {
+  addFinalRequestLog,
+  httpStatusForRequestLogTerminal,
+  inspectResponseLogSsePayload,
+  nextRequestLogId,
+  recordFirstOutput,
+  type RequestLogContext,
+  type RequestLogEntry,
+} from "../request-log";
+import {
+  corsHeaders,
+  managementCorsHeaders,
+  isAllowedRequestOrigin,
+  isAllowedManagementOrigin,
+  isApiAuthRequired,
+  jsonResponse,
+  admissionFields,
+  resolveApiAuth,
+  resolveResponsesApiAuth,
+  type RequestPolicyView,
+  withCors,
+  withManagementCors,
+} from "../auth-cors";
+import {
+  disableResponsesRequestTimeout,
+  handleResponses,
+  handleResponsesCompact,
+} from "../responses";
+import {
+  handleLive,
+  logLiveSidebandFrame,
+  parseLiveSidebandTarget,
+  resolveLiveSidebandUpgrade,
+} from "../live";
+import type { ServeOptionsContext } from "./serve-options";
+
+/**
+ * The WebSocket half of the Bun.serve options, split out of serve-options.ts to keep that file
+ * under the 2,000-line ratchet threshold. The body is the original handler verbatim; it reads the
+ * same startServer context the HTTP half does, so it takes the same context object.
+ */
+export function createWebsocketHandler(ctx: ServeOptionsContext) {
+  const { config, deps } = ctx;
+  return {
+      maxPayloadLength: MAX_WS_FRAME_BYTES,
+      idleTimeout: WEBSOCKET_IDLE_TIMEOUT_SECONDS,
+      // Responses WebSocket data plane (phase 120.2). Re-frames the same SSE pipeline onto the
+      // socket: parse response.create → run handleResponses unchanged → pump its SSE body as WS
+      // Text frames. response.processed is a no-op ack. close() aborts the upstream (RC2 parity).
+      // Live sideband sockets (kind=live-sideband) are a transparent bidirectional relay instead.
+      open(ws: ServerWebSocket<WsData>) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          const open = ws.data.remoteWorkspaceOpen;
+          if (!open) {
+            ws.close(1011, "remote workspace connection unavailable");
+            return;
+          }
+          try {
+            ws.data.remoteWorkspaceConnection = open(ws);
+          } catch {
+            ws.close(1011, "remote workspace connection failed");
+          }
+          return;
+        }
+        if (ws.data.kind === "live-sideband") {
+          if (!ws.data.liveTurnAdmissionLease) {
+            closeLiveSideband(ws, 1013, "server busy");
+            return;
+          }
+          attachLiveSidebandUpstream(ws, deps.liveSidebandWebSocketFactory);
+          return;
+        }
+        if (!ws.data.admissionLease) {
+          ws.close(1013, "server busy");
+          return;
+        }
+        ws.data.admissionLease.bind(ws);
+        registerCodexWebSocket(ws);
+      },
+      message(ws: ServerWebSocket<WsData>, raw: string | Buffer) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          try {
+            ws.data.remoteWorkspaceConnection?.receive(raw);
+          } catch {
+            ws.close(1008, "remote workspace protocol error");
+          }
+          return;
+        }
+        if (ws.data.kind === "live-sideband") {
+          if (ws.data.liveClosing) return;
+          if (ws.data.liveValidateFrame && !ws.data.liveValidateFrame(raw)) {
+            closeLiveSideband(ws, 1008, "invalid audio event");
+            return;
+          }
+          const rawBytes = webSocketFrameBytes(raw);
+          if (exceedsLiveSidebandFrameByteLimit(rawBytes)) {
+            closeLiveSideband(ws, 1009, "message too large");
+            return;
+          }
+          logLiveSidebandFrame("c2u", raw);
+          const upstream = ws.data.liveUpstream;
+          if (!upstream || upstream.readyState === WebSocket.CONNECTING || !ws.data.liveOpened) {
+            const enqueueResult = enqueueLiveSidebandPendingFrame(ws.data, raw, rawBytes);
+            if (enqueueResult === "too-many-frames") {
+              closeLiveSideband(ws, 1009, "too many pending frames");
+              return;
+            }
+            if (enqueueResult === "too-many-bytes") {
+              closeLiveSideband(ws, 1009, "too many pending bytes");
+              return;
+            }
+            return;
+          }
+          if (upstream.readyState !== WebSocket.OPEN) {
+            closeLiveSideband(ws, 1011, "upstream not open");
+            return;
+          }
+          try {
+            sendUpstreamFrame(upstream, raw);
+            if (ws.data.liveMaxSessionMs !== undefined && upstream.bufferedAmount > MAX_WS_FRAME_BYTES) {
+              closeLiveSideband(ws, 1013, "audio upstream backpressure");
+            }
+          } catch {
+            closeLiveSideband(ws, 1011, "upstream send failed");
+          }
+          return;
+        }
+        const rawBytes = typeof raw === "string" ? Buffer.byteLength(raw) : raw.byteLength;
+        if (rawBytes > MAX_WS_FRAME_BYTES) {
+          sendJsonFrame(ws, buildWsErrorFrame(413, {
+            type: "invalid_request_error",
+            message: "WebSocket response.create frame is too large",
+          }));
+          ws.close(1009, "message too large");
+          return;
+        }
+        let frame: Record<string, unknown>;
+        try {
+          frame = JSON.parse(typeof raw === "string" ? raw : raw.toString()) as Record<string, unknown>;
+        } catch {
+          return; // text-only contract; ignore unparseable frames
+        }
+        if (frame.type === "response.processed") return; // ack — no-op
+        if (frame.type !== "response.create") return;
+        markActivity("ws response.create");
+
+        ws.data.cancel?.();
+        const turnId = (ws.data.turnId ?? 0) + 1;
+        ws.data.turnId = turnId;
+        const isCurrent = () => ws.data.turnId === turnId;
+        const turnAbort = new AbortController();
+        const cancelTurn = () => {
+          turnAbort.abort("websocket turn superseded or closed");
+        };
+        ws.data.cancel = cancelTurn;
+        // A socket may carry several response.create frames. Clear the previous
+        // account before resolving this frame so a failed Multi resolution cannot
+        // leave stale invalidation ownership behind.
+        updateCodexWebSocketAuthContext(ws, undefined);
+
+        if (frame.generate === false) {
+          for (const payload of buildWarmupCompletionFrames(frame)) {
+            if (!isCurrent()) return;
+            sendTextFrame(ws, payload);
+          }
+          if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
+          return;
+        }
+
+        const turnAdmissionLease = tryAdmitTurn(ws.data.sessionLaneId);
+        if (!turnAdmissionLease) {
+          sendJsonFrame(ws, buildWsErrorFrame(503, {
+            type: "server_error",
+            code: "server_busy",
+            message: "active turns capacity reached",
+            retryable: true,
+          }, new Headers({ "Retry-After": "1" })));
+          if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
+          return;
+        }
+
+        const payload: Record<string, unknown> = { ...frame };
+        delete payload.type;
+        turnAdmissionLease.bindAbortController(turnAbort);
+        void (async () => {
+          const start = Date.now();
+          const requestId = nextRequestLogId(start);
+          // Resolved once at the handshake — a frame has no request headers left
+          // to re-resolve from. Optional on WsData like every other member, so
+          // narrow rather than assume: an unattributed frame is preferable to a
+          // fabricated attribution.
+          const wsAdmission = ws.data.admission;
+          const logCtx: RequestLogContext = {
+            model: "unknown",
+            provider: "unknown",
+            ...(wsAdmission ? admissionFields(wsAdmission) : {}),
+            inboundProtocol: "responses",
+          };
+          let logged = false;
+          const finalizeLog = (
+            status: number,
+            meta?: Pick<RequestLogEntry, "terminalStatus" | "closeReason">,
+          ) => {
+            if (logged) return;
+            logged = true;
+            addFinalRequestLog(requestId, start, logCtx, status, meta);
+          };
+          const baseHeaders = ws.data.headers ?? new Headers();
+          const fwd = new Headers({ "content-type": "application/json" });
+          baseHeaders.forEach((value, key) => fwd.set(key, value));
+          const req = new Request("http://localhost/v1/responses", {
+            method: "POST",
+            headers: fwd,
+            body: JSON.stringify({ ...payload, stream: true }),
+          });
+          try {
+            let terminalRecorder: ((status: ResponsesTerminalStatus, httpStatusOverride?: number) => void) | undefined;
+            const response = await handleResponses(req, config, logCtx, {
+              ...(wsAdmission ? { admission: wsAdmission } : {}),
+              forceEmptyResponseId: true,
+              inboundTransport: "websocket",
+              abortSignal: turnAbort.signal,
+              turnAdmissionLease,
+              onFirstOutput: () => recordFirstOutput(logCtx, start),
+              onCodexAuthContextResolved: context => updateCodexWebSocketAuthContext(ws, context),
+              recordTerminalOutcomes: false,
+              setTerminalOutcomeRecorder: recorder => {
+                terminalRecorder = recorder;
+              },
+            });
+            await sendResponseToWebSocket(ws, response, isCurrent, {
+              onSsePayload: payload => inspectResponseLogSsePayload(logCtx, payload),
+              onTerminal: status => {
+                terminalRecorder?.(status, logCtx.terminalHttpStatus);
+                finalizeLog(httpStatusForRequestLogTerminal(status, logCtx), {
+                  terminalStatus: status,
+                  closeReason: "terminal",
+                });
+              },
+            });
+            if (!logged) finalizeLog(turnAbort.signal.aborted ? 499 : response.status);
+          } catch (err) {
+            if (!isCurrent()) return;
+            try {
+              if (err instanceof CodexAccountCooldownError) {
+                finalizeLog(429);
+                // Codex Desktop rides this WS transport, so it must carry the same
+                // actionable text as HTTP; a frame has no headers, hence message-only.
+                const accountSelector = typeof payload.model === "string"
+                  ? codexAccountNamespaceForModel(config.codexAccountNamespaces, payload.model)
+                  : undefined;
+                sendJsonFrame(ws, buildWsErrorFrame(429, {
+                  type: "rate_limit_error",
+                  message: cooldownErrorMessage(err, accountSelector),
+                }));
+                return;
+              }
+              finalizeLog(502);
+              sendJsonFrame(ws, buildWsErrorFrame(502, {
+                type: "proxy_error",
+                message: err instanceof Error ? err.message : String(err),
+              }));
+            } catch {
+              /* socket already gone or send dropped */
+            }
+          } finally {
+            turnAdmissionLease.release();
+            if (!logged && turnAbort.signal.aborted) finalizeLog(499);
+            if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
+          }
+        })();
+      },
+      close(ws: ServerWebSocket<WsData>, code: number, reason: string) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          ws.data.remoteWorkspaceClose?.();
+          return;
+        }
+        if (ws.data.kind === "live-sideband") {
+          // Carry the client's own close through to the upstream instead of reporting every
+          // hang-up as a plain 1000.
+          const forwarded = clientCloseForUpstream(code, reason);
+          closeLiveSideband(ws, forwarded.code, forwarded.reason);
+          return;
+        }
+        unregisterCodexWebSocket(ws);
+        ws.data.admissionLease?.release();
+        ws.data.admissionLease = undefined;
+        ws.data.cancel?.(); // RC2: abort the upstream when the client disconnects
+      },
+  } as const;
+}