opencode-usage 0.5.4 → 0.5.6

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) {
@@ -308,6 +321,120 @@ async function directCodexPing(alias) {
     };
   }
 }
+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) {
+  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;
+    const freshStore = JSON.parse(await Bun.file(storePath).text());
+    const freshAccounts = freshStore.accounts ?? {};
+    const freshAcct = freshAccounts[alias];
+    if (freshAcct) {
+      freshAcct.accessToken = tokens.access_token;
+      if (tokens.refresh_token)
+        freshAcct.refreshToken = tokens.refresh_token;
+      if (tokens.id_token)
+        freshAcct.idToken = tokens.id_token;
+      freshAcct.expiresAt = expiresAt;
+      freshAcct.lastRefresh = new Date().toISOString();
+      freshAcct.accountId = getAccountIdFromJwt(idClaims) ?? getAccountIdFromJwt(accessClaims) ?? freshAcct.accountId;
+      freshAcct.authInvalid = false;
+    }
+    await Bun.write(storePath, JSON.stringify(freshStore, 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);
+    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();
@@ -415,8 +542,8 @@ async function clearStaleMetrics(provider, alias) {
           const rl = acct.rateLimits;
           for (const key of ["fiveHour", "weekly"]) {
             const w2 = rl[key];
-            if (w2?.resetAt && typeof w2.resetAt === "string") {
-              if (new Date(w2.resetAt).getTime() < now) {
+            if (w2?.resetAt && typeof w2.resetAt === "number") {
+              if (w2.resetAt < now) {
                 w2.remaining = w2.limit;
                 delete w2.resetAt;
                 changed = true;
@@ -461,7 +588,7 @@ function reauthCliCommand(provider) {
     throw new Error(`Re-auth not supported for provider: ${provider}`);
   return cmd;
 }
-var isBun4, PROVIDER_SOURCE, bunxQueue, 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();
@@ -562,6 +689,7 @@ var init_plugin_adapters = __esm(() => {
       return { ok: true };
     }
   });
+  REFRESH_COOLDOWN_MS = 24 * 60 * 60 * 1000;
   bunxQueue = new Map;
   registerCommand({
     id: "accounts.ping",
@@ -602,6 +730,8 @@ var init_plugin_adapters = __esm(() => {
           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") {
@@ -4972,10 +5102,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,
@@ -4984,7 +5114,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,
@@ -30311,6 +30441,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";
@@ -30834,6 +30967,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"] });
@@ -30979,4 +31114,4 @@ async function main2() {
 var WATCH_INTERVAL_MS = 5 * 60 * 1000;
 main2().catch(console.error);
 
-//# debugId=E047BEB14D24A3D264756E2164756E21
+//# debugId=79D8BC2A04D06ACC64756E2164756E21