@bitkyc08/opencodex 2.7.28 → 2.7.29

package/src/server/request-log.ts

@@ -11,11 +11,13 @@ import type { OcxUsage } from "../types";
 import { redactSecretString } from "../lib/redact";
 import {
   appendUsageEntry,
+  readRecentUsageEntries,
   usageForFinalLog,
   usageStatusForFinalLog,
   usageTotalTokens,
   type AttemptRecoveryKind,
   type PersistedUsageAttempt,
+  type PersistedUsageEntry,
   type UsageStatus,
 } from "../usage/log";
 import {
@@ -95,6 +97,92 @@ export interface RequestLogEntry {
 const requestLog: RequestLogEntry[] = [];
 const MAX_LOG_SIZE = 200;
 let requestLogSeq = 0;
+/** True after hydrateRequestLogsFromDisk ran once in this process. */
+let requestLogsHydratedFromDisk = false;
+
+function asTerminalStatus(value: string | undefined): ResponsesTerminalStatus | undefined {
+  if (value === "completed" || value === "failed" || value === "incomplete") return value;
+  return undefined;
+}
+
+function asCloseReason(value: string | undefined): RequestLogEntry["closeReason"] | undefined {
+  switch (value) {
+    case "terminal":
+    case "client_cancel":
+    case "non_stream":
+    case "body_stall":
+    case "body_overflow":
+      return value;
+    default:
+      return undefined;
+  }
+}
+
+/** Project a persisted usage.jsonl row back into the in-memory /api/logs shape. */
+export function requestLogEntryFromPersistedUsage(entry: PersistedUsageEntry): RequestLogEntry {
+  const terminalStatus = asTerminalStatus(entry.terminalStatus);
+  const closeReason = asCloseReason(entry.closeReason);
+  return {
+    requestId: entry.requestId,
+    timestamp: entry.timestamp,
+    model: entry.model,
+    provider: entry.provider,
+    ...(entry.firstOutputMs !== undefined ? { firstOutputMs: entry.firstOutputMs } : {}),
+    ...(entry.surface === "claude" ? { surface: entry.surface } : {}),
+    ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
+    ...(entry.requestedEffort ? { requestedEffort: entry.requestedEffort } : {}),
+    ...(entry.requestedServiceTier ? { requestedServiceTier: entry.requestedServiceTier } : {}),
+    ...(entry.requestedSpeedLabel ? { requestedSpeedLabel: entry.requestedSpeedLabel } : {}),
+    ...(entry.configuredServiceTier ? { configuredServiceTier: entry.configuredServiceTier } : {}),
+    ...(entry.configuredSpeedLabel ? { configuredSpeedLabel: entry.configuredSpeedLabel } : {}),
+    ...(entry.modelSupportsServiceTier !== undefined
+      ? { modelSupportsServiceTier: entry.modelSupportsServiceTier }
+      : {}),
+    ...(entry.responseServiceTier ? { responseServiceTier: entry.responseServiceTier } : {}),
+    ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
+    status: entry.status,
+    durationMs: entry.durationMs,
+    ...(entry.errorCode ? { errorCode: entry.errorCode } : {}),
+    ...(terminalStatus ? { terminalStatus } : {}),
+    ...(closeReason ? { closeReason } : {}),
+    ...(entry.upstreamError ? { upstreamError: entry.upstreamError } : {}),
+    usageStatus: entry.usageStatus,
+    ...(entry.usage ? { usage: entry.usage } : {}),
+    ...(entry.totalTokens !== undefined ? { totalTokens: entry.totalTokens } : {}),
+    ...(entry.attempts?.length ? { attempts: entry.attempts } : {}),
+  };
+}
+
+/**
+ * Seed the in-memory Logs ring buffer from usage.jsonl so GUI /api/logs survives
+ * `ocx stop` / `ocx start` (process restart). Idempotent per process; no-ops when
+ * the buffer already has live entries. Read failures are non-fatal (same as /api/usage).
+ */
+export function hydrateRequestLogsFromDisk(
+  reader: () => PersistedUsageEntry[] = () => readRecentUsageEntries(MAX_LOG_SIZE),
+): number {
+  if (requestLogsHydratedFromDisk) return 0;
+  if (requestLog.length > 0) {
+    requestLogsHydratedFromDisk = true;
+    return 0;
+  }
+  try {
+    const persisted = reader();
+    requestLogsHydratedFromDisk = true;
+    if (persisted.length === 0) return 0;
+    const slice = persisted.length > MAX_LOG_SIZE
+      ? persisted.slice(persisted.length - MAX_LOG_SIZE)
+      : persisted;
+    for (const entry of slice) requestLog.push(requestLogEntryFromPersistedUsage(entry));
+    return slice.length;
+  } catch (err) {
+    requestLogsHydratedFromDisk = true;
+    console.warn(
+      `[request-log] failed to hydrate from usage.jsonl: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return 0;
+  }
+}
 
 export function addRequestLog(entry: RequestLogEntry) {
   requestLog.push(entry);
@@ -119,6 +207,15 @@ export function addRequestLog(entry: RequestLogEntry) {
       ...(entry.surface === "claude" ? { surface: entry.surface } : {}),
       ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
       ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
+      ...(entry.requestedEffort ? { requestedEffort: entry.requestedEffort } : {}),
+      ...(entry.requestedServiceTier ? { requestedServiceTier: entry.requestedServiceTier } : {}),
+      ...(entry.requestedSpeedLabel ? { requestedSpeedLabel: entry.requestedSpeedLabel } : {}),
+      ...(entry.configuredServiceTier ? { configuredServiceTier: entry.configuredServiceTier } : {}),
+      ...(entry.configuredSpeedLabel ? { configuredSpeedLabel: entry.configuredSpeedLabel } : {}),
+      ...(entry.modelSupportsServiceTier !== undefined
+        ? { modelSupportsServiceTier: entry.modelSupportsServiceTier }
+        : {}),
+      ...(entry.responseServiceTier ? { responseServiceTier: entry.responseServiceTier } : {}),
       status: entry.status,
       durationMs: entry.durationMs,
       ...(entry.firstOutputMs !== undefined ? { firstOutputMs: entry.firstOutputMs } : {}),
@@ -687,4 +784,5 @@ export function getRequestLogEntries(): RequestLogEntry[] { return requestLog; }
 export function clearRequestLogsForTests(): void {
   requestLog.length = 0;
   requestLogSeq = 0;
+  requestLogsHydratedFromDisk = false;
 }

package/src/service.ts

@@ -242,9 +242,29 @@ function shellQuote(value: string): string {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
-function buildServiceShellCommand(bun: string, cli: string): string {
+/**
+ * Listen port baked into service wrappers / WinSW XML.
+ * Priority: explicit override → OCX_BAKE_PORT (update restart) → config.port → 10100.
+ * `config.port === 0` means ephemeral for interactive start; services need a stable pin,
+ * so treat 0 / invalid like unset (default 10100) instead of baking `--port 0`.
+ */
+export function resolveServiceListenPort(override?: number): number {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0 && override <= 65535) {
+    return Math.trunc(override);
+  }
+  const baked = process.env.OCX_BAKE_PORT?.trim();
+  if (baked && /^\d+$/.test(baked)) {
+    const n = Number(baked);
+    if (n > 0 && n <= 65535) return n;
+  }
+  const configured = loadConfig().port;
+  if (typeof configured === "number" && configured > 0 && configured <= 65535) return configured;
+  return 10100;
+}
+
+function buildServiceShellCommand(bun: string, cli: string, port = resolveServiceListenPort()): string {
   const tokenFile = serviceApiTokenFilePath();
-  return `if [ -f ${shellQuote(tokenFile)} ]; then OPENCODEX_API_AUTH_TOKEN="$(cat ${shellQuote(tokenFile)})"; export OPENCODEX_API_AUTH_TOKEN; fi; exec ${shellQuote(bun)} ${shellQuote(cli)} start`;
+  return `if [ -f ${shellQuote(tokenFile)} ]; then OPENCODEX_API_AUTH_TOKEN="$(cat ${shellQuote(tokenFile)})"; export OPENCODEX_API_AUTH_TOKEN; fi; exec ${shellQuote(bun)} ${shellQuote(cli)} start --port ${port}`;
 }
 
 function systemdQuote(value: string): string {
@@ -316,7 +336,7 @@ function taskXmlString(value: string): string {
     .replace(/'/g, "&apos;");
 }
 
-export function buildWindowsServiceScript(entry = cliEntry()): string {
+export function buildWindowsServiceScript(entry = cliEntry(), port = resolveServiceListenPort()): string {
   const { bun, cli } = entry;
   const bunRuntime = durableBunRuntime();
   const path = process.env.PATH ?? "";
@@ -345,7 +365,7 @@ export function buildWindowsServiceScript(entry = cliEntry()): string {
     '>>"%OCX_SERVICE_LOG%" echo opencodex_home="%OPENCODEX_HOME%"',
     '>>"%OCX_SERVICE_LOG%" echo codex_home="%CODEX_HOME%"',
     '>>"%OCX_SERVICE_LOG%" echo token_file="%OCX_API_TOKEN_FILE%"',
-    '"%OCX_BUN%" "%OCX_CLI%" start >>"%OCX_SERVICE_LOG%" 2>&1',
+    `"%OCX_BUN%" "%OCX_CLI%" start --port ${port} >>"%OCX_SERVICE_LOG%" 2>&1`,
     "if %ERRORLEVEL% NEQ 0 (",
     '  >>"%OCX_SERVICE_LOG%" echo [%DATE% %TIME%] child exited with code %ERRORLEVEL%; restarting in 5s',
     // `timeout` needs console stdin and dies with "Input redirection is not supported"

package/src/update/index.ts

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { getConfigDir, readPid, readRuntimePort } from "../config";
+import { getConfigDir, loadConfig, readPid, readRuntimePort } from "../config";
 
 /**
  * A `codex-history-backup-*.json` surviving a stop means the native-history restore was
@@ -171,6 +171,20 @@ export async function runUpdate(): Promise<void> {
     serviceWasInstalled = isServiceInstalled();
   } catch { /* best-effort */ }
 
+  // Capture listen target before stop clears runtime state (same contract as GUI update worker).
+  // Prefer a live runtime record; a stale crashed leftover must not override config.port.
+  const preUpdateConfig = loadConfig();
+  const preUpdateRt = readRuntimePort();
+  const livePid = readPid();
+  const runtimeTrusted = !!(preUpdateRt && livePid && preUpdateRt.pid === livePid);
+  const configPort = typeof preUpdateConfig.port === "number" && preUpdateConfig.port > 0
+    ? preUpdateConfig.port
+    : 10100;
+  const capturedListen = {
+    port: runtimeTrusted ? preUpdateRt.port : configPort,
+    hostname: (runtimeTrusted ? preUpdateRt.hostname : undefined) ?? preUpdateConfig.hostname ?? "127.0.0.1",
+  };
+
   // Never replace package files under a live proxy: the running server dynamic-imports
   // modules after startup, so an in-place update leaves it executing mixed old/new code.
   // Gate on the service and the runtime-port record too, not just the pid file — a
@@ -230,14 +244,27 @@ export async function runUpdate(): Promise<void> {
     if (serviceWasInstalled) {
       console.log("🔁 Reinstalling the background service with the updated files...");
       const { serviceReinstallArgs } = await import("../service");
-      const svcStdio = updateChildStdio();
-      const svc = spawnSync(process.execPath, [process.argv[1], ...serviceReinstallArgs()], {
-        stdio: svcStdio,
-        encoding: svcStdio === "pipe" ? "utf8" : undefined,
-        windowsHide: true,
+      const { waitForPortAvailable } = await import("../server/ports");
+      const freed = await waitForPortAvailable(capturedListen.port, capturedListen.hostname, {
+        timeoutMs: 5_000,
+        intervalMs: 25,
       });
-      if (svcStdio === "pipe") logSpawnOutput("", svc);
-      if (svc.status !== 0) console.warn("⚠️  Service refresh failed — run 'ocx service install' manually.");
+      if (!freed) console.warn(`⚠️  Port ${capturedListen.port} still busy; reinstalling with pinned --port anyway.`);
+      const prevBake = process.env.OCX_BAKE_PORT;
+      process.env.OCX_BAKE_PORT = String(capturedListen.port);
+      try {
+        const svcStdio = updateChildStdio();
+        const svc = spawnSync(process.execPath, [process.argv[1], ...serviceReinstallArgs()], {
+          stdio: svcStdio,
+          encoding: svcStdio === "pipe" ? "utf8" : undefined,
+          windowsHide: true,
+        });
+        if (svcStdio === "pipe") logSpawnOutput("", svc);
+        if (svc.status !== 0) console.warn("⚠️  Service refresh failed — run 'ocx service install' manually.");
+      } finally {
+        if (prevBake === undefined) delete process.env.OCX_BAKE_PORT;
+        else process.env.OCX_BAKE_PORT = prevBake;
+      }
     } else {
       console.log("Restart the proxy:  ocx start");
     }

package/src/update/job.ts

@@ -291,6 +291,12 @@ export interface RestartIo {
   waitForPort?: typeof waitForPortAvailable;
   spawnStart?: (job: UpdateJobState, installer: Installer, port?: number) => void;
   serviceInstalledFn?: () => boolean;
+  /** Service-mode install/reinstall command (defaults to spawnSync via runLoggedCommand). */
+  runService?: (
+    job: UpdateJobState,
+    bin: string,
+    args: string[],
+  ) => { status: number | null; signal?: NodeJS.Signals | null };
 }
 
 async function restartAfterUpdate(
@@ -313,10 +319,26 @@ async function restartAfterUpdate(
     } catch { /* fallback to default service install */ }
   }
   const cmd = restartCommand(serviceInstalled, job.installer, packageLauncherPath(), port, svcArgs);
+  const waitFn = io.waitForPort ?? waitForPortAvailable;
+
   if (serviceInstalled) {
-    const result = runLoggedCommand(job, cmd.bin, cmd.args, RESTART_TIMEOUT_MS);
-    if (result.status !== 0) {
-      throw new Error(`service restart failed (${cmd.display}, exit ${result.status ?? "?"})`);
+    // 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 });
+    if (!freed) {
+      updateJob(job, {}, `Port ${port} still busy after stop; reinstalling service with pinned --port ${port} anyway.`);
+    }
+    const prevBake = process.env.OCX_BAKE_PORT;
+    process.env.OCX_BAKE_PORT = String(Math.trunc(port));
+    try {
+      const run = io.runService ?? ((j, bin, args) => runLoggedCommand(j, bin, args, RESTART_TIMEOUT_MS));
+      const result = run(job, cmd.bin, cmd.args);
+      if (result.status !== 0) {
+        throw new Error(`service restart failed (${cmd.display}, exit ${result.status ?? "?"})`);
+      }
+    } finally {
+      if (prevBake === undefined) delete process.env.OCX_BAKE_PORT;
+      else process.env.OCX_BAKE_PORT = prevBake;
     }
     return;
   }
@@ -329,8 +351,7 @@ async function restartAfterUpdate(
   // 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 waitFn = io.waitForPort ?? waitForPortAvailable;
-  const freed = await waitFn(port, hostname, { timeoutMs: 2000, intervalMs: 25 });
+  const freed = await waitFn(port, hostname, { timeoutMs: 2_000, intervalMs: 25 });
   if (!freed) {
     updateJob(job, {}, `Port ${port} still busy after stop; starting with --port ${port} anyway.`);
   }
@@ -352,11 +373,17 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
   const now = new Date().toISOString();
   // Capture the live listen target BEFORE the update command runs: the stop-first update
   // flow clears pid/runtime state, so this is the last moment the real port is knowable.
+  // Only trust runtime-port.json when its pid matches the live pidfile process.
   const rt = readRuntimePort();
+  const livePid = readPid();
   const preUpdateConfig = loadConfig();
+  const runtimeTrusted = !!(rt && livePid && rt.pid === livePid);
+  const configPort = typeof preUpdateConfig.port === "number" && preUpdateConfig.port > 0
+    ? preUpdateConfig.port
+    : 10100;
   const captured = {
-    port: rt?.port ?? preUpdateConfig.port ?? 10100,
-    hostname: rt?.hostname ?? preUpdateConfig.hostname ?? "127.0.0.1",
+    port: runtimeTrusted ? rt.port : configPort,
+    hostname: (runtimeTrusted ? rt.hostname : undefined) ?? preUpdateConfig.hostname ?? "127.0.0.1",
   };
   if (!job) {
     job = {

package/src/usage/log.ts

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, appendFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { getConfigDir } from "../config";
 import { usageDisplayTotalTokens } from "./totals";
@@ -39,6 +39,14 @@ export interface PersistedUsageEntry {
   surface?: "claude";
   resolvedModel?: string;
   requestedModel?: string;
+  /** Reasoning effort / service-tier metadata for GUI Logs after restart. */
+  requestedEffort?: string;
+  requestedServiceTier?: string;
+  requestedSpeedLabel?: string;
+  configuredServiceTier?: string;
+  configuredSpeedLabel?: string;
+  modelSupportsServiceTier?: boolean;
+  responseServiceTier?: string;
   status: number;
   durationMs: number;
   /** TTFT relative to the request start (WP4); unset for non-streaming/tool-only. */
@@ -197,6 +205,11 @@ function normalizedAttempts(raw: unknown): PersistedUsageAttempt[] {
     .filter((attempt): attempt is PersistedUsageAttempt => attempt !== null);
 }
 
+const MAX_METADATA_STRING_LEN = 64;
+function capMetadataString(s: string): string {
+  return s.length > MAX_METADATA_STRING_LEN ? s.slice(0, MAX_METADATA_STRING_LEN) : s;
+}
+
 function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
   const attempts = normalizedAttempts(entry.attempts);
   return {
@@ -207,6 +220,27 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
     ...(entry.surface === "claude" ? { surface: entry.surface } : {}),
     ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
     ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
+    ...(typeof entry.requestedEffort === "string" && entry.requestedEffort
+      ? { requestedEffort: capMetadataString(entry.requestedEffort) }
+      : {}),
+    ...(typeof entry.requestedServiceTier === "string" && entry.requestedServiceTier
+      ? { requestedServiceTier: capMetadataString(entry.requestedServiceTier) }
+      : {}),
+    ...(typeof entry.requestedSpeedLabel === "string" && entry.requestedSpeedLabel
+      ? { requestedSpeedLabel: capMetadataString(entry.requestedSpeedLabel) }
+      : {}),
+    ...(typeof entry.configuredServiceTier === "string" && entry.configuredServiceTier
+      ? { configuredServiceTier: capMetadataString(entry.configuredServiceTier) }
+      : {}),
+    ...(typeof entry.configuredSpeedLabel === "string" && entry.configuredSpeedLabel
+      ? { configuredSpeedLabel: capMetadataString(entry.configuredSpeedLabel) }
+      : {}),
+    ...(typeof entry.modelSupportsServiceTier === "boolean"
+      ? { modelSupportsServiceTier: entry.modelSupportsServiceTier }
+      : {}),
+    ...(typeof entry.responseServiceTier === "string" && entry.responseServiceTier
+      ? { responseServiceTier: capMetadataString(entry.responseServiceTier) }
+      : {}),
     status: entry.status,
     durationMs: entry.durationMs,
     ...(isNonNegativeFiniteNumber(entry.firstOutputMs)
@@ -254,3 +288,66 @@ export function readUsageEntries(): PersistedUsageEntry[] {
   }
   return entries;
 }
+
+function parseUsageLines(lines: string[]): PersistedUsageEntry[] {
+  const entries: PersistedUsageEntry[] = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line) as PersistedUsageEntry;
+      if (parsed && typeof parsed === "object" && typeof parsed.requestId === "string") {
+        entries.push(normalizeUsageEntry(parsed));
+      }
+    } catch {
+      /* skip partial / hand-edited lines */
+    }
+  }
+  return entries;
+}
+
+/**
+ * Read only the newest `limit` usage.jsonl rows without loading the whole append-only
+ * file into memory. Used by request-log hydration on `ocx start`.
+ */
+export function readRecentUsageEntries(limit: number): PersistedUsageEntry[] {
+  if (!Number.isFinite(limit) || limit <= 0) return [];
+  const path = usageLogPath();
+  if (!existsSync(path)) return [];
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    const size = fstatSync(fd).size;
+    if (size <= 0) return [];
+    // ~4 KiB/row budget with a floor; expand once if the window yields too few lines.
+    let windowBytes = Math.min(size, Math.max(64 * 1024, Math.ceil(limit) * 4 * 1024));
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const start = Math.max(0, size - windowBytes);
+      const buf = Buffer.alloc(size - start);
+      readSync(fd, buf, 0, buf.length, start);
+      let text = buf.toString("utf-8");
+      if (start > 0) {
+        const nl = text.indexOf("\n");
+        if (nl < 0) {
+          if (start === 0) break;
+          windowBytes = Math.min(size, windowBytes * 4);
+          continue;
+        }
+        text = text.slice(nl + 1);
+      }
+      const lines = text.split(/\r?\n/).filter(line => line.trim());
+      // Parse ALL lines first, then take the last N valid entries. This way corrupt
+      // or partial lines are filtered out during parsing and we always return the
+      // most recent N valid rows (not N physical lines minus corrupt ones).
+      const entries = parseUsageLines(lines);
+      if (entries.length >= limit || start === 0 || windowBytes >= size) return entries.slice(-limit);
+      windowBytes = Math.min(size, windowBytes * 4);
+    }
+    return [];
+  } catch {
+    return [];
+  } finally {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch { /* ignore */ }
+    }
+  }
+}