@bitkyc08/opencodex 2.7.40-preview.20260725 → 2.7.41-preview.20260726

package/src/update/job.ts

@@ -4,7 +4,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { atomicWriteFile, getConfigDir, loadConfig, readPid, readRuntimePort } from "../config";
 import { killProxy } from "../lib/process-control";
-import { waitForPortAvailable } from "../server/ports";
+import { reclaimListenPort } from "../server/port-reclaim";
 import { proxyIdentityAt } from "../server/proxy-liveness";
 import { isServiceInstalled } from "../service";
 import {
@@ -28,6 +28,8 @@ const UPDATE_TIMEOUT_MS = 180_000;
 const RESTART_TIMEOUT_MS = 60_000;
 const RESTART_HEALTH_TIMEOUT_MS = 15_000;
 const RESTART_STABILITY_WINDOW_MS = 15_000;
+/** How long update restart waits for the captured port to become bindable after stop. */
+export const RESTART_PORT_RECLAIM_MS = 30_000;
 
 export type UpdateJobStatus = "running" | "restarting" | "succeeded" | "failed";
 
@@ -292,7 +294,7 @@ function spawnDetachedStart(job: UpdateJobState, installer: Installer, port?: nu
 
 /** Test seam: the wait/spawn pair is injectable so the restart path is verifiable. */
 export interface RestartIo {
-  waitForPort?: typeof waitForPortAvailable;
+  waitForPort?: typeof reclaimListenPort;
   spawnStart?: (job: UpdateJobState, installer: Installer, port?: number) => void;
   serviceInstalledFn?: () => boolean;
   probeProxy?: (port: number, hostname?: string) => Promise<boolean>;
@@ -308,7 +310,7 @@ export interface RestartIo {
 
 async function restartAfterUpdate(
   job: UpdateJobState,
-  captured?: { port: number; hostname: string },
+  captured?: { port: number; hostname: string; oldPid?: number },
   io: RestartIo = {},
 ): Promise<void> {
   const serviceInstalled = (io.serviceInstalledFn ?? isServiceInstalled)();
@@ -318,6 +320,9 @@ async function restartAfterUpdate(
   // port to wait on; config is only the cold-start fallback.
   const port = captured?.port ?? config.port ?? 10100;
   const hostname = captured?.hostname ?? config.hostname ?? "127.0.0.1";
+  const oldPid = typeof captured?.oldPid === "number" && captured.oldPid > 0
+    ? captured.oldPid
+    : undefined;
   let svcArgs: string[] | undefined;
   if (serviceInstalled) {
     try {
@@ -326,14 +331,21 @@ async function restartAfterUpdate(
     } catch { /* fallback to default service install */ }
   }
   const cmd = restartCommand(serviceInstalled, job.installer, packageLauncherPath(), port, svcArgs);
-  const waitFn = io.waitForPort ?? waitForPortAvailable;
+  const waitFn = io.waitForPort ?? reclaimListenPort;
+  const reclaimOpts = {
+    timeoutMs: RESTART_PORT_RECLAIM_MS,
+    intervalMs: 100,
+    scanIntervalMs: 500,
+    killOcxHolders: oldPid != null,
+    onlyKillPids: oldPid != null ? [oldPid] : [],
+  };
 
   if (serviceInstalled) {
-    // Stop-first update already unloaded the service; wait for the socket to drain,
-    // then reinstall wrappers that bake `--port` via OCX_BAKE_PORT (PR #152 gap).
-    const freed = await waitFn(port, hostname, { timeoutMs: 5_000, intervalMs: 25 });
+    // Stop-first update already unloaded the service; reclaim the socket (only the
+    // captured old PID when trusted), then reinstall wrappers that bake `--port`.
+    const freed = await waitFn(port, hostname, reclaimOpts);
     if (!freed) {
-      updateJob(job, {}, `Port ${port} still busy after stop; reinstalling service with pinned --port ${port} anyway.`);
+      updateJob(job, {}, `Port ${port} still busy after ${Math.trunc(RESTART_PORT_RECLAIM_MS / 1000)}s; refusing to hop — reinstall may fail until the port is free.`);
     }
     const prevBake = process.env.OCX_BAKE_PORT;
     process.env.OCX_BAKE_PORT = String(Math.trunc(port));
@@ -365,12 +377,13 @@ async function restartAfterUpdate(
     updateJob(job, {}, `Stopping current proxy PID ${pid}.`);
     killProxy(pid);
   }
-  // The old socket can stay busy briefly after stop (Windows taskkill drain, or the
-  // stop-first update path that already killed the proxy before we got here) — wait
-  // unconditionally on the captured port so the pinned start does not race the drain.
-  const freed = await waitFn(port, hostname, { timeoutMs: 2_000, intervalMs: 25 });
+  // Reclaim the captured port before the pinned start. Spawning `--port` while the old
+  // socket is still busy is how Windows updates used to fail health checks (or hop).
+  // Only the trusted pre-update PID may be killed; never an arbitrary ocx listener.
+  const freed = await waitFn(port, hostname, reclaimOpts);
   if (!freed) {
-    updateJob(job, {}, `Port ${port} still busy after stop; starting with --port ${port} anyway.`);
+    updateJob(job, {}, `Port ${port} still busy after ${Math.trunc(RESTART_PORT_RECLAIM_MS / 1000)}s (reclaim could not free the socket); not starting on another port. Retry 'ocx start --port ${port}'.`);
+    return;
   }
   (io.spawnStart ?? spawnDetachedStart)(job, job.installer, port);
 }
@@ -378,7 +391,7 @@ async function restartAfterUpdate(
 /** Exposed for tests: drives the non-service restart path with injected io. */
 export function restartAfterUpdateForTests(
   job: UpdateJobState,
-  captured: { port: number; hostname: string },
+  captured: { port: number; hostname: string; oldPid?: number },
   io: RestartIo,
 ): Promise<void> {
   return restartAfterUpdate(job, captured, io);
@@ -386,7 +399,8 @@ export function restartAfterUpdateForTests(
 
 function restartFailureHint(port: number): string {
   return `Update installed, but the restarted proxy did not stay healthy on port ${port}. `
-    + "Try 'ocx start'. If the update log shows bun postinstall or EPERM warnings, "
+    + `Try 'ocx start --port ${port}'. `
+    + "If the update log shows bun postinstall or EPERM warnings, "
     + "reinstall with 'npm install -g --allow-scripts=bun @bitkyc08/opencodex'.";
 }
 
@@ -474,6 +488,7 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
   const captured = {
     port: runtimeTrusted ? rt.port : configPort,
     hostname: (runtimeTrusted ? rt.hostname : undefined) ?? preUpdateConfig.hostname ?? "127.0.0.1",
+    ...(runtimeTrusted && livePid ? { oldPid: livePid } : {}),
   };
   let trayWasInstalled = false;
   let trayWasRunning = false;

package/src/usage/log.ts

@@ -36,7 +36,7 @@ export interface PersistedUsageEntry {
   timestamp: number;
   provider: string;
   model: string;
-  surface?: "claude";
+  surface?: "claude" | "claude-desktop" | "grok";
   resolvedModel?: string;
   requestedModel?: string;
   /** Reasoning effort / service-tier metadata for GUI Logs after restart. */
@@ -64,6 +64,23 @@ export interface PersistedUsageEntry {
   upstreamError?: string;
 }
 
+const KNOWN_USAGE_SURFACES = new Set<NonNullable<PersistedUsageEntry["surface"]>>([
+  "claude",
+  "claude-desktop",
+  "grok",
+]);
+
+/**
+ * The serializer guard for `surface`. Two failure modes shaped this: a literal
+ * whitelist ("claude" | "claude-desktop" only) silently dropped every NEW surface at
+ * write time, while a plain truthy spread would persist junk values from hand-edited
+ * logs. Membership in this set is the middle path: adding a surface here is one edit,
+ * and unknown values are still dropped.
+ */
+export function isKnownUsageSurface(value: unknown): value is NonNullable<PersistedUsageEntry["surface"]> {
+  return typeof value === "string" && KNOWN_USAGE_SURFACES.has(value as NonNullable<PersistedUsageEntry["surface"]>);
+}
+
 export function usageLogPath(): string {
   return join(getConfigDir(), "usage.jsonl");
 }
@@ -217,7 +234,7 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
     timestamp: entry.timestamp,
     provider: entry.provider,
     model: entry.model,
-    ...(entry.surface === "claude" ? { surface: entry.surface } : {}),
+    ...(isKnownUsageSurface(entry.surface) ? { surface: entry.surface } : {}),
     ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
     ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
     ...(typeof entry.requestedEffort === "string" && entry.requestedEffort
@@ -270,6 +287,145 @@ export function appendUsageEntry(entry: PersistedUsageEntry): void {
   try { chmodSync(path, 0o600); } catch { /* best-effort on platforms that ignore chmod */ }
 }
 
+export type UsageLogRevision = {
+  path: string;
+  dev: number;
+  ino: number;
+  birthtimeMs: number;
+  size: number;
+  mtimeMs: number;
+  ctimeMs: number;
+};
+
+let usageReadCacheStats = { fullReads: 0, tailReads: 0, parsedLines: 0 };
+let managementUsageReadInflight: {
+  key: string;
+  promise: Promise<{ entries: PersistedUsageEntry[]; revision: UsageLogRevision }>;
+} | null = null;
+
+/** Test-only observability for proving that unchanged prefixes are not reparsed. */
+export function usageReadCacheStatsForTests(): Readonly<typeof usageReadCacheStats> {
+  return { ...usageReadCacheStats };
+}
+
+export function resetUsageReadCacheForTests(): void {
+  usageReadCacheStats = { fullReads: 0, tailReads: 0, parsedLines: 0 };
+  managementUsageReadInflight = null;
+}
+
+function readExactly(fd: number, length: number, position: number): Buffer | null {
+  const output = Buffer.allocUnsafe(length);
+  let offset = 0;
+  while (offset < length) {
+    const read = readSync(fd, output, offset, length - offset, position + offset);
+    if (read === 0) return null;
+    offset += read;
+  }
+  return output;
+}
+
+function usageLogRevision(path: string, stat: ReturnType<typeof fstatSync>): UsageLogRevision {
+  if (!stat.isFile()) throw new Error("usage log is not a regular file");
+  return {
+    path,
+    dev: Number(stat.dev),
+    ino: Number(stat.ino),
+    birthtimeMs: Number(stat.birthtimeMs),
+    size: Number(stat.size),
+    mtimeMs: Number(stat.mtimeMs),
+    ctimeMs: Number(stat.ctimeMs),
+  };
+}
+
+export function usageLogRevisionKey(revision: UsageLogRevision | null): string {
+  if (!revision) return "missing";
+  return [
+    revision.path,
+    revision.dev,
+    revision.ino,
+    revision.birthtimeMs,
+    revision.size,
+    revision.mtimeMs,
+    revision.ctimeMs,
+  ].join("\0");
+}
+
+export function currentUsageLogRevision(): UsageLogRevision | null {
+  const path = usageLogPath();
+  if (!existsSync(path)) return null;
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    return usageLogRevision(path, fstatSync(fd));
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+async function parseUsageTextCooperatively(text: string): Promise<PersistedUsageEntry[]> {
+  const lines = text.split(/\r?\n/);
+  usageReadCacheStats.parsedLines += lines.filter(line => line.trim()).length;
+  const entries: PersistedUsageEntry[] = [];
+  const batchSize = 1_000;
+  for (let offset = 0; offset < lines.length; offset += batchSize) {
+    entries.push(...parseUsageLines(lines.slice(offset, offset + batchSize)));
+    if (offset + batchSize < lines.length) {
+      // JSON parsing dominates large-log startup. Yield between bounded batches so
+      // Bun can continue serving health and settings requests on the same thread.
+      await new Promise<void>(resolve => setTimeout(resolve, 0));
+    }
+  }
+  return entries;
+}
+
+async function readUsageEntriesFullCooperatively(
+  path: string,
+): Promise<{ entries: PersistedUsageEntry[]; revision: UsageLogRevision }> {
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    const stat = fstatSync(fd);
+    const size = Number(stat.size);
+    const bytes = readExactly(fd, size, 0);
+    if (bytes === null) throw new Error("usage log changed while it was being read");
+    const entries = await parseUsageTextCooperatively(bytes.toString("utf-8"));
+    usageReadCacheStats.fullReads += 1;
+    return { entries, revision: usageLogRevision(path, stat) };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+/**
+ * Management API reader: full parses yield between bounded batches and concurrent
+ * callers share work only when they observed the same exact file revision. Parsed rows
+ * are returned to the request and never retained in module state.
+ */
+export async function readUsageSnapshotForManagement(): Promise<{
+  entries: PersistedUsageEntry[];
+  revision: UsageLogRevision | null;
+}> {
+  const path = usageLogPath();
+  if (!existsSync(path)) return { entries: [], revision: null };
+  const observed = currentUsageLogRevision();
+  const key = usageLogRevisionKey(observed);
+  if (managementUsageReadInflight?.key === key) {
+    const shared = await managementUsageReadInflight.promise;
+    return { entries: shared.entries.slice(), revision: shared.revision };
+  }
+  const promise = readUsageEntriesFullCooperatively(path);
+  managementUsageReadInflight = { key, promise };
+  try {
+    return await promise;
+  } finally {
+    if (managementUsageReadInflight?.promise === promise) managementUsageReadInflight = null;
+  }
+}
+
+export async function readUsageEntriesForManagement(): Promise<PersistedUsageEntry[]> {
+  return (await readUsageSnapshotForManagement()).entries;
+}
+
 export function readUsageEntries(): PersistedUsageEntry[] {
   const path = usageLogPath();
   if (!existsSync(path)) return [];

package/src/usage/summary.ts

@@ -5,7 +5,7 @@ import type { PersistedUsageEntry, UsageStatus } from "./log";
 import { estimateComboCost, estimateRequestCost, effectiveServiceTier } from "./cost";
 
 export type UsageRange = "7d" | "30d" | "all";
-export type UsageSurface = "all" | "codex" | "claude";
+export type UsageSurface = "all" | "codex" | "claude" | "grok";
 
 export interface UsageSummaryTotals {
   requests: number;
@@ -98,7 +98,7 @@ export function parseRange(input: string | null | undefined): UsageRange {
 }
 
 export function parseUsageSurface(input: string | null | undefined): UsageSurface {
-  if (input === "codex" || input === "claude") return input;
+  if (input === "codex" || input === "claude" || input === "grok") return input;
   return "all";
 }
 
@@ -491,8 +491,12 @@ export function summarizeUsage(
   const { since } = rangeWindow(range, now);
   const filteredEntries = entries.filter(entry => {
     if (since !== null && entry.timestamp < since) return false;
-    if (surface === "claude") return entry.surface === "claude";
-    if (surface === "codex") return entry.surface !== "claude";
+    if (surface === "claude") return entry.surface === "claude" || entry.surface === "claude-desktop";
+    if (surface === "grok") return entry.surface === "grok";
+    // Codex = the historical unlabelled bucket. Before the grok tag existed every
+    // non-Claude turn landed here, and `surface !== "claude"` also swallowed
+    // claude-desktop — disjoint predicates fix both.
+    if (surface === "codex") return entry.surface === undefined;
     return true;
   });
   const totals = blankTotals();

package/src/web-search/loop.ts

@@ -1,5 +1,5 @@
 import type { ProviderAdapter } from "../adapters/base";
-import type { AdapterEvent, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxThinkingContent } from "../types";
+import type { AdapterEvent, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxThinkingContent, OcxUsage } from "../types";
 import { namespacedToolName } from "../types";
 import { bridgeToResponsesSSE } from "../bridge";
 import { runWebSearch, type SidecarOutcome, type SidecarOutcomeRecorder, type SidecarSettings } from "./executor";
@@ -189,6 +189,8 @@ export interface WebSearchLoopDeps {
   stallTimeoutSec?: number;
   /** One-shot TTFT callback: first non-empty model output observed (WP4). */
   onFirstOutput?: () => void;
+  /** Raw adapter usage at the terminal event, pre wire-normalization (see bridgeToResponsesSSE onUsage). */
+  onUsage?: (usage: OcxUsage | undefined) => void;
   /**
    * 429 key-failover hook: rotate the provider's active pool key and return a rebuilt adapter,
    * or null when the pool is exhausted (same semantics as the normal routed path).
@@ -575,6 +577,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       hideThinkingSummary: parsed.options.hideThinkingSummary,
       ...(deps.stallTimeoutSec !== undefined ? { stallTimeoutSec: deps.stallTimeoutSec } : {}),
       ...(deps.onFirstOutput ? { onFirstOutput: deps.onFirstOutput } : {}),
+      ...(deps.onUsage ? { onUsage: deps.onUsage } : {}),
     },
   );
   return new Response(sse, { headers: SSE_HEADERS });