@bitkyc08/opencodex 2.27.0 → 2.28.0

package/src/server/responses-tool-search-repair.ts

@@ -0,0 +1,217 @@
+import {
+  isTranslatorBudgetExceededError,
+  type TranslatorBudget,
+} from "../lib/translator-budget";
+import {
+  restoreRoutedToolSearchCalls,
+} from "../responses/tool-search-compat";
+import {
+  replaceSseDataPayload,
+  sseDataPayload,
+  type SseBlockRewrite,
+} from "./sse-payload-rewrite";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+type PendingArgumentBlock = {
+  block: string;
+  itemId?: string;
+  outputIndex?: number;
+  retainedBytes: number;
+};
+
+const MAX_PENDING_ARGUMENT_FRAMES = 256;
+const MAX_PENDING_ARGUMENT_BYTES = 1024 * 1024;
+
+/**
+ * Public Responses gateways stream a lowered search as a normal function lifecycle. Codex expects
+ * only `tool_search_call` items, so classify each item before dropping its function-argument
+ * frames. Unknown early argument frames stay bounded until their item arrives.
+ */
+export function createRoutedToolSearchRestoreBlockRewrite(
+  names: ReadonlySet<string>,
+  budget?: TranslatorBudget,
+): SseBlockRewrite {
+  const routedItemIds = new Set<string>();
+  const ordinaryItemIds = new Set<string>();
+  let pendingArguments: PendingArgumentBlock[] = [];
+  let pendingArgumentBytes = 0;
+  let passthrough = false;
+  let disposed = false;
+
+  const releaseAll = (): void => {
+    if (disposed) return;
+    disposed = true;
+    if (pendingArgumentBytes > 0) {
+      budget?.releaseRetained(pendingArgumentBytes, { kind: "retained_collectors" });
+    }
+    pendingArguments = [];
+    pendingArgumentBytes = 0;
+    routedItemIds.clear();
+    ordinaryItemIds.clear();
+  };
+
+  const retainPending = (
+    block: string,
+    itemId: string | undefined,
+    outputIndex: number | undefined,
+  ): readonly string[] | null => {
+    const retainedBytes = Buffer.byteLength(block, "utf8");
+    const overflow = pendingArguments.length >= MAX_PENDING_ARGUMENT_FRAMES
+      || pendingArgumentBytes + retainedBytes > MAX_PENDING_ARGUMENT_BYTES;
+    if (overflow) {
+      const flushed = [...pendingArguments.map(pending => pending.block), block];
+      if (pendingArgumentBytes > 0) {
+        budget?.releaseRetained(pendingArgumentBytes, { kind: "retained_collectors" });
+      }
+      pendingArguments = [];
+      pendingArgumentBytes = 0;
+      passthrough = true;
+      // Deliberately KEEP routedItemIds. Overflow means we stop buffering UNKNOWN frames, not
+      // that we forget what we already classified: an item restored to `tool_search_call`
+      // upstream of here would otherwise start emitting `function_call_arguments.*` again and
+      // the client would see a mixed private/public lifecycle for one call.
+      ordinaryItemIds.clear();
+      return flushed;
+    }
+    if (retainedBytes > 0) {
+      try {
+        budget?.chargeRetained(retainedBytes, { kind: "retained_collectors" });
+      } catch (error) {
+        if (!isTranslatorBudgetExceededError(error)) throw error;
+        const flushed = [...pendingArguments.map(pending => pending.block), block];
+        if (pendingArgumentBytes > 0) {
+          budget?.releaseRetained(pendingArgumentBytes, { kind: "retained_collectors" });
+        }
+        pendingArguments = [];
+        pendingArgumentBytes = 0;
+        passthrough = true;
+        // Same reasoning as the frame/byte overflow above: an already-restored routed item
+        // must keep its frames suppressed even once buffering stops.
+        ordinaryItemIds.clear();
+        return flushed;
+      }
+    }
+    pendingArguments.push({ block, itemId, outputIndex, retainedBytes });
+    pendingArgumentBytes += retainedBytes;
+    return null;
+  };
+
+  const takePending = (
+    itemId: string | undefined,
+    outputIndex: number | undefined,
+  ): string[] => {
+    const matched: PendingArgumentBlock[] = [];
+    const remaining: PendingArgumentBlock[] = [];
+    for (const pending of pendingArguments) {
+      const matches = pending.itemId !== undefined
+        ? itemId !== undefined && pending.itemId === itemId
+        : outputIndex !== undefined && pending.outputIndex === outputIndex;
+      (matches ? matched : remaining).push(pending);
+    }
+    pendingArguments = remaining;
+    const retainedBytes = matched.reduce((total, pending) => total + pending.retainedBytes, 0);
+    if (retainedBytes > 0) {
+      budget?.releaseRetained(retainedBytes, { kind: "retained_collectors" });
+      pendingArgumentBytes = Math.max(0, pendingArgumentBytes - retainedBytes);
+    }
+    return matched.map(pending => {
+      if (pending.itemId !== undefined || itemId === undefined) return pending.block;
+      const payload = sseDataPayload(pending.block);
+      if (payload === null) return pending.block;
+      try {
+        const parsed: unknown = JSON.parse(payload);
+        return isPlainObject(parsed)
+          ? replaceSseDataPayload(pending.block, JSON.stringify({ ...parsed, item_id: itemId }))
+          : pending.block;
+      } catch {
+        return pending.block;
+      }
+    });
+  };
+
+  const rewrite: SseBlockRewrite = (block: string): readonly string[] => {
+    if (disposed) return [block];
+    const payload = sseDataPayload(block);
+    if (payload === null || payload === "[DONE]") return [block];
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      return [block];
+    }
+    if (!isPlainObject(parsed)) return [block];
+
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    // After overflow we stop BUFFERING unknown frames, but an item already restored to
+    // `tool_search_call` must keep its public argument frames suppressed — otherwise the client
+    // receives a private item followed by `function_call_arguments.*` for the same id, which is
+    // exactly the mixed lifecycle this rewrite exists to prevent. Everything else passes through.
+    if (passthrough) {
+      const passthroughItemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+      const isArgumentEvent = type === "response.function_call_arguments.delta"
+        || type === "response.function_call_arguments.done";
+      if (isArgumentEvent && passthroughItemId && routedItemIds.has(passthroughItemId)) return [];
+      return [block];
+    }
+    const outputIndex = typeof parsed.output_index === "number"
+      && Number.isInteger(parsed.output_index)
+      && parsed.output_index >= 0
+      ? parsed.output_index
+      : undefined;
+    if (
+      (type === "response.output_item.added" || type === "response.output_item.done")
+      && isPlainObject(parsed.item)
+      && parsed.item.type === "function_call"
+      && typeof parsed.item.name === "string"
+    ) {
+      const itemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
+      const routed = names.has(parsed.item.name);
+      if (itemId) {
+        if (routed) {
+          routedItemIds.add(itemId);
+          ordinaryItemIds.delete(itemId);
+        } else {
+          ordinaryItemIds.add(itemId);
+          routedItemIds.delete(itemId);
+        }
+      }
+      const pending = takePending(itemId, outputIndex);
+      const restored = routed ? restoreRoutedToolSearchCalls(parsed, names) : { value: parsed, changed: false };
+      const restoredBlock = restored.changed
+        ? replaceSseDataPayload(block, JSON.stringify(restored.value))
+        : block;
+      // Classification is retained past `output_item.done` for BOTH kinds, until the terminal
+      // event releases everything.
+      //
+      // `done` ends the item, not the id's relevance. Forgetting a ROUTED id let a trailing
+      // `function_call_arguments.*` — which some upstreams emit after done — fall through to
+      // the unknown-id branch and reach the client as a public frame for an item the client
+      // was told is a private `tool_search_call`: the mixed lifecycle this rewrite exists to
+      // prevent. Forgetting an ORDINARY id is not leak-shaped but is not free either, because
+      // the same fall-through buffers its trailing frames as unknown and delays them until an
+      // item that will never arrive. Neither id is dropped early.
+      return routed ? [restoredBlock] : [...pending, restoredBlock];
+    }
+
+    const itemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+    const argumentEvent = type === "response.function_call_arguments.delta"
+      || type === "response.function_call_arguments.done";
+    if (argumentEvent && (!itemId || (!routedItemIds.has(itemId) && !ordinaryItemIds.has(itemId)))) {
+      return retainPending(block, itemId, outputIndex) ?? [];
+    }
+    if (argumentEvent && itemId && routedItemIds.has(itemId)) return [];
+
+    const terminal = type === "response.completed" || type === "response.failed" || type === "response.incomplete";
+    if (!terminal) return [block];
+    const restored = restoreRoutedToolSearchCalls(parsed, names);
+    releaseAll();
+    return restored.changed
+      ? [replaceSseDataPayload(block, JSON.stringify(restored.value))]
+      : [block];
+  };
+  rewrite.dispose = releaseAll;
+  return rewrite;
+}

package/src/server/system-env.ts

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
-import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { accessSync, constants, readFileSync, writeFileSync, unlinkSync, mkdirSync, statSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { getConfigDir } from "../config";
 import { resolveAutoContext, type AutoContextMode } from "../claude/context-windows";
 import { PROXY_MARKER, defaultAuthDetectDeps, detectClaudeAuth, ownAdmissionTokens } from "../claude/auth-detect";
@@ -118,15 +118,84 @@ export function uninstallShellHook(): { removed: boolean; reason?: string } {
   try {
     const content = readFileSync(zshrcPath, "utf8");
     if (!content.includes(SHELL_HOOK_MARKER)) return { removed: false, reason: "not installed" };
-    // Remove the hook block (marker line + source line + surrounding newlines)
-    const cleaned = content.replace(/\n?# opencodex claude-env hook\n\[.*claude-env\.sh.*\n?/g, "\n");
+    // Match CR?LF, not LF alone. A .zshrc with CRLF line endings — ordinary on a home
+    // directory an editor or another OS has touched — did not match, so the file was
+    // rewritten unchanged and the caller was told the hook was removed. Reporting success
+    // while the hook still sources on every new shell is the worse of the two failures.
+    const cleaned = content.replace(/\r?\n?# opencodex claude-env hook\r?\n\[.*claude-env\.sh.*(?:\r?\n)?/g, "\n");
+    // Verify instead of assuming: if the marker survives, the block is shaped in a way this
+    // pattern does not own, and the honest answer is failure rather than a silent no-op.
+    if (cleaned.includes(SHELL_HOOK_MARKER)) {
+      return { removed: false, reason: "hook block present but not in the expected shape; remove it manually" };
+    }
     writeFileSync(zshrcPath, cleaned, { encoding: "utf8", mode: 0o644 });
     return { removed: true };
-  } catch {
+  } catch (error) {
+    if (error && typeof error === "object" && (error as { code?: unknown }).code === "ENOENT") {
+      return { removed: false, reason: "not installed" };
+    }
     return { removed: false, reason: "read/write failed" };
   }
 }
 
+/** Whether a real `claude` executable is discoverable from this process's PATH. */
+export function claudeCodeCliInstalled(pathValue = process.env.PATH): boolean {
+  if (!pathValue) return false;
+  for (const directory of pathValue.split(delimiter)) {
+    // An empty PATH segment means the current directory. Do not let the proxy treat a
+    // workspace-local file as a durable user installation.
+    if (!directory) continue;
+    const candidate = join(directory, "claude");
+    try {
+      if (!statSync(candidate).isFile()) continue;
+      accessSync(candidate, constants.X_OK);
+      return true;
+    } catch {
+      // Keep scanning PATH after missing, non-file, and non-executable entries.
+    }
+  }
+  return false;
+}
+
+/**
+ * Keep the shell hook aligned with the integration that can actually consume it.
+ * Claude Desktop uses its own profile and does not source `.zshrc`; this hook exists
+ * only for plain Claude Code CLI launches.
+ *
+ * Reconciliation is PATH-sensitive by construction: "Claude Code is installed" is answered
+ * from the PATH of whichever process calls this. A launchd/service context with a stripped
+ * PATH can therefore fail to see a `claude` the user's interactive shell finds, and this will
+ * remove the hook. That is the intended failure direction — removing an OpenCodex-owned block
+ * is reversible on the next foreground `ocx start`, whereas leaving a hook pointing at an
+ * uninstalled CLI is the stale state this reconciliation exists to clear. Only the block
+ * carrying our own marker is ever touched; user lines are preserved.
+ */
+export function reconcileShellHook(systemEnvInjected: boolean): {
+  changed: boolean;
+  state: "installed" | "absent" | "failed";
+  reason?: string;
+} {
+  if (process.platform !== "darwin") return { changed: false, state: "absent", reason: "not macOS" };
+  if (systemEnvInjected && claudeCodeCliInstalled()) {
+    const result = installShellHook();
+    if (result.installed) return { changed: true, state: "installed" };
+    if (result.reason === "already installed") {
+      return { changed: false, state: "installed", reason: result.reason };
+    }
+    return { changed: false, state: "failed", reason: result.reason ?? "install failed" };
+  }
+
+  const result = uninstallShellHook();
+  if (!result.removed && result.reason !== "not installed") {
+    return { changed: false, state: "failed", reason: result.reason ?? "remove failed" };
+  }
+  return {
+    changed: result.removed,
+    state: "absent",
+    reason: systemEnvInjected ? "Claude Code not installed" : "system environment inactive",
+  };
+}
+
 const SYSTEM_ENV_NAMES = [
   "ANTHROPIC_BASE_URL",
   "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY",

package/src/usage/log.ts

@@ -84,6 +84,8 @@ export interface PersistedUsageEntry {
   conversationId?: string;
   resolvedModel?: string;
   requestedModel?: string;
+  /** Original bare helper model when the opt-in shadow-call route rewrote this request. */
+  shadowCallRewrittenFrom?: string;
   /** Reasoning effort / service-tier metadata for GUI Logs after restart. */
   requestedEffort?: string;
   /** Adapter-normalized tier and exact upstream parameter emitted for this request. */
@@ -427,6 +429,7 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
   const tierOutcome = entry.tierOutcome ? normalizeAttemptTierOutcome(entry.tierOutcome) : undefined;
   const callerServiceTier = sanitizeLogMetadataString(entry.callerServiceTier);
   const responseServiceTier = sanitizeLogMetadataString(entry.responseServiceTier);
+  const shadowCallRewrittenFrom = sanitizeLogMetadataString(entry.shadowCallRewrittenFrom);
   const routeDecision = entry.routeDecision
     ? normalizeRouteDecisionTrace(entry.routeDecision)
     : undefined;
@@ -453,6 +456,7 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
       : {}),
     ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
     ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
+    ...(shadowCallRewrittenFrom ? { shadowCallRewrittenFrom } : {}),
     ...(typeof entry.requestedEffort === "string" && entry.requestedEffort
       ? { requestedEffort: capMetadataString(entry.requestedEffort) }
       : {}),