npm - @bitkyc08/opencodex - Versions diffs - 2.6.0 → 2.6.1 - Mend

@bitkyc08/opencodex 2.6.0 → 2.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/gui/dist/assets/index-BmHrbTmO.js +9 -0
package/gui/dist/index.html +1 -1
package/package.json +1 -1
package/src/cli.ts +4 -0
package/src/codex-account-usability.ts +5 -0
package/src/codex-auth-api.ts +19 -3
package/src/codex-auth-context.ts +21 -3
package/src/codex-main-account.ts +46 -0
package/src/codex-routing.ts +19 -1
package/src/codex-websocket-registry.ts +1 -1
package/src/crash-guard.ts +82 -0
package/src/provider-label.ts +4 -0
package/src/server.ts +10 -4
package/src/usage-summary.ts +0 -0
package/gui/dist/assets/index-BS4X1QDi.js +0 -9

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BS4X1QDi.js"></script>
+    <script type="module" crossorigin src="/assets/index-BmHrbTmO.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BwvDb198.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/cli.ts CHANGED Viewed

@@ -17,6 +17,7 @@ import {
   writeRuntimePort,
 } from "./config";
 import { collectStatus } from "./cli-status";
+import { installCrashGuards } from "./crash-guard";
 import { hasHelpFlag, printSubcommandUsage, printUsage, printVersion } from "./cli-help";
 import { findAvailablePort, shouldPersistSelectedPort } from "./ports";
 import { killProxy } from "./process-control";
@@ -136,6 +137,9 @@ async function handleStart(options: { block?: boolean } = {}) {
   const port = await chooseListenPort(requestedPort);
   const server = startServer(port);
+  // A single request's streaming error must never crash the daemon serving every
+  // other Codex session — capture the full stack to crash.log and stay up.
+  installCrashGuards();
   writePid(process.pid);
   const config = loadConfig();

package/src/codex-account-usability.ts CHANGED Viewed

@@ -1,8 +1,13 @@
 import { getCodexAccountCredential } from "./codex-account-store";
 import { isAccountNeedsReauth } from "./codex-account-runtime-state";
+import { MAIN_CODEX_ACCOUNT_ID, isMainAccountTokenLive } from "./codex-main-account";
 import type { OcxConfig } from "./types";
 export function isCodexAccountUsable(config: OcxConfig, accountId: string): boolean {
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) {
+    // Main account: credential is the read-only ~/.codex/auth.json token (Option A).
+    return isMainAccountTokenLive() && !isAccountNeedsReauth(accountId);
+  }
   const exists = (config.codexAccounts ?? []).some(account => !account.isMain && account.id === accountId);
   if (!exists) return false;
   if (isAccountNeedsReauth(accountId)) return false;

package/src/codex-auth-api.ts CHANGED Viewed

@@ -24,6 +24,7 @@ import {
 } from "./codex-quota";
 export { clearAccountQuota, getAccountQuota, parseUsageQuota, updateAccountQuota } from "./codex-quota";
 import { extractAccountId, decodeJwtPayload } from "./oauth/chatgpt";
+import { MAIN_CODEX_ACCOUNT_ID, setMainAccountPlan } from "./codex-main-account";
 import { maskEmail } from "./privacy";
 export { maskEmail } from "./privacy";
 import type { CodexAccount, OcxConfig } from "./types";
@@ -88,7 +89,7 @@ async function resolveResetCreditAuth(
   | { ok: true; isMain: boolean; accessToken: string; chatgptAccountId: string }
   | { ok: false; response: Response }
 > {
-  if (accountId === "__main__") {
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) {
     const tokens = readCodexTokens();
     if (!tokens) return { ok: false, response: jsonResponse({ error: "Main Codex account not logged in" }, 401) };
     return { ok: true, isMain: true, accessToken: tokens.access_token, chatgptAccountId: tokens.account_id };
@@ -202,6 +203,21 @@ async function fetchMainAccountInfo(forceRefresh = false): Promise<{ email: stri
       ts: Date.now(),
     };
     mainAccountCache = result;
+    // Mirror main quota + plan into the shared stores so the rotation engine can
+    // score and auto-switch the main account exactly like a pool account (Option A).
+    setMainAccountPlan(result.plan);
+    if (result.quota) {
+      updateAccountQuota(
+        MAIN_CODEX_ACCOUNT_ID,
+        result.quota.weeklyPercent,
+        result.quota.fiveHourPercent,
+        result.quota.weeklyResetAt,
+        result.quota.fiveHourResetAt,
+        result.quota.monthlyPercent,
+        result.quota.monthlyResetAt,
+        result.quota.resetCredits,
+      );
+    }
     return result;
   } catch {
     return { email: null, plan: null, quota: null };
@@ -265,7 +281,7 @@ export async function handleCodexAuthAPI(
       return poolAccountDto(a, quotaResult, !!cred);
     });
     const main = {
-      id: "__main__",
+      id: MAIN_CODEX_ACCOUNT_ID,
       email: maskEmail(mainInfo.email) ?? "Codex App login",
       plan: mainInfo.plan,
       isMain: true,
@@ -329,7 +345,7 @@ export async function handleCodexAuthAPI(
     let body: { accountId: string | null };
     try { body = (await req.json()) as typeof body; } catch { return jsonResponse({ error: "Invalid JSON" }, 400); }
     const runtimeConfig = getRuntimeConfig(config);
-    if (body.accountId != null) {
+    if (body.accountId != null && body.accountId !== MAIN_CODEX_ACCOUNT_ID) {
       const exists = (runtimeConfig.codexAccounts ?? []).some(a => a.id === body.accountId);
       if (!exists) return jsonResponse({ error: "Account not found" }, 400);
     }

package/src/codex-auth-context.ts CHANGED Viewed

@@ -6,6 +6,7 @@ import {
 } from "./codex-account-store";
 import { markAccountNeedsReauth } from "./codex-account-runtime-state";
 import { isCodexAccountUsable } from "./codex-account-usability";
+import { MAIN_CODEX_ACCOUNT_ID, getMainAccountToken } from "./codex-main-account";
 import { getCodexAccountCooldownUntil, resolveCodexAccountForThreadDetailed } from "./codex-routing";
 import type { OcxConfig, OcxProviderConfig } from "./types";
 import { FORWARD_HEADERS } from "./adapters/openai-responses";
@@ -18,6 +19,14 @@ export type CodexAuthContext =
       generation: number;
       accessToken: string;
       chatgptAccountId: string;
+    }
+  | {
+      // Main Codex account participating in rotation: token injected from ~/.codex/auth.json
+      // (Option A). Distinct from "main" (passthrough fallback that forwards the client token).
+      kind: "main-pool";
+      accountId: string;
+      accessToken: string;
+      chatgptAccountId: string;
     };
 export type OcxRuntimeProviderConfig = OcxProviderConfig & {
@@ -70,6 +79,14 @@ export async function resolveCodexAuthContext(headers: Headers, config: OcxConfi
   const cooldownUntil = getCodexAccountCooldownUntil(accountId);
   if (cooldownUntil) throw new CodexAccountCooldownError(accountId, cooldownUntil);
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) {
+    // Main account in rotation: inject the read-only auth.json token. If the token vanished
+    // since selection, fall back to passthrough rather than failing the request.
+    const token = getMainAccountToken();
+    if (!token) return { kind: "main", accountId: null };
+    return { kind: "main-pool", accountId, accessToken: token.accessToken, chatgptAccountId: token.chatgptAccountId };
+  }
   try {
     const token = await getValidCodexToken(accountId);
     return {
@@ -88,7 +105,7 @@ export async function resolveCodexAuthContext(headers: Headers, config: OcxConfi
 }
 export function assertCodexAuthContextNotCooled(ctx: CodexAuthContext | undefined): void {
-  if (ctx?.kind !== "pool") return;
+  if (ctx?.kind !== "pool" && ctx?.kind !== "main-pool") return;
   const cooldownUntil = getCodexAccountCooldownUntil(ctx.accountId);
   if (cooldownUntil) throw new CodexAccountCooldownError(ctx.accountId, cooldownUntil);
 }
@@ -97,7 +114,7 @@ export function applyCodexAuthContextToProvider(
   provider: OcxProviderConfig,
   ctx: CodexAuthContext,
 ): OcxRuntimeProviderConfig {
-  if (ctx.kind !== "pool" || provider.authMode !== "forward") return provider;
+  if ((ctx.kind !== "pool" && ctx.kind !== "main-pool") || provider.authMode !== "forward") return provider;
   return {
     ...provider,
     _codexAccountOverride: {
@@ -114,7 +131,7 @@ export function headersForCodexAuthContext(headers: Headers, ctx: CodexAuthConte
     const value = headers.get(name);
     if (value) selected.set(name, value);
   }
-  if (ctx.kind === "pool") {
+  if (ctx.kind === "pool" || ctx.kind === "main-pool") {
     selected.set("authorization", `Bearer ${ctx.accessToken}`);
     selected.set("chatgpt-account-id", ctx.chatgptAccountId);
   }
@@ -123,6 +140,7 @@ export function headersForCodexAuthContext(headers: Headers, ctx: CodexAuthConte
 export function isCodexAuthContextUsable(ctx: CodexAuthContext, config: OcxConfig): boolean {
   if (ctx.kind === "main") return true;
+  if (ctx.kind === "main-pool") return isCodexAccountUsable(config, ctx.accountId);
   return isCodexAccountUsable(config, ctx.accountId) && isCodexAccountGenerationLive(ctx.accountId, ctx.generation);
 }

package/src/codex-main-account.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import { readCodexTokens } from "./codex-auth-collision";
+import { decodeJwtPayload } from "./oauth/chatgpt";
+/**
+ * Stable id under which the "main" Codex account (the Codex CLI login stored in
+ * ~/.codex/auth.json) participates in opencodex's account rotation. The main account is
+ * NOT imported into the managed credential store (Option A): its token is read-only from
+ * auth.json, so opencodex never refreshes it — an expired token surfaces as a reauth
+ * notice (re-login via the Codex CLI) rather than a background refresh.
+ */
+export const MAIN_CODEX_ACCOUNT_ID = "__main__";
+/**
+ * Main account plan (e.g. "plus", "go", "free", "team"), populated from the WHAM usage
+ * fetch. Used by the rotation usage-score so go/free main accounts score on monthly
+ * percent, matching pool-account behavior.
+ */
+let mainAccountPlan: string | null = null;
+export function setMainAccountPlan(plan: string | null): void {
+  mainAccountPlan = plan;
+}
+export function getMainAccountPlan(): string | undefined {
+  return mainAccountPlan ?? undefined;
+}
+/** Read-only main account token from ~/.codex/auth.json, or null when not logged in. */
+export function getMainAccountToken(): { accessToken: string; chatgptAccountId: string } | null {
+  const tokens = readCodexTokens();
+  if (!tokens?.access_token) return null;
+  return { accessToken: tokens.access_token, chatgptAccountId: tokens.account_id };
+}
+/**
+ * The main token is usable when it exists and — if its JWT carries a decodable `exp` — is
+ * not expired. When `exp` cannot be decoded we treat the token as live (best-effort); an
+ * actually-invalid token then surfaces via the upstream 401 → cooldown path.
+ */
+export function isMainAccountTokenLive(now = Date.now()): boolean {
+  const tokens = readCodexTokens();
+  if (!tokens?.access_token) return false;
+  const payload = decodeJwtPayload(tokens.access_token);
+  const exp = typeof payload?.exp === "number" ? payload.exp * 1000 : undefined;
+  return exp === undefined || exp > now;
+}

package/src/codex-routing.ts CHANGED Viewed

@@ -4,6 +4,7 @@ import { codexAccountLogLabel } from "./codex-account-label";
 import { isCodexAccountUsable } from "./codex-account-usability";
 import { isAccountNeedsReauth, markAccountNeedsReauth } from "./codex-account-runtime-state";
 import { CODEX_UNKNOWN_USAGE_SCORE, getAccountQuota } from "./codex-quota";
+import { MAIN_CODEX_ACCOUNT_ID, getMainAccountPlan } from "./codex-main-account";
 import type { OcxConfig } from "./types";
 type ThreadAffinityEntry = {
@@ -43,6 +44,7 @@ export type CodexUpstreamOutcomeMeta = {
 };
 function hasConfiguredPoolAccount(config: OcxConfig, accountId: string): boolean {
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) return isCodexAccountUsable(config, accountId);
   return (config.codexAccounts ?? []).some(account => !account.isMain && account.id === accountId);
 }
@@ -203,14 +205,26 @@ function bindThreadAffinity(threadId: string, accountId: string, now: number): v
 }
 function getEligiblePoolAccounts(config: OcxConfig, excludeId?: string, now = Date.now()): string[] {
-  return (config.codexAccounts ?? [])
+  const ids = (config.codexAccounts ?? [])
     .filter(account => !account.isMain && account.id !== excludeId && !isAccountNeedsReauth(account.id))
     .filter(account => !isCodexAccountInCooldown(account.id, now))
     .filter(account => isCodexAccountUsable(config, account.id))
     .map(account => account.id);
+  // The main Codex account is not stored in config.codexAccounts; include it as a
+  // first-class rotation candidate when its read-only token is usable (Option A).
+  if (
+    excludeId !== MAIN_CODEX_ACCOUNT_ID
+    && !isAccountNeedsReauth(MAIN_CODEX_ACCOUNT_ID)
+    && !isCodexAccountInCooldown(MAIN_CODEX_ACCOUNT_ID, now)
+    && isCodexAccountUsable(config, MAIN_CODEX_ACCOUNT_ID)
+  ) {
+    ids.unshift(MAIN_CODEX_ACCOUNT_ID);
+  }
+  return ids;
 }
 function getPoolAccountPlan(config: OcxConfig, accountId: string): string | undefined {
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) return getMainAccountPlan();
   return (config.codexAccounts ?? []).find(account => !account.isMain && account.id === accountId)?.plan;
 }
@@ -387,6 +401,10 @@ export function recordCodexUpstreamOutcome(
 export function formatCodexProviderForLog(providerName: string, accountId: string | null, config: OcxConfig): string {
   if (!accountId) return providerName;
+  // The main Codex login participates in rotation as "main-pool" (MAIN_CODEX_ACCOUNT_ID) but is the
+  // same physical account as the "main" passthrough (null accountId). Log both under the base provider
+  // name so usage/tokens aggregate into a single row instead of splitting into `chatgpt` + `chatgpt-main`.
+  if (accountId === MAIN_CODEX_ACCOUNT_ID) return providerName;
   const account = (config.codexAccounts ?? []).find(a => !a.isMain && a.id === accountId);
   return account ? `${providerName}-${codexAccountLogLabel(account)}` : providerName;
 }

package/src/codex-websocket-registry.ts CHANGED Viewed

@@ -5,7 +5,7 @@ const socketsByAccount = new Map<string, Set<ServerWebSocket<WsData>>>();
 function trackedAccountId(ws: ServerWebSocket<WsData>): string | null {
   const ctx = ws.data.authContext;
-  return ctx?.kind === "pool" ? ctx.accountId : null;
+  return ctx?.kind === "pool" || ctx?.kind === "main-pool" ? ctx.accountId : null;
 }
 function addSocketForAccount(accountId: string | null, ws: ServerWebSocket<WsData>): void {

package/src/crash-guard.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir } from "./config";
+/**
+ * Process-level safety net for the long-running proxy daemon.
+ *
+ * A single request can trigger an async error inside a Bun.serve streaming
+ * handler (e.g. a ReadableStream `start(controller)` callback hitting an
+ * unexpected upstream response shape). Without a handler, Bun's default
+ * behaviour prints the raw error — shown as `(function (controller, error)
+ * {"use strict"; ... TypeError: null is not an object` — and can tear down
+ * the whole proxy, killing every other in-flight Codex session.
+ *
+ * We must NOT let one bad stream crash the daemon. These handlers:
+ *   1. Append the full error + stack to `<configDir>/crash.log` so the exact
+ *      fault (with the JSC `(evaluating 'x.y')` clause and file:line) is
+ *      captured for a precise root-cause fix.
+ *   2. Keep the process alive — the failed request is already isolated by
+ *      Bun.serve; surviving is strictly better than terminating.
+ */
+let installed = false;
+function crashLogPath(): string {
+  const dir = getConfigDir();
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch {
+    /* best-effort: directory usually already exists */
+  }
+  return join(dir, "crash.log");
+}
+function formatError(kind: string, err: unknown): string {
+  const ts = new Date().toISOString();
+  const detail =
+    err instanceof Error
+      ? `${err.name}: ${err.message}\n${err.stack ?? "(no stack)"}`
+      : typeof err === "object"
+        ? safeStringify(err)
+        : String(err);
+  return `\n[${ts}] ${kind}\n${detail}\n`;
+}
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function record(kind: string, err: unknown): void {
+  const line = formatError(kind, err);
+  // Always surface to stderr so foreground `ocx start` users still see it,
+  // then persist for later diagnosis.
+  console.error(`⚠️  ${kind} (proxy stayed up; logged to crash.log)`);
+  console.error(line.trimStart());
+  try {
+    appendFileSync(crashLogPath(), line);
+  } catch {
+    /* logging must never throw */
+  }
+}
+/**
+ * Register global handlers that keep the proxy alive and capture full stacks.
+ * Idempotent: safe to call more than once.
+ */
+export function installCrashGuards(): void {
+  if (installed) return;
+  installed = true;
+  process.on("unhandledRejection", reason => {
+    record("unhandledRejection", reason);
+  });
+  process.on("uncaughtException", err => {
+    record("uncaughtException", err);
+  });
+}

package/src/provider-label.ts CHANGED Viewed

@@ -4,5 +4,9 @@ export function baseProviderLabel(provider: string): string {
   const cut = provider.lastIndexOf("-");
   if (cut <= 0) return provider;
   const suffix = provider.slice(cut + 1);
+  // `-main` is the legacy log label for the main Codex account (MAIN_CODEX_ACCOUNT_ID). New entries
+  // log under the base provider name, but historical `<provider>-main` entries must still collapse so
+  // the usage table aggregates the main account into a single row instead of a stray split.
+  if (suffix === "main") return provider.slice(0, cut);
   return CODEX_ACCOUNT_LOG_LABEL_RE.test(suffix) ? provider.slice(0, cut) : provider;
 }

package/src/server.ts CHANGED Viewed

@@ -298,16 +298,22 @@ export function resolveAdapter(providerConfig: OcxProviderConfig) {
 }
 function sidecarOutcomeRecorder(config: OcxConfig, authCtx: CodexAuthContext): ((outcome: CodexUpstreamOutcome) => void) | undefined {
-  return authCtx.kind === "pool"
+  return authCtx.kind === "pool" || authCtx.kind === "main-pool"
     ? outcome => recordCodexUpstreamOutcome(config, authCtx.accountId, outcome)
     : undefined;
 }
+/** Account id to attribute log labels / upstream outcomes to (pool + rotation-injected main). */
+function codexLogAccountId(authCtx: CodexAuthContext): string | null {
+  return authCtx.kind === "pool" || authCtx.kind === "main-pool" ? authCtx.accountId : null;
+}
 function usesCodexForwardPoolAuth(
   authCtx: CodexAuthContext,
   provider: OcxProviderConfig,
-): authCtx is Extract<CodexAuthContext, { kind: "pool" }> {
-  return authCtx.kind === "pool" && provider.authMode === "forward" && provider.adapter === "openai-responses";
+): authCtx is Extract<CodexAuthContext, { kind: "pool" | "main-pool" }> {
+  return (authCtx.kind === "pool" || authCtx.kind === "main-pool")
+    && provider.authMode === "forward" && provider.adapter === "openai-responses";
 }
 function codexForwardTerminalOutcomeRecorder(
@@ -399,7 +405,7 @@ async function handleResponses(
     return formatErrorResponse(401, "authentication_error", "Selected Codex account needs reauthentication");
   }
   route.provider = applyCodexAuthContextToProvider(route.provider, authCtx);
-  logCtx.provider = formatCodexProviderForLog(route.providerName, authCtx.kind === "pool" ? authCtx.accountId : null, config);
+  logCtx.provider = formatCodexProviderForLog(route.providerName, codexLogAccountId(authCtx), config);
   // OAuth providers: swap in a fresh access token (auto-refreshed) as the Bearer key, so the
   // existing openai-chat / anthropic adapters authenticate with no change.

package/src/usage-summary.ts CHANGED Viewed

Binary file