opencode-usage 0.5.3 → 0.5.5

package/dist/commander/services/plugin-adapters.d.ts

@@ -4,4 +4,9 @@
  * Each command is registered via `registerCommand` so the command-runner can
  * execute them as background jobs.
  */
-export {};
+/**
+ * Proactively refresh Codex tokens that haven't been refreshed in 24+ hours.
+ * Keeps tokens fresh so they never silently expire.
+ * Safe to call frequently — skips accounts refreshed recently.
+ */
+export declare function proactiveRefreshCodexTokens(): Promise<void>;

package/dist/index.js

@@ -1,5 +1,15 @@
 #!/usr/bin/env bun
 // @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/commander/services/command-runner.ts
@@ -232,6 +242,9 @@ var init_config_service = __esm(() => {
 
 // src/commander/services/plugin-adapters.ts
 var exports_plugin_adapters = {};
+__export(exports_plugin_adapters, {
+  proactiveRefreshCodexTokens: () => proactiveRefreshCodexTokens
+});
 import { homedir as homedir6, tmpdir } from "os";
 import { join as join8 } from "path";
 function resolveSource2(provider) {
@@ -241,36 +254,215 @@ function resolveSource2(provider) {
   }
   return source;
 }
+async function directCodexPing(alias) {
+  console.log(`[directCodexPing] pinging "${alias}"\u2026`);
+  const STORE_PATHS = [
+    join8(homedir6(), ".config", "opencode", "codex-multi-account-accounts.json"),
+    join8(homedir6(), ".config", "opencode", "codex-multi-accounts.json"),
+    join8(homedir6(), ".config", "oc-codex-multi-account", "accounts.json")
+  ];
+  let store = null;
+  for (const p of STORE_PATHS) {
+    try {
+      store = JSON.parse(await Bun.file(p).text());
+      break;
+    } catch {
+      continue;
+    }
+  }
+  if (!store)
+    return { status: "error", error: "No codex store found" };
+  console.log(`[directCodexPing] found account "${alias}", calling ChatGPT Codex API\u2026`);
+  const accounts = store.accounts ?? {};
+  const account = accounts[alias];
+  if (!account)
+    return { status: "error", error: `Account "${alias}" not found` };
+  const token = account.accessToken;
+  const accountId = account.accountId;
+  if (typeof token !== "string" || !token) {
+    return { status: "error", error: "Missing access token" };
+  }
+  if (typeof accountId !== "string" || !accountId) {
+    return { status: "error", error: "Missing accountId" };
+  }
+  try {
+    const res = await fetch("https://chatgpt.com/backend-api/codex/responses", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "chatgpt-account-id": accountId,
+        "OpenAI-Beta": "responses=experimental",
+        originator: "codex_cli_rs",
+        accept: "text/event-stream"
+      },
+      body: JSON.stringify({
+        model: "gpt-5.3-codex",
+        instructions: "reply ok",
+        input: [{ type: "message", role: "user", content: "hi" }],
+        store: false,
+        stream: true
+      })
+    });
+    if (res.ok || res.status === 429) {
+      console.log(`[directCodexPing] "${alias}" \u2192 ok (HTTP ${res.status})`);
+      return { status: "ok" };
+    }
+    if (res.status === 401 || res.status === 403) {
+      console.log(`[directCodexPing] "${alias}" \u2192 expired (HTTP ${res.status})`);
+      return { status: "expired", error: `HTTP ${res.status}` };
+    }
+    console.log(`[directCodexPing] "${alias}" \u2192 error (HTTP ${res.status})`);
+    return { status: "error", error: `HTTP ${res.status}` };
+  } catch (err) {
+    return {
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = Buffer.from(parts[1], "base64").toString("utf-8");
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+function getExpiryFromJwt(claims) {
+  if (!claims || typeof claims.exp !== "number")
+    return null;
+  return claims.exp * 1000;
+}
+function getAccountIdFromJwt(claims) {
+  const auth = claims?.["https://api.openai.com/auth"];
+  return auth?.chatgpt_account_id ?? null;
+}
+async function refreshSingleCodexToken(alias, account, storePath, store) {
+  const refreshToken = account.refreshToken;
+  if (typeof refreshToken !== "string" || !refreshToken) {
+    console.log(`[proactiveRefresh] ${alias}: no refresh token, skipping`);
+    return false;
+  }
+  try {
+    const t0 = Date.now();
+    const res = await fetch(CODEX_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: CODEX_CLIENT_ID,
+        refresh_token: refreshToken
+      })
+    });
+    if (!res.ok) {
+      console.log(`[proactiveRefresh] ${alias}: refresh failed HTTP ${res.status} in ${Date.now() - t0}ms`);
+      return false;
+    }
+    const tokens = await res.json();
+    const accessClaims = decodeJwtPayload(tokens.access_token);
+    const idClaims = tokens.id_token ? decodeJwtPayload(tokens.id_token) : null;
+    const expiresAt = getExpiryFromJwt(accessClaims) ?? getExpiryFromJwt(idClaims) ?? Date.now() + tokens.expires_in * 1000;
+    account.accessToken = tokens.access_token;
+    if (tokens.refresh_token)
+      account.refreshToken = tokens.refresh_token;
+    if (tokens.id_token)
+      account.idToken = tokens.id_token;
+    account.expiresAt = expiresAt;
+    account.lastRefresh = new Date().toISOString();
+    account.accountId = getAccountIdFromJwt(idClaims) ?? getAccountIdFromJwt(accessClaims) ?? account.accountId;
+    account.authInvalid = false;
+    await Bun.write(storePath, JSON.stringify(store, null, 2));
+    const daysLeft = ((expiresAt - Date.now()) / (24 * 60 * 60 * 1000)).toFixed(1);
+    console.log(`[proactiveRefresh] ${alias}: refreshed in ${Date.now() - t0}ms, new expiry in ${daysLeft}d`);
+    return true;
+  } catch (err) {
+    console.log(`[proactiveRefresh] ${alias}: error \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+async function proactiveRefreshCodexTokens() {
+  const STORE_PATHS = [
+    join8(homedir6(), ".config", "opencode", "codex-multi-account-accounts.json"),
+    join8(homedir6(), ".config", "opencode", "codex-multi-accounts.json"),
+    join8(homedir6(), ".config", "oc-codex-multi-account", "accounts.json")
+  ];
+  let storePath = null;
+  let store = null;
+  for (const p of STORE_PATHS) {
+    try {
+      store = JSON.parse(await Bun.file(p).text());
+      storePath = p;
+      break;
+    } catch {
+      continue;
+    }
+  }
+  if (!store || !storePath)
+    return;
+  const accounts = store.accounts ?? {};
+  const now = Date.now();
+  let refreshed = 0;
+  for (const [alias, account] of Object.entries(accounts)) {
+    const expiresAt = typeof account.expiresAt === "number" ? account.expiresAt : 0;
+    const lastRefresh = typeof account.lastRefresh === "string" ? new Date(account.lastRefresh).getTime() : 0;
+    const timeSinceRefresh = now - lastRefresh;
+    const timeToExpiry = expiresAt - now;
+    if (timeToExpiry <= 0) {
+      console.log(`[proactiveRefresh] ${alias}: token expired, needs reauth`);
+      continue;
+    }
+    if (timeSinceRefresh < REFRESH_COOLDOWN_MS) {
+      const hoursAgo = (timeSinceRefresh / (60 * 60 * 1000)).toFixed(1);
+      console.log(`[proactiveRefresh] ${alias}: refreshed ${hoursAgo}h ago, skipping`);
+      continue;
+    }
+    const hoursStale = (timeSinceRefresh / (60 * 60 * 1000)).toFixed(1);
+    console.log(`[proactiveRefresh] ${alias}: ${hoursStale}h since refresh, refreshing\u2026`);
+    const ok = await refreshSingleCodexToken(alias, account, storePath, store);
+    if (ok)
+      refreshed++;
+  }
+  if (refreshed > 0) {
+    console.log(`[proactiveRefresh] refreshed ${refreshed} codex token(s)`);
+  }
+}
 async function readCredentialFile(filename) {
   const filePath = join8(homedir6(), ".config", "opencode", filename);
   const text = await Bun.file(filePath).text();
   return JSON.parse(text);
 }
 async function spawnPluginCli(command, args, timeoutMs = 15000) {
-  const localBin = `./node_modules/${command}/dist/cli.js`;
-  const useLocal = await Bun.file(localBin).exists();
-  if (!useLocal) {
-    const existing = bunxBarrier.get(command);
-    if (existing) {
-      await existing.catch(() => {
-      });
-      return runPluginCli(command, args, timeoutMs, false);
+  const candidates = [
+    `./node_modules/${command}/dist/cli.js`,
+    join8(homedir6(), ".config", "opencode", "node_modules", command, "dist", "cli.js")
+  ];
+  let localBin = null;
+  for (const c of candidates) {
+    if (await Bun.file(c).exists()) {
+      localBin = c;
+      break;
     }
-    const warmup = runPluginCli(command, args, timeoutMs, false);
-    const barrier = warmup.then(() => {
+  }
+  const useLocal = localBin !== null;
+  if (!useLocal) {
+    const prev = bunxQueue.get(command) ?? Promise.resolve();
+    const run = prev.catch(() => {
+    }).then(() => runPluginCli(command, args, timeoutMs, null));
+    bunxQueue.set(command, run.then(() => {
     }, () => {
-    });
-    bunxBarrier.set(command, barrier);
-    barrier.finally(() => bunxBarrier.delete(command));
-    return warmup;
+    }));
+    return run;
   }
-  return runPluginCli(command, args, timeoutMs, true);
+  return runPluginCli(command, args, timeoutMs, localBin);
 }
-async function runPluginCli(command, args, timeoutMs, useLocal) {
+async function runPluginCli(command, args, timeoutMs, localBin) {
   const t0 = Date.now();
-  const localBin = `./node_modules/${command}/dist/cli.js`;
-  const cmd = useLocal ? ["bun", localBin, ...args] : ["bunx", `${command}@latest`, ...args];
-  const cwd = useLocal ? undefined : join8(tmpdir(), `bunx-${crypto.randomUUID()}`);
+  const cmd = localBin ? ["bun", localBin, ...args] : ["bunx", `${command}@latest`, ...args];
+  const cwd = localBin ? undefined : join8(tmpdir(), `bunx-${crypto.randomUUID()}`);
   if (cwd)
     await Bun.$`mkdir -p ${cwd}`.quiet();
   console.log(`[spawnPluginCli] starting: ${cmd.join(" ")}`);
@@ -391,7 +583,7 @@ function reauthCliCommand(provider) {
     throw new Error(`Re-auth not supported for provider: ${provider}`);
   return cmd;
 }
-var isBun4, PROVIDER_SOURCE, bunxBarrier, REAUTH_PROVIDERS;
+var isBun4, PROVIDER_SOURCE, CODEX_TOKEN_URL = "https://auth.openai.com/oauth/token", CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann", REFRESH_COOLDOWN_MS, bunxQueue, REAUTH_PROVIDERS;
 var init_plugin_adapters = __esm(() => {
   init_command_runner();
   init_config_service();
@@ -492,7 +684,8 @@ var init_plugin_adapters = __esm(() => {
       return { ok: true };
     }
   });
-  bunxBarrier = new Map;
+  REFRESH_COOLDOWN_MS = 24 * 60 * 60 * 1000;
+  bunxQueue = new Map;
   registerCommand({
     id: "accounts.ping",
     timeoutMs: 30000,
@@ -527,19 +720,43 @@ var init_plugin_adapters = __esm(() => {
           };
         }
         case "codex": {
-          ctx.log("info", "Calling oc-codex-multi-account ping\u2026");
-          const result = await spawnPluginCli("oc-codex-multi-account", [
-            "ping",
-            input.alias
-          ]);
-          const status = String(result.status ?? "error");
-          ctx.log("info", `Result: ${status}`);
-          if (status === "ok") {
+          ctx.log("info", `Direct-pinging codex account "${input.alias}"\u2026`);
+          const direct = await directCodexPing(input.alias);
+          ctx.log("info", `Direct ping result: ${direct.status}`);
+          if (direct.status === "ok") {
             await clearStaleMetrics(input.provider, input.alias);
+            proactiveRefreshCodexTokens().catch(() => {
+            });
+            return { status: "ok", message: "pong" };
+          }
+          if (direct.status === "expired") {
+            ctx.log("info", "Token expired \u2014 trying plugin CLI for refresh\u2026");
+            try {
+              const result = await spawnPluginCli("oc-codex-multi-account", [
+                "ping",
+                input.alias
+              ]);
+              const cliStatus = String(result.status ?? "error");
+              ctx.log("info", `Plugin CLI result: ${cliStatus}`);
+              if (cliStatus === "ok") {
+                await clearStaleMetrics(input.provider, input.alias);
+                return { status: "ok", message: "pong (token refreshed)" };
+              }
+              return {
+                status: cliStatus,
+                message: String(result.error ?? "Token refresh failed")
+              };
+            } catch (cliErr) {
+              ctx.log("info", `Plugin CLI failed: ${cliErr instanceof Error ? cliErr.message : String(cliErr)}`);
+              return {
+                status: "error",
+                message: direct.error ?? "Token expired and plugin refresh failed"
+              };
+            }
           }
           return {
-            status,
-            message: status === "ok" ? "pong" : String(result.error ?? "unknown error")
+            status: "error",
+            message: direct.error ?? "unknown error"
           };
         }
         case "antigravity": {
@@ -4880,10 +5097,10 @@ async function createCliRenderer(config = {}) {
   await renderer.setupTerminal();
   return renderer;
 }
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
+    __defProp2(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
@@ -4892,7 +5109,7 @@ var __export = (target, all) => {
 };
 var __require = import.meta.require;
 var exports_src = {};
-__export(exports_src, {
+__export2(exports_src, {
   default: () => src_default,
   Wrap: () => Wrap,
   Unit: () => Unit,
@@ -30219,6 +30436,9 @@ function ensureActionsRegistered() {
 var isBun5 = typeof globalThis.Bun !== "undefined";
 var registered = false;
 
+// src/commander/server.ts
+init_plugin_adapters();
+
 // src/commander/services/app-init-service.ts
 init_command_runner();
 import { homedir as homedir7 } from "os";
@@ -30742,6 +30962,8 @@ async function runCommanderServer(args) {
   });
   const serverUrl = `http://${hostname}:${port}`;
   console.log(`Commander ready at ${serverUrl}`);
+  proactiveRefreshCodexTokens().catch(() => {
+  });
   if (isBun7 && !process.env.NO_OPEN) {
     const cmd = process.platform === "win32" ? ["cmd", "/c", "start", serverUrl] : process.platform === "darwin" ? ["open", serverUrl] : ["xdg-open", serverUrl];
     Bun.spawn(cmd, { stdio: ["ignore", "ignore", "ignore"] });
@@ -30887,4 +31109,4 @@ async function main2() {
 var WATCH_INTERVAL_MS = 5 * 60 * 1000;
 main2().catch(console.error);
 
-//# debugId=2B2A0EC747EBB71864756E2164756E21
+//# debugId=DF21C38AB467E5FE64756E2164756E21