@bitkyc08/opencodex 2.5.6 → 2.6.0

package/src/codex-journal.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteFile } from "./config";
@@ -9,11 +10,26 @@ interface Journal {
   version: 1;
   originalConfig: string;
   originalProfile: string | null;
+  injectedConfigHash?: string;
+  injectedProfileHash?: string | null;
   pid: number;
   timestamp: string;
 }
 
+interface RestoreJournalResult {
+  configRestored: boolean;
+  profileRestored: boolean;
+  configChanged: boolean;
+  profileChanged: boolean;
+  complete: boolean;
+}
+
+function sha256(content: string | null): string | null {
+  return content === null ? null : createHash("sha256").update(content).digest("hex");
+}
+
 export function writeJournal(): void {
+  if (existsSync(JOURNAL_PATH) && readJournal()) return;
   if (!existsSync(CODEX_CONFIG_PATH)) return;
   const config = readFileSync(CODEX_CONFIG_PATH, "utf-8");
   const profile = existsSync(CODEX_PROFILE_PATH)
@@ -29,20 +45,73 @@ export function writeJournal(): void {
   atomicWriteFile(JOURNAL_PATH, JSON.stringify(journal));
 }
 
+export function markJournalInjectedState(config: string, profile: string | null): void {
+  const journal = readJournal();
+  if (!journal) return;
+  if (journal.injectedConfigHash) return;
+  journal.injectedConfigHash = sha256(config) ?? undefined;
+  journal.injectedProfileHash = sha256(profile);
+  atomicWriteFile(JOURNAL_PATH, JSON.stringify(journal));
+}
+
 export function removeJournal(): void {
   try { unlinkSync(JOURNAL_PATH); } catch { /* ignore */ }
 }
 
-export function reconcileJournal(): boolean {
-  if (!existsSync(JOURNAL_PATH)) return false;
-  let journal: Journal;
+function readJournal(): Journal | null {
+  if (!existsSync(JOURNAL_PATH)) return null;
   try {
-    journal = JSON.parse(readFileSync(JOURNAL_PATH, "utf-8"));
+    const journal = JSON.parse(readFileSync(JOURNAL_PATH, "utf-8")) as Journal;
     if (journal.version !== 1) throw new Error("unknown version");
+    return journal;
   } catch {
     removeJournal();
-    return false;
+    return null;
+  }
+}
+
+export function restoreJournalState(): RestoreJournalResult {
+  const journal = readJournal();
+  if (!journal) {
+    return { configRestored: false, profileRestored: false, configChanged: false, profileChanged: false, complete: false };
   }
+  const currentConfig = existsSync(CODEX_CONFIG_PATH) ? readFileSync(CODEX_CONFIG_PATH, "utf-8") : "";
+  const currentProfile = existsSync(CODEX_PROFILE_PATH) ? readFileSync(CODEX_PROFILE_PATH, "utf-8") : null;
+  const configUnchanged = !journal.injectedConfigHash || sha256(currentConfig) === journal.injectedConfigHash;
+  const profileUnchanged = journal.injectedProfileHash === undefined || sha256(currentProfile) === (journal.injectedProfileHash ?? null);
+
+  let configRestored = false;
+  let profileRestored = false;
+  if (configUnchanged) {
+    atomicWriteFile(CODEX_CONFIG_PATH, Buffer.from(journal.originalConfig, "base64").toString("utf-8"));
+    configRestored = true;
+  }
+  if (profileUnchanged) {
+    if (journal.originalProfile !== null) {
+      atomicWriteFile(CODEX_PROFILE_PATH, Buffer.from(journal.originalProfile, "base64").toString("utf-8"));
+    } else if (existsSync(CODEX_PROFILE_PATH)) {
+      try { unlinkSync(CODEX_PROFILE_PATH); } catch { /* ignore */ }
+    }
+    profileRestored = true;
+  }
+  const complete = configRestored && profileRestored;
+  if (complete) removeJournal();
+  return {
+    configRestored,
+    profileRestored,
+    configChanged: !configUnchanged,
+    profileChanged: !profileUnchanged,
+    complete,
+  };
+}
+
+export function restoreJournal(): boolean {
+  return restoreJournalState().complete;
+}
+
+export function reconcileJournal(): boolean {
+  const journal = readJournal();
+  if (!journal) return false;
   try {
     process.kill(journal.pid, 0);
     return false;
@@ -51,13 +120,8 @@ export function reconcileJournal(): boolean {
       return false;
     }
   }
-  atomicWriteFile(CODEX_CONFIG_PATH, Buffer.from(journal.originalConfig, "base64").toString("utf-8"));
-  if (journal.originalProfile !== null) {
-    atomicWriteFile(CODEX_PROFILE_PATH, Buffer.from(journal.originalProfile, "base64").toString("utf-8"));
-  } else if (existsSync(CODEX_PROFILE_PATH)) {
-    try { unlinkSync(CODEX_PROFILE_PATH); } catch { /* ignore */ }
-  }
-  removeJournal();
-  console.error(`⚠️  Previous session (PID ${journal.pid}) did not shut down cleanly. Codex config restored from journal.`);
+  const restored = restoreJournalState();
+  if (!restored.configRestored && !restored.profileRestored) return false;
+  console.error(`⚠️  Previous session (PID ${journal.pid}) did not shut down cleanly. Codex state restored from journal.`);
   return true;
 }

package/src/codex-quota.ts

@@ -121,21 +121,29 @@ export function parseUsageQuota(data: WhamUsageResponse): Omit<StoredAccountQuot
   }
 
   const quota: Omit<StoredAccountQuota, "updatedAt"> = {};
+  const thirtyDayOnly = data.plan_type?.trim().toLowerCase() === "go" || data.plan_type?.trim().toLowerCase() === "free";
   const weeklyPercent = normalizeUsagePercent(data.rate_limit.secondary_window?.used_percent);
   const fiveHourPercent = normalizeUsagePercent(data.rate_limit.primary_window?.used_percent);
   const monthlyPercent = normalizeUsagePercent(data.rate_limit.tertiary_window?.used_percent);
   const weeklyResetAt = normalizeResetAt(data.rate_limit.secondary_window?.reset_at);
   const fiveHourResetAt = normalizeResetAt(data.rate_limit.primary_window?.reset_at);
   const monthlyResetAt = normalizeResetAt(data.rate_limit.tertiary_window?.reset_at);
-  if (weeklyPercent !== undefined) {
+  if (thirtyDayOnly) {
+    const goMonthlyPercent = monthlyPercent ?? fiveHourPercent;
+    const goMonthlyResetAt = monthlyResetAt ?? fiveHourResetAt;
+    if (goMonthlyPercent !== undefined) {
+      quota.monthlyPercent = goMonthlyPercent;
+      if (goMonthlyResetAt !== undefined) quota.monthlyResetAt = goMonthlyResetAt;
+    }
+  } else if (weeklyPercent !== undefined) {
     quota.weeklyPercent = weeklyPercent;
     if (weeklyResetAt !== undefined) quota.weeklyResetAt = weeklyResetAt;
   }
-  if (fiveHourPercent !== undefined) {
+  if (!thirtyDayOnly && fiveHourPercent !== undefined) {
     quota.fiveHourPercent = fiveHourPercent;
     if (fiveHourResetAt !== undefined) quota.fiveHourResetAt = fiveHourResetAt;
   }
-  if (monthlyPercent !== undefined) {
+  if (!thirtyDayOnly && monthlyPercent !== undefined) {
     quota.monthlyPercent = monthlyPercent;
     if (monthlyResetAt !== undefined) quota.monthlyResetAt = monthlyResetAt;
   }

package/src/codex-routing.ts

@@ -74,8 +74,14 @@ export function computeCodexUsageScore(quota: {
   weeklyPercent?: number;
   fiveHourPercent?: number;
   monthlyPercent?: number;
-} | null): number {
+} | null, plan?: string | null): number {
   if (!quota) return CODEX_UNKNOWN_USAGE_SCORE;
+  const normalizedPlan = plan?.trim().toLowerCase();
+  if (normalizedPlan === "go" || normalizedPlan === "free") {
+    return typeof quota.monthlyPercent === "number" && Number.isFinite(quota.monthlyPercent)
+      ? quota.monthlyPercent
+      : CODEX_UNKNOWN_USAGE_SCORE;
+  }
   const values = [quota.weeklyPercent, quota.fiveHourPercent, quota.monthlyPercent]
     .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
   return values.length > 0 ? Math.max(...values) : CODEX_UNKNOWN_USAGE_SCORE;
@@ -204,11 +210,15 @@ function getEligiblePoolAccounts(config: OcxConfig, excludeId?: string, now = Da
     .map(account => account.id);
 }
 
+function getPoolAccountPlan(config: OcxConfig, accountId: string): string | undefined {
+  return (config.codexAccounts ?? []).find(account => !account.isMain && account.id === accountId)?.plan;
+}
+
 function pickLowerUsageAccount(config: OcxConfig, active: string, activeUsage: number, now: number): string {
   let best = active;
   let bestUsage = activeUsage;
   for (const id of getEligiblePoolAccounts(config, active, now)) {
-    const usage = computeCodexUsageScore(getAccountQuota(id));
+    const usage = computeCodexUsageScore(getAccountQuota(id), getPoolAccountPlan(config, id));
     if (usage < bestUsage) {
       best = id;
       bestUsage = usage;
@@ -221,7 +231,7 @@ export function pickLowestUsageCodexAccount(config: OcxConfig, excludeId?: strin
   let best: string | null = null;
   let bestUsage = Number.POSITIVE_INFINITY;
   for (const id of getEligiblePoolAccounts(config, excludeId, now)) {
-    const usage = computeCodexUsageScore(getAccountQuota(id));
+    const usage = computeCodexUsageScore(getAccountQuota(id), getPoolAccountPlan(config, id));
     if (usage < bestUsage) {
       best = id;
       bestUsage = usage;
@@ -240,7 +250,7 @@ function applyQuotaAutoSwitch(config: OcxConfig, active: string, now: number): s
   const threshold = config.autoSwitchThreshold ?? 80;
   if (threshold <= 0) return active;
   const quota = getAccountQuota(active);
-  const activeUsage = computeCodexUsageScore(quota);
+  const activeUsage = computeCodexUsageScore(quota, getPoolAccountPlan(config, active));
   if (activeUsage < threshold) return active;
   const best = pickLowerUsageAccount(config, active, activeUsage, now);
   if (best !== active) setActiveCodexAccount(config, best);

package/src/codex-shim.ts

@@ -2,8 +2,10 @@ import { delimiter, dirname, extname, join } from "node:path";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { getConfigDir } from "./config";
 import { durableBunPath } from "./bun-runtime";
+import { serviceApiTokenFilePath } from "./service-secrets";
 
 const SHIM_MARKER = "opencodex codex autostart shim";
+let lastShimDiscoveryError: string | null = null;
 const CODEX_INTERNAL_COMMANDS = [
   "app-server",
   "archive",
@@ -13,7 +15,6 @@ const CODEX_INTERNAL_COMMANDS = [
   "debug",
   "delete",
   "doctor",
-  "exec",
   "exec-server",
   "features",
   "fork",
@@ -22,8 +23,6 @@ const CODEX_INTERNAL_COMMANDS = [
   "logout",
   "mcp",
   "plugin",
-  "resume",
-  "review",
   "sandbox",
   "unarchive",
   "update",
@@ -41,6 +40,8 @@ interface ShimFileState {
   wrapperPath: string;
   originalPath: string;
   backupPath: string;
+  realPath?: string;
+  preserveOnly?: boolean;
 }
 
 function cliEntry(): { bun: string; cli: string } {
@@ -79,7 +80,20 @@ function findCodexOnPath(): string | null {
 }
 
 function findWindowsCodexTargets(): ShimFileState[] | null {
+  lastShimDiscoveryError = null;
   for (const dir of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+    const exe = join(dir, "codex.exe");
+    if (existsSync(exe) && !isShim(exe)) {
+      try {
+        if (!lstatSync(exe).isDirectory()) {
+          lastShimDiscoveryError =
+            `Found codex.exe at ${exe}. Refusing to rename a real .exe because exact codex.exe invocations would break; ` +
+            "install a codex.cmd/codex.ps1 launcher or use `ocx service install` for autostart.";
+          return null;
+        }
+      } catch { /* keep scanning */ }
+    }
+
     const cmd = join(dir, "codex.cmd");
     const ps1 = join(dir, "codex.ps1");
     const targets: ShimFileState[] = [];
@@ -92,15 +106,6 @@ function findWindowsCodexTargets(): ShimFileState[] | null {
       } catch { /* keep scanning */ }
     }
     if (targets.length > 0) return targets;
-
-    const exe = join(dir, "codex.exe");
-    if (!existsSync(exe) || isShim(exe)) continue;
-    try {
-      if (lstatSync(exe).isDirectory()) continue;
-      const wrapperPath = join(dir, "codex.cmd");
-      if (existsSync(wrapperPath) && !isShim(wrapperPath)) continue;
-      return [{ wrapperPath, originalPath: exe, backupPath: backupPathFor(exe) }];
-    } catch { /* keep scanning */ }
   }
   return null;
 }
@@ -110,36 +115,62 @@ function backupPathFor(path: string): string {
   return ext ? `${path.slice(0, -ext.length)}.opencodex-real${ext}` : `${path}.opencodex-real`;
 }
 
+function shQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
 export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
   const internalCommands = CODEX_INTERNAL_COMMANDS.join("|");
+  const tokenFile = serviceApiTokenFilePath();
   return `#!/usr/bin/env sh
 # ${SHIM_MARKER}
+if [ -z "$OPENCODEX_API_AUTH_TOKEN" ] && [ -f ${shQuote(tokenFile)} ]; then
+  OPENCODEX_API_AUTH_TOKEN="$(cat ${shQuote(tokenFile)})"
+  export OPENCODEX_API_AUTH_TOKEN
+fi
 case "$1" in
   ${internalCommands}|--help|-h|--version|-V)
     ;;
   *)
     if [ -z "$OCX_SHIM_BYPASS" ]; then
-      "${bunPath}" "${cliPath}" ensure >/dev/null 2>&1 || true
+      ${shQuote(bunPath)} ${shQuote(cliPath)} ensure >/dev/null 2>&1 || true
     fi
     ;;
 esac
-exec "${realCodexPath}" "$@"
+exec ${shQuote(realCodexPath)} "$@"
 `;
 }
 
+function windowsBatchValue(value: string): string {
+  return value
+    .replace(/%/g, "%%")
+    .replace(/\^/g, "^^")
+    .replace(/"/g, "")
+    .replace(/[\r\n]/g, "");
+}
+
+function windowsBatchSet(name: string, value: string): string {
+  return `set "${name}=${windowsBatchValue(value)}"`;
+}
+
 export function buildWindowsCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
   const internalCommandChecks = CODEX_INTERNAL_COMMANDS.map(command => `if /I "%~1"=="${command}" goto run_codex`).join("\r\n");
   return `@echo off\r
 rem ${SHIM_MARKER}\r
+${windowsBatchSet("OCX_REAL_CODEX", realCodexPath)}\r
+${windowsBatchSet("OCX_BUN", bunPath)}\r
+${windowsBatchSet("OCX_CLI", cliPath)}\r
+${windowsBatchSet("OCX_API_TOKEN_FILE", serviceApiTokenFilePath())}\r
+if "%OPENCODEX_API_AUTH_TOKEN%"=="" if exist "%OCX_API_TOKEN_FILE%" set /p OPENCODEX_API_AUTH_TOKEN=<"%OCX_API_TOKEN_FILE%"\r
 if not "%OCX_SHIM_BYPASS%"=="" goto run_codex\r
 ${internalCommandChecks}\r
 if /I "%~1"=="--help" goto run_codex\r
 if /I "%~1"=="-h" goto run_codex\r
 if /I "%~1"=="--version" goto run_codex\r
 if /I "%~1"=="-V" goto run_codex\r
-"${bunPath}" "${cliPath}" ensure >nul 2>nul\r
+"%OCX_BUN%" "%OCX_CLI%" ensure >nul 2>nul\r
 :run_codex\r
-"${realCodexPath}" %*\r
+"%OCX_REAL_CODEX%" %*\r
 `;
 }
 
@@ -149,8 +180,12 @@ function psString(value: string): string {
 
 export function buildWindowsPowerShellCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
   const internalCommands = CODEX_INTERNAL_COMMANDS.map(command => psString(command)).join(", ");
+  const tokenFile = serviceApiTokenFilePath();
   return `#!/usr/bin/env pwsh
 # ${SHIM_MARKER}
+if (-not $env:OPENCODEX_API_AUTH_TOKEN -and (Test-Path -LiteralPath ${psString(tokenFile)})) {
+  $env:OPENCODEX_API_AUTH_TOKEN = (Get-Content -Raw -LiteralPath ${psString(tokenFile)}).Trim()
+}
 $internalCommands = @(${internalCommands})
 $firstArg = if ($args.Count -gt 0) { [string]$args[0] } else { "" }
 $skipEnsure = $env:OCX_SHIM_BYPASS -or $internalCommands -contains $firstArg -or @("--help", "-h", "--version", "-V") -contains $firstArg
@@ -218,19 +253,26 @@ function replaceOwnedBackup(sourcePath: string, backupPath: string): void {
 }
 
 function refreshShimFile(file: ShimFileState): boolean {
+  if (file.preserveOnly) {
+    if (existsSync(file.originalPath) && !isShim(file.originalPath)) {
+      replaceOwnedBackup(file.originalPath, file.backupPath);
+      return true;
+    }
+    return false;
+  }
   if (existsSync(file.wrapperPath) && !isShim(file.wrapperPath)) {
     if (file.wrapperPath !== file.originalPath) return false;
     replaceOwnedBackup(file.wrapperPath, file.backupPath);
-    writeShim(file.wrapperPath, file.backupPath);
+    writeShim(file.wrapperPath, file.realPath ?? file.backupPath);
     return true;
   }
   if (!existsSync(file.wrapperPath) && existsSync(file.backupPath)) {
-    writeShim(file.wrapperPath, file.backupPath);
+    writeShim(file.wrapperPath, file.realPath ?? file.backupPath);
     return true;
   }
   if (file.originalPath !== file.wrapperPath && existsSync(file.originalPath) && existsSync(file.wrapperPath) && isShim(file.wrapperPath)) {
     replaceOwnedBackup(file.originalPath, file.backupPath);
-    writeShim(file.wrapperPath, file.backupPath);
+    writeShim(file.wrapperPath, file.realPath ?? file.backupPath);
     return true;
   }
   return false;
@@ -242,7 +284,11 @@ export function installCodexShim(): { installed: boolean; message: string } {
     const files = stateFiles(existing);
     let refreshed = false;
     for (const file of files) refreshed = refreshShimFile(file) || refreshed;
-    const allInstalled = files.every(file => existsSync(file.wrapperPath) && existsSync(file.backupPath) && isShim(file.wrapperPath));
+    const allInstalled = files.every(file => file.preserveOnly
+      ? existsSync(file.backupPath) && !existsSync(file.originalPath)
+      : existsSync(file.wrapperPath)
+        && (existsSync(file.backupPath) || (file.realPath ? existsSync(file.realPath) : false))
+        && isShim(file.wrapperPath));
     if (refreshed || allInstalled) {
       writeState(primaryState(files));
       if (refreshed) {
@@ -258,20 +304,20 @@ export function installCodexShim(): { installed: boolean; message: string } {
     }
   }
 
-  const targets = process.platform === "win32"
+  const targets: ShimFileState[] | null = process.platform === "win32"
     ? findWindowsCodexTargets()
     : (() => {
       const originalPath = findCodexOnPath();
       return originalPath ? [{ wrapperPath: originalPath, originalPath, backupPath: backupPathFor(originalPath) }] : null;
     })();
-  if (!targets) return { installed: false, message: "Could not find a codex executable on PATH." };
+  if (!targets) return { installed: false, message: lastShimDiscoveryError ?? "Could not find a codex executable on PATH." };
 
   for (const target of targets) {
     if (existsSync(target.backupPath)) return { installed: false, message: `Refusing to overwrite existing backup: ${target.backupPath}` };
   }
   for (const target of targets) {
-    renameSync(target.originalPath, target.backupPath);
-    writeShim(target.wrapperPath, target.backupPath);
+    if (existsSync(target.originalPath)) renameSync(target.originalPath, target.backupPath);
+    if (!target.preserveOnly) writeShim(target.wrapperPath, target.realPath ?? target.backupPath);
   }
   writeState(primaryState(targets));
   return {
@@ -285,6 +331,7 @@ export function uninstallCodexShim(): { removed: boolean; message: string } {
   if (!state) return { removed: false, message: "Codex autostart shim is not installed." };
   const files = stateFiles(state);
   for (const file of files) {
+    if (file.preserveOnly) continue;
     if (existsSync(file.wrapperPath) && isShim(file.wrapperPath)) unlinkSync(file.wrapperPath);
   }
   for (const file of files) {

package/src/codex-websocket-registry.ts

@@ -8,8 +8,7 @@ function trackedAccountId(ws: ServerWebSocket<WsData>): string | null {
   return ctx?.kind === "pool" ? ctx.accountId : null;
 }
 
-export function registerCodexWebSocket(ws: ServerWebSocket<WsData>): void {
-  const accountId = trackedAccountId(ws);
+function addSocketForAccount(accountId: string | null, ws: ServerWebSocket<WsData>): void {
   if (!accountId) return;
   let sockets = socketsByAccount.get(accountId);
   if (!sockets) {
@@ -19,8 +18,7 @@ export function registerCodexWebSocket(ws: ServerWebSocket<WsData>): void {
   sockets.add(ws);
 }
 
-export function unregisterCodexWebSocket(ws: ServerWebSocket<WsData>): void {
-  const accountId = trackedAccountId(ws);
+function removeSocketForAccount(accountId: string | null, ws: ServerWebSocket<WsData>): void {
   if (!accountId) return;
   const sockets = socketsByAccount.get(accountId);
   if (!sockets) return;
@@ -28,6 +26,24 @@ export function unregisterCodexWebSocket(ws: ServerWebSocket<WsData>): void {
   if (sockets.size === 0) socketsByAccount.delete(accountId);
 }
 
+export function registerCodexWebSocket(ws: ServerWebSocket<WsData>): void {
+  addSocketForAccount(trackedAccountId(ws), ws);
+}
+
+export function unregisterCodexWebSocket(ws: ServerWebSocket<WsData>): void {
+  removeSocketForAccount(trackedAccountId(ws), ws);
+}
+
+export function updateCodexWebSocketAuthContext(
+  ws: ServerWebSocket<WsData>,
+  authContext: WsData["authContext"],
+): void {
+  const before = trackedAccountId(ws);
+  removeSocketForAccount(before, ws);
+  ws.data.authContext = authContext;
+  addSocketForAccount(trackedAccountId(ws), ws);
+}
+
 export function invalidateCodexWebSocketsForAccount(accountId: string): number {
   const sockets = socketsByAccount.get(accountId);
   if (!sockets) return 0;