@bitkyc08/opencodex 2.65.0 → 2.66.0

package/src/cli/runtime-api.ts

@@ -14,6 +14,8 @@ import { runningProxyUpdateHeaders } from "../oauth/login-cli";
 
 export type CliStdin = NodeJS.ReadableStream & { isTTY?: boolean; readableEnded?: boolean };
 
+export const MAX_LINK_CREDENTIAL_BYTES = 4 * 1024;
+
 export interface RuntimeApiDeps {
   baseUrl?: string;
   fetchImpl?: typeof fetch;
@@ -389,6 +391,81 @@ export async function readSecretLine(deps: RuntimeApiDeps, label: string): Promi
   return line;
 }
 
+/** Read a bounded secret payload while keeping the original bytes available for zeroing. */
+export async function readSecretBytes(
+  deps: RuntimeApiDeps,
+  label: string,
+  maxBytes = MAX_LINK_CREDENTIAL_BYTES,
+): Promise<Uint8Array> {
+  const input: CliStdin = deps.stdinImpl ?? process.stdin;
+  const timeoutMs = deps.stdinTimeoutMs ?? 120_000;
+  if (input.readableEnded === true) throw new CliUsageError(`${label} input was empty`);
+  return await new Promise<Uint8Array>((resolve, reject) => {
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      input.removeListener("data", onData);
+      input.removeListener("end", onEnd);
+      input.removeListener("error", onError);
+    };
+    const wipeChunks = () => {
+      for (const chunk of chunks) chunk.fill(0);
+    };
+    const finish = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try { fn(); }
+      finally { wipeChunks(); }
+    };
+    const onData = (chunk: unknown) => {
+      const source = chunk instanceof Uint8Array ? chunk : undefined;
+      let bytes: Uint8Array | undefined;
+      let retained = false;
+      try {
+        bytes = typeof chunk === "string"
+          ? new TextEncoder().encode(chunk)
+          : source
+            ? new Uint8Array(source)
+            : new TextEncoder().encode(String(chunk));
+        total += bytes.byteLength;
+        if (total > maxBytes) {
+          finish(() => reject(new CliUsageError(`${label} exceeds ${maxBytes} bytes`)));
+          return;
+        }
+        chunks.push(bytes);
+        retained = true;
+      } finally {
+        source?.fill(0);
+        if (!retained) bytes?.fill(0);
+      }
+    };
+    const onEnd = () => finish(() => {
+      if (total === 0) {
+        reject(new CliUsageError(`${label} input was empty`));
+        return;
+      }
+      const result = new Uint8Array(total);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      resolve(result);
+    });
+    const onError = (error: Error) => finish(() => reject(error));
+    const timer = setTimeout(
+      () => finish(() => reject(new CliUsageError(`timed out waiting for ${label} on stdin`))),
+      timeoutMs,
+    );
+    input.on("data", onData);
+    input.on("end", onEnd);
+    input.on("error", onError);
+  });
+}
+
 export function printData(value: unknown, wantsJson: boolean, lines?: string[]): void {
   if (wantsJson || !lines) console.log(JSON.stringify(value, null, 2));
   else for (const line of lines) console.log(line);
@@ -406,6 +483,8 @@ export function desktopSwitchApplyReason(reason: unknown): string {
   if (reason === "not_requested") return "no desktop switch rewrite was requested";
   if (reason === "proxy_not_running") return "the proxy is not running";
   if (reason === "integration_disabled") return "Codex integration is disabled";
+  if (reason === "external_provider") return "an external model provider owns config.toml";
+  if (reason === "ownership_undetermined") return "config.toml ownership could not be determined";
   if (reason === "write_lock_busy") return "the Codex config write lock is busy";
   if (reason === "injection_refused") return "Codex config injection was refused";
   return "the rewrite could not be completed";

package/src/cli/system-command.ts

@@ -57,6 +57,7 @@ function desktopSwitchInertReason(reason: unknown): string {
   return "the stored setting is not effective in the current runtime configuration";
 }
 
+
 function settingsUpdateLines(
   result: unknown,
   changed: { desktopAuthless: boolean; clientCompaction: boolean },
@@ -68,8 +69,19 @@ function settingsUpdateLines(
   const lines: string[] = [];
   const appendSwitch = (key: string, label: string): boolean => {
     const state = recordValue(switches[key]);
-    if (!state || typeof state.stored !== "boolean" || typeof state.effective !== "boolean") return false;
+    if (!state || typeof state.stored !== "boolean"
+      || (typeof state.effective !== "boolean" && state.effective !== null)) return false;
     lines.push(`${label}: stored ${state.stored ? "on" : "off"}.`);
+    if (state.effective === null) {
+      // `null` is reported for both withheld cases; the apply reason is the only place
+      // that still distinguishes them, so the line has to read it rather than claim
+      // external control over an ownership the server could not determine.
+      const withheld = recordValue(switches.apply)?.reason === "ownership_undetermined"
+        ? "effective state could not be determined"
+        : "effective state is controlled by the external model provider";
+      lines.push(`${label}: ${withheld}.`);
+      return true;
+    }
     // The effective value is always stated, even when it matches. Printing it only on a
     // mismatch would make silence ambiguous — the reader could not tell "the stored value is
     // in force" from "this build does not report effective state", and that ambiguity is a
@@ -96,7 +108,14 @@ function settingsUpdateLines(
     lines.push("Codex config: ~/.codex/config.toml was rewritten.");
   } else {
     const detail = typeof apply.detail === "string" && apply.detail.length > 0 ? ` Details: ${apply.detail}` : "";
-    lines.push(`Codex config: ~/.codex/config.toml was not rewritten because ${desktopSwitchApplyReason(apply.reason)}.${detail} Run 'ocx sync' to apply the stored settings.`);
+    const retry = apply.reason === "external_provider"
+      ? ""
+      : apply.reason === "ownership_undetermined"
+      ? " Resolve the reported config.toml read error, then inspect 'ocx system settings --json'."
+      : apply.reason === "integration_disabled"
+      ? " Enable Codex integration before applying the stored settings."
+      : " Run 'ocx sync' to apply the stored settings.";
+    lines.push(`Codex config: ~/.codex/config.toml was not rewritten because ${desktopSwitchApplyReason(apply.reason)}.${detail}${retry}`);
   }
   lines.push(`Auth source: ${authSource.summary}`);
   return lines;

package/src/client/connect.ts

@@ -66,11 +66,14 @@ import {
   clearClientConnection,
   commitClientConnection,
   readClientConnectionState,
+  isLinkConnection,
   markClientConnectPending, clearClientConnectPending, pendingClientConnectMayOwnToken,
   assertNoClientDisconnectPending, assertClientConnectionUnchanged, sameClientConnectionOwner,
 } from "./state";
 import { assertClientCatalogCompatible, type CatalogCompatibilityDeps } from "./catalog-compatibility";
 import { hubStateCachePath } from "./hub-state";
+import { ClientLinkStateError, clearClientLinkState, readClientLinkState } from "./link-state";
+import { isLinkPort } from "../link/ports";
 
 class RotationRecoveryRequiredError extends Error {
   constructor(message: string, options?: ErrorOptions) {
@@ -82,13 +85,21 @@ class RotationRecoveryRequiredError extends Error {
 export interface ConnectOptions {
   serverUrl: string;
   managementUrl?: string;
-  credential: OneTimeConnectCredential;
+  credential: OneTimeConnectCredential | LinkClientCredential;
   selectedClients: OcxConnectedClientId[];
   managementTransport: "direct" | "relay";
+  transport?: "hub" | "link";
+  link?: { tunnelPort: number; linkId: string };
   noSync?: boolean;
   catalogTimeoutMs?: number;
 }
 
+export interface LinkClientCredential {
+  kind: "link";
+  apiKeyId: string;
+  key: string;
+}
+
 export interface ClientConnectDeps {
   fetchImpl?: typeof fetch;
   now?: () => Date;
@@ -158,11 +169,20 @@ function catalogMatchesFingerprint(body: string, fingerprint: string | undefined
   return createHash("sha256").update(body).digest("base64url") === fingerprint;
 }
 
-function routingTarget(serverUrl: string): CodexRoutingTarget {
+export function routingTarget(serverUrl: string, localPort?: number): CodexRoutingTarget & { link?: true } {
+  const baseUrl = localPort === undefined
+    ? `${serverUrl}/v1`
+    : (() => {
+      if (!Number.isInteger(localPort) || localPort < 1 || localPort > 65535) {
+        throw new Error("link mode requires a valid local config port");
+      }
+      return `http://localhost:${localPort}/v1`;
+    })();
   return {
-    baseUrl: `${serverUrl}/v1`,
+    baseUrl,
     requiresAdmissionToken: true,
     tokenEnv: "OPENCODEX_API_AUTH_TOKEN",
+    ...(localPort === undefined ? {} : { link: true as const }),
   };
 }
 
@@ -180,6 +200,10 @@ function releaseCredential(credential: OneTimeConnectCredential): void {
   credential.value.fill(0);
 }
 
+function releaseConnectCredential(credential: ConnectOptions["credential"]): void {
+  if (credential.kind !== "link") releaseCredential(credential);
+}
+
 async function rotationAuthority(
   connection: OcxClientConnectionConfig,
   options: RotateClientOptions,
@@ -349,6 +373,7 @@ export async function recoverPendingClientRotation(
       assertNoClientDisconnectPending();
       const state = readClientConnectionState();
       if (state.kind !== "connected" || !state.value.pendingOperation) throw new Error("no pending client key rotation to recover");
+      if (isLinkConnection(state.value)) throw new Error("connect rotate is unavailable in link mode");
       const authority = await rotationAuthority(state.value, options, deps);
       assertClientConnectionUnchanged(state.value);
       return recoverRotationWithAuthority(held, state.value, authority, deps);
@@ -381,6 +406,7 @@ async function rotateConnectedClientKeyHeld(
     const state = readClientConnectionState();
     if (state.kind !== "connected") throw new Error("connect rotate is available only while connected");
     connection = state.value;
+    if (isLinkConnection(connection)) throw new Error("connect rotate is unavailable in link mode");
     const current = readServiceApiTokenState();
     if (current.kind !== "present") throw new Error("connected service token unavailable");
     if (!connection.pendingOperation) {
@@ -501,6 +527,9 @@ export async function connectClient(
 ): Promise<OcxClientConnectionConfig> {
   let serverUrl = "";
   let managementUrl = "";
+  let linkAdmissionToken: string | null = null;
+  let linkMode = false;
+  let linkMetadata: { tunnelPort: number; linkId: string } | undefined;
   let issued: IssuedClientKey | null = null;
   let cleanupCredential: { kind: "admin"; value: Uint8Array } | { kind: "gui-session"; value: ConnectGuiSession } | null = null;
   let tokenFingerprint: string | null = null;
@@ -510,22 +539,68 @@ export async function connectClient(
   let injectionCommitted = false;
   let committed = false;
   try {
-    serverUrl = normalizeHubOrigin(options.serverUrl);
-    if (options.managementUrl) managementUrl = normalizeHubOrigin(options.managementUrl);
+    linkMode = (options.transport ?? "hub") === "link";
+    if (linkMode) {
+      if (options.credential.kind !== "link" || !options.link
+        || !isLinkPort(options.link.tunnelPort)
+        || !/^lnk_[0-9a-f]{16}$/.test(options.link.linkId)
+        || !/^ocx_data_[0-9a-f]{40}$/.test(options.credential.key)
+        || !options.credential.apiKeyId.trim() || options.credential.apiKeyId.length > 256) {
+        throw new Error("invalid link credential");
+      }
+      linkMetadata = { ...options.link };
+      serverUrl = `http://127.0.0.1:${linkMetadata.tunnelPort}`;
+      if ((options.managementUrl && options.managementUrl !== serverUrl) || options.managementTransport !== "direct") {
+        throw new Error("link mode requires direct management on the tunnel origin");
+      }
+      managementUrl = serverUrl;
+    } else {
+      if (options.credential.kind === "link" || options.link) throw new Error("link credential requires link transport");
+      serverUrl = normalizeHubOrigin(options.serverUrl);
+      if (options.managementUrl) managementUrl = normalizeHubOrigin(options.managementUrl);
+    }
     if (options.selectedClients.length < 1 || new Set(options.selectedClients).size !== options.selectedClients.length) {
       throw new Error("at least one unique connected client is required");
     }
+    // Only link mode needs the local port before the hub is contacted; hub mode keeps reading config
+    // after the catalog download, so its stderr order (catalog refusal first) is unchanged.
+    const earlyConfig = linkMode ? loadConfig() : undefined;
+    if (earlyConfig && (!Number.isInteger(earlyConfig.port) || earlyConfig.port < 1 || earlyConfig.port > 65535)) {
+      throw new Error("link mode requires a valid local config port");
+    }
     withClientLifecycleSync(() => withConfigMutationLockSync(() => {
       assertConnectingState();
       const externalProvider = currentExternalCodexModelProvider();
       if (externalProvider) throw new Error("connect refused: an external Codex provider owns config.toml");
+      if (linkMode) {
+        const credential = options.credential;
+        if (credential.kind !== "link") throw new Error("invalid link credential");
+        const persisted = writeServiceApiTokenFile(credential.key);
+        pendingConnectFingerprint = persisted.fingerprint;
+        const reread = readServiceApiTokenState();
+        if (reread.kind !== "present" || reread.fingerprint !== persisted.fingerprint) {
+          throw new Error("invalid link credential");
+        }
+        markClientConnectPending(persisted.fingerprint);
+        linkAdmissionToken = reread.token;
+      }
     }), deps.lifecycleLockDeps);
 
-    const ready = await fetchHubReady(serverUrl, { fetchImpl: deps.fetchImpl });
+    const upstreamFetch = deps.fetchImpl ?? fetch;
+    const readinessFetch = linkMode
+      ? (async (input, init = {}) => {
+        const url = input instanceof Request ? input.url : String(input);
+        if (!url.endsWith("/readyz")) return upstreamFetch(input, init);
+        const headers = new Headers(init.headers);
+        headers.set("x-opencodex-api-key", linkAdmissionToken!);
+        return upstreamFetch(input, { ...init, headers });
+      }) as typeof fetch
+      : upstreamFetch;
+    const ready = await fetchHubReady(serverUrl, { fetchImpl: readinessFetch });
     if (ready.status !== "ready") throw new Error(`hub is not ready (${ready.status})`);
-    managementUrl = managementUrl || ready.metadata.managementUrl;
+    if (!linkMode) managementUrl = managementUrl || ready.metadata.managementUrl;
 
-    if (options.credential.kind === "pairing-grant") {
+    if (!linkMode && options.credential.kind === "pairing-grant") {
       const session = await exchangeConnectPairingGrant(
         managementUrl,
         localGuiOrigin(),
@@ -533,23 +608,37 @@ export async function connectClient(
         { fetchImpl: deps.fetchImpl },
       );
       cleanupCredential = { kind: "gui-session", value: session };
-    } else {
+    } else if (!linkMode && options.credential.kind === "admin") {
       cleanupCredential = { kind: "admin", value: options.credential.value };
     }
-    issued = await issueClientKey(managementUrl, cleanupCredential, clientKeyName(), { fetchImpl: deps.fetchImpl });
+    if (!linkMode) {
+      issued = await issueClientKey(managementUrl, cleanupCredential!, clientKeyName(), { fetchImpl: deps.fetchImpl });
+    }
 
     const initialFiles = withClientLifecycleSync(() => withConfigMutationLockSync(() => {
-      assertConnectingState();
-      const fingerprint = serviceApiTokenFingerprint(issued!.key);
-      markClientConnectPending(fingerprint);
-      pendingConnectFingerprint = fingerprint;
-      return { prior: catalogSnapshot(), persisted: writeServiceApiTokenFile(issued!.key) };
+      assertConnectingState(linkMode ? pendingConnectFingerprint! : undefined);
+      const persisted = linkMode
+        ? (() => {
+          const current = readServiceApiTokenState();
+          if (current.kind !== "present") throw new Error("invalid link credential");
+          return { fingerprint: current.fingerprint };
+        })()
+        : writeServiceApiTokenFile(issued!.key);
+      const fingerprint = persisted.fingerprint;
+      if (!pendingConnectFingerprint) {
+        markClientConnectPending(fingerprint);
+        pendingConnectFingerprint = fingerprint;
+      }
+      return { prior: catalogSnapshot(), persisted };
     }), deps.lifecycleLockDeps);
     priorCatalog = initialFiles.prior;
     const persisted = initialFiles.persisted;
     tokenFingerprint = persisted.fingerprint;
 
-    const catalog = await downloadClientCatalog(serverUrl, issued.key, {
+    const admissionToken = linkMode ? linkAdmissionToken : issued?.key;
+    if (!admissionToken) throw new Error("client admission credential unavailable");
+    const apiKeyId = linkMode ? (options.credential as LinkClientCredential).apiKeyId : issued!.id;
+    const catalog = await downloadClientCatalog(serverUrl, admissionToken, {
       fetchImpl: deps.fetchImpl,
       timeoutMs: options.catalogTimeoutMs,
     });
@@ -565,14 +654,14 @@ export async function connectClient(
       return sha256(catalog.body);
     }), deps.lifecycleLockDeps);
 
-    const config = loadConfig();
-    const target = routingTarget(serverUrl);
+    const config = earlyConfig ?? loadConfig();
+    const target = routingTarget(serverUrl, linkMode ? config.port : undefined);
     const injectConfig = { ...config, syncResumeHistory: false };
     const preflight = await injectCodexConfig(config.port, injectConfig, {
       validateOnly: true,
       routingTarget: target,
       catalogPath: DEFAULT_CATALOG_PATH,
-      journalOwner: { kind: "client", apiKeyId: issued.id },
+      journalOwner: { kind: "client", apiKeyId },
       beforeClientWrite: () => assertConnectingState(persisted.fingerprint),
     });
     if (!preflight.success) throw new Error(preflight.message);
@@ -581,7 +670,7 @@ export async function connectClient(
       const injected = await injectCodexConfig(config.port, injectConfig, {
         routingTarget: target,
         catalogPath: DEFAULT_CATALOG_PATH,
-        journalOwner: { kind: "client", apiKeyId: issued.id },
+        journalOwner: { kind: "client", apiKeyId },
         beforeClientWrite: () => assertConnectingState(persisted.fingerprint),
       });
       if (!injected.success || injected.status === "skipped") throw new Error(injected.message);
@@ -596,7 +685,7 @@ export async function connectClient(
       managementTransport: options.managementTransport,
       selectedClients: [...options.selectedClients],
       tokenEnv: "OPENCODEX_API_AUTH_TOKEN",
-      apiKeyId: issued.id,
+      apiKeyId,
       tokenFingerprint: persisted.fingerprint,
       protocolVersion: 1,
       connectedAt: now,
@@ -606,6 +695,7 @@ export async function connectClient(
       // back in the same run.
       priorCatalog: priorCatalog.kind === "file" ? Buffer.from(priorCatalog.body, "utf8").toString("base64") : "",
       catalogSyncedAt: now,
+      ...(linkMode ? { transport: "link" as const, link: linkMetadata } : {}),
     };
     withClientLifecycleSync(() => withConfigMutationLockSync(() => {
       assertConnectingState(persisted.fingerprint);
@@ -645,7 +735,7 @@ export async function connectClient(
     ];
     throw new Error(details.length > 0 ? `${base}. ${details.join(" ")}` : base, { cause: error });
   } finally {
-    releaseCredential(options.credential);
+    releaseConnectCredential(options.credential);
     cleanupCredential = null;
     issued = null;
     if (!committed) {
@@ -706,7 +796,7 @@ export async function syncConnectedClient(
   if (next.selectedClients.includes("codex")) {
     const config = loadConfig();
     const result = await injectCodexConfig(config.port, { ...config, syncResumeHistory: false }, {
-      routingTarget: routingTarget(next.serverUrl), catalogPath: DEFAULT_CATALOG_PATH,
+      routingTarget: routingTarget(next.serverUrl, isLinkConnection(next) ? config.port : undefined), catalogPath: DEFAULT_CATALOG_PATH,
       journalOwner: { kind: "client", apiKeyId: next.apiKeyId }, beforeClientWrite,
     });
     if (!result.success || result.status === "skipped") throw new Error(result.message);
@@ -902,6 +992,17 @@ export async function disconnectClient(
     if (!disconnectAtLeast(receipt, "clearing_connection")) advance("clearing_connection");
     if (clearClientConnection(receipt.owner) === "conflict") throw new Error("client_disconnect_owner_changed");
     if (!disconnectAtLeast(receipt, "connection_cleared")) advance("connection_cleared");
+    if (connection?.transport === "link" && connection.link) {
+      // A corrupt sidecar is left in place: the connection is already cleared, the client runtime
+      // will not start a tunnel for a disconnected client, and the next join overwrites the file.
+      let sidecarLinkId: string | null = null;
+      try {
+        sidecarLinkId = readClientLinkState()?.linkId ?? null;
+      } catch (error) {
+        if (!(error instanceof ClientLinkStateError)) throw error;
+      }
+      if (sidecarLinkId === connection.link.linkId) clearClientLinkState(connection.link.linkId);
+    }
     removeHubStateCache();
     requireDesktopResult(finishRemoteDesktopCleanup(held, receipt.owner));
     if (receipt.phase !== "complete") advance("complete");
@@ -940,6 +1041,7 @@ export async function revokeConnectedClientKey(
       assertNoClientDisconnectPending();
       const state = readClientConnectionState();
       if (state.kind !== "connected" || state.value.pendingOperation) throw new Error("connect revoke requires a settled connection");
+      if (isLinkConnection(state.value)) throw new Error("connect revoke is unavailable in link mode");
       await revokeClientKey(state.value.managementUrl, credential, state.value.apiKeyId, { fetchImpl: deps.fetchImpl });
       assertClientConnectionUnchanged(state.value);
       return { apiKeyId: state.value.apiKeyId };

package/src/client/hub-relay.ts

@@ -108,7 +108,7 @@ function relayDestination(suffix: string, target: HubRelayTarget, method: string
   return destination;
 }
 
-async function boundedBody(
+export async function readBoundedRelayRequestBody(
   stream: ReadableStream<Uint8Array> | null,
   declared: string | null,
   limit: number,
@@ -142,16 +142,20 @@ async function boundedBody(
   return body;
 }
 
-function filteredHeaders(source: Headers, allowlist: Set<string>, omitted: ReadonlySet<string> = new Set()): Headers {
+export function filterRelayHeaders(
+  source: Headers,
+  allowlist?: ReadonlySet<string>,
+  omitted: ReadonlySet<string> = new Set(),
+): Headers {
   const headers = new Headers();
   for (const [name, value] of source) {
     const normalized = name.toLowerCase();
-    if (allowlist.has(normalized) && !HOP_BY_HOP_HEADERS.has(normalized) && !omitted.has(normalized)) headers.append(name, value);
+    if ((!allowlist || allowlist.has(normalized)) && !HOP_BY_HOP_HEADERS.has(normalized) && !omitted.has(normalized)) headers.append(name, value);
   }
   return headers;
 }
 
-function headersWithinLimit(headers: Headers): boolean {
+export function headersWithinLimit(headers: Headers): boolean {
   let bytes = 0;
   for (const [name, value] of headers) {
     bytes += name.length + value.length + 4;
@@ -160,7 +164,7 @@ function headersWithinLimit(headers: Headers): boolean {
   return true;
 }
 
-function boundedRelayResponseStream(
+export function boundedRelayResponseStream(
   body: ReadableStream<Uint8Array>,
   limit: number,
   signal: AbortSignal,
@@ -228,13 +232,13 @@ export async function relayHubManagementRequest(
   try {
     body = method === "GET" || method === "HEAD"
       ? null
-      : await boundedBody(req.body, req.headers.get("content-length"), HUB_RELAY_REQUEST_BODY_MAX_BYTES);
+      : await readBoundedRelayRequestBody(req.body, req.headers.get("content-length"), HUB_RELAY_REQUEST_BODY_MAX_BYTES);
   } catch {
     return relayError(413, "hub relay request body too large");
   }
 
   const stripped = stripMachineAuthHeaders(req.headers);
-  const headers = filteredHeaders(stripped, REQUEST_HEADERS, requestHeaderValidation.connectionNamed);
+  const headers = filterRelayHeaders(stripped, REQUEST_HEADERS, requestHeaderValidation.connectionNamed);
   if (!headersWithinLimit(headers)) return relayError(431, "hub relay request headers too large");
   const browserOrigin = canonicalOrigin(target.browserOrigin);
   const mutation = method !== "GET" && method !== "HEAD";
@@ -285,7 +289,7 @@ export async function relayHubManagementRequest(
   }
 
   const responseConnectionNamed = new Set((upstream.headers.get("connection") ?? "").split(",").map(value => value.trim().toLowerCase()).filter(Boolean));
-  const responseHeaders = filteredHeaders(upstream.headers, RESPONSE_HEADERS, responseConnectionNamed);
+  const responseHeaders = filterRelayHeaders(upstream.headers, RESPONSE_HEADERS, responseConnectionNamed);
   if (!headersWithinLimit(responseHeaders)) {
     cleanup();
     try { await upstream.body?.cancel(); } catch { /* best effort */ }