oc-auth-switcher 0.7.2 → 0.8.0

package/README.md

@@ -47,7 +47,7 @@ oc-auth-switcher <command> [options]
 |---------|-------------|
 | `add [name]` | Add a new account via OAuth |
 | `reauth <name>` | Re-authenticate an existing account |
-| `usage [--watch]` | Show utilization dashboard with progress bars |
+| `usage [--watch]` | Show utilization dashboard with progress bars and reset countdowns |
 | `config [options]` | View/modify thresholds |
 | `switch <name>` | Set the active account |
 | `status` | Show current active account and rotation state |

package/dist/cli.js

@@ -48,6 +48,11 @@ var OAUTH_SCOPES = [
 ];
 
 // src/accounts.ts
+function isAccessTokenFresh(account, nowMs = Date.now()) {
+  if (account.expires == null || Number.isNaN(account.expires))
+    return true;
+  return !!account.access && account.expires > nowMs;
+}
 function normalizeAccount(raw) {
   const name = raw.name || "unnamed";
   const access = raw.access || raw.accessToken || "";
@@ -371,7 +376,7 @@ function purgeExpiredCooldowns(state) {
     }
   }
 }
-function findBestAvailable(candidates, state, exclude, modelFamily) {
+function pickByScore(candidates, state, exclude, modelFamily, predicate) {
   let best = null;
   let bestScore = Infinity;
   for (const acct of candidates) {
@@ -379,22 +384,7 @@ function findBestAvailable(candidates, state, exclude, modelFamily) {
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    if (!isOverThreshold(state.usage[acct.name], state, modelFamily)) {
-      const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
-      if (!best || score < bestScore) {
-        bestScore = score;
-        best = acct;
-      }
-    }
-  }
-  if (best)
-    return best;
-  best = null;
-  bestScore = Infinity;
-  for (const acct of candidates) {
-    if (exclude.has(acct.name))
-      continue;
-    if (isTemporarilyUnavailable(state, acct.name))
+    if (!predicate(acct))
       continue;
     const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
     if (!best || score < bestScore) {
@@ -404,6 +394,12 @@ function findBestAvailable(candidates, state, exclude, modelFamily) {
   }
   return best;
 }
+function findBestAvailable(candidates, state, exclude, modelFamily) {
+  const underThreshold = (acct) => !isOverThreshold(state.usage[acct.name], state, modelFamily);
+  const fresh = (acct) => isAccessTokenFresh(acct);
+  const stale = (acct) => !isAccessTokenFresh(acct);
+  return pickByScore(candidates, state, exclude, modelFamily, (acct) => underThreshold(acct) && fresh(acct)) ?? pickByScore(candidates, state, exclude, modelFamily, (acct) => underThreshold(acct) && stale(acct)) ?? pickByScore(candidates, state, exclude, modelFamily, fresh) ?? pickByScore(candidates, state, exclude, modelFamily, stale);
+}
 function selectAccount(accounts, state, model) {
   if (accounts.length === 0) {
     throw new Error("No accounts available");
@@ -692,6 +688,11 @@ function progressBar(value, threshold, width = 30) {
   const label = `${(value * 100).toFixed(1)}%`;
   return `${bar} ${color}${label}${RESET}`;
 }
+function resetSuffix(metric, now) {
+  if (!metric.reset || metric.reset * 1000 <= now)
+    return "";
+  return `  ${DIM}resets ${formatRelativeDuration(metric.reset * 1000, now)}${RESET}`;
+}
 function tryCopy(cmd, args, text) {
   return new Promise((resolve) => {
     try {
@@ -886,10 +887,10 @@ ${BOLD}${CYAN}=== Auth Switcher Usage Dashboard ===${RESET}
       const tag = isActive ? `${GREEN} [ACTIVE]${RESET}` : isCooling ? `${RED} [COOLDOWN]${RESET}` : "";
       console.log(`  ${BOLD}${account.name}${RESET}${tag}`);
       if (usage) {
-        console.log(`    5h session:  ${progressBar(usage.session5h.utilization, thresholds.session5h)}`);
-        console.log(`    7d weekly:   ${progressBar(usage.weekly7d.utilization, thresholds.weekly7d)}`);
-        console.log(`    7d sonnet:   ${progressBar(usage.weekly7dSonnet.utilization, thresholds.weekly7dSonnet)}`);
-        console.log(`    7d fable:    ${progressBar(usage.weekly7dFable.utilization, thresholds.weekly7dFable)}`);
+        console.log(`    5h session:  ${progressBar(usage.session5h.utilization, thresholds.session5h)}${resetSuffix(usage.session5h, now)}`);
+        console.log(`    7d weekly:   ${progressBar(usage.weekly7d.utilization, thresholds.weekly7d)}${resetSuffix(usage.weekly7d, now)}`);
+        console.log(`    7d sonnet:   ${progressBar(usage.weekly7dSonnet.utilization, thresholds.weekly7dSonnet)}${resetSuffix(usage.weekly7dSonnet, now)}`);
+        console.log(`    7d fable:    ${progressBar(usage.weekly7dFable.utilization, thresholds.weekly7dFable)}${resetSuffix(usage.weekly7dFable, now)}`);
         const rejection = deriveAccountHealth(account, usage, thresholds, state.authFailures[account.name], now).reasons.find((reason) => reason.kind === "rejection");
         if (rejection) {
           const reset = rejection.reset ? ` \u2014 resets ${formatResetTime(rejection.reset, now)}` : "";

package/dist/index.js

@@ -433,6 +433,11 @@ function quotaWindowScope(prefix) {
 }
 
 // src/accounts.ts
+function isAccessTokenFresh(account, nowMs = Date.now()) {
+  if (account.expires == null || Number.isNaN(account.expires))
+    return true;
+  return !!account.access && account.expires > nowMs;
+}
 function normalizeAccount(raw) {
   const name = raw.name || "unnamed";
   const access = raw.access || raw.accessToken || "";
@@ -832,7 +837,7 @@ function purgeExpiredCooldowns(state) {
     }
   }
 }
-function findBestAvailable(candidates, state, exclude, modelFamily) {
+function pickByScore(candidates, state, exclude, modelFamily, predicate) {
   let best = null;
   let bestScore = Infinity;
   for (const acct of candidates) {
@@ -840,22 +845,7 @@ function findBestAvailable(candidates, state, exclude, modelFamily) {
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    if (!isOverThreshold(state.usage[acct.name], state, modelFamily)) {
-      const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
-      if (!best || score < bestScore) {
-        bestScore = score;
-        best = acct;
-      }
-    }
-  }
-  if (best)
-    return best;
-  best = null;
-  bestScore = Infinity;
-  for (const acct of candidates) {
-    if (exclude.has(acct.name))
-      continue;
-    if (isTemporarilyUnavailable(state, acct.name))
+    if (!predicate(acct))
       continue;
     const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
     if (!best || score < bestScore) {
@@ -865,6 +855,12 @@ function findBestAvailable(candidates, state, exclude, modelFamily) {
   }
   return best;
 }
+function findBestAvailable(candidates, state, exclude, modelFamily) {
+  const underThreshold = (acct) => !isOverThreshold(state.usage[acct.name], state, modelFamily);
+  const fresh = (acct) => isAccessTokenFresh(acct);
+  const stale = (acct) => !isAccessTokenFresh(acct);
+  return pickByScore(candidates, state, exclude, modelFamily, (acct) => underThreshold(acct) && fresh(acct)) ?? pickByScore(candidates, state, exclude, modelFamily, (acct) => underThreshold(acct) && stale(acct)) ?? pickByScore(candidates, state, exclude, modelFamily, fresh) ?? pickByScore(candidates, state, exclude, modelFamily, stale);
+}
 function selectAccount(accounts, state, model) {
   if (accounts.length === 0) {
     throw new Error("No accounts available");
@@ -906,6 +902,96 @@ function clearAuthFailure(state, accountName) {
   delete state.authFailures[accountName];
 }
 
+// src/retry.ts
+var RATE_LIMIT_STATUSES = new Set([429]);
+function isReplayableBody(body) {
+  return body == null || typeof body === "string";
+}
+function isRateLimitStatus(status) {
+  return RATE_LIMIT_STATUSES.has(status);
+}
+function finalizeRequestAccounting(state, accountName, response) {
+  updateUsageFromHeaders(state, accountName, response.headers);
+  if (response.ok) {
+    clearAuthFailure(state, accountName);
+    state.requestCount = (state.requestCount || 0) + 1;
+  }
+}
+async function retryAcrossAccounts(initial, account, options) {
+  const { accounts, state, model, bodyReplayable, attemptedAccounts, send, log } = options;
+  attemptedAccounts.add(account.name);
+  let response = initial;
+  let current = account;
+  let authRetryUsed = false;
+  const maxFetches = Math.max(accounts.length, 1) + 1;
+  let fetches = 1;
+  while (fetches < maxFetches) {
+    if (!bodyReplayable)
+      break;
+    if (isRateLimitStatus(response.status)) {
+      updateUsageFromHeaders(state, current.name, response.headers);
+      attemptedAccounts.add(current.name);
+      const available = accounts.filter((candidate) => !attemptedAccounts.has(candidate.name));
+      if (available.length === 0)
+        break;
+      const next = selectAccount(available, state, model).account;
+      if (next.name === current.name || attemptedAccounts.has(next.name))
+        break;
+      await log(`${current.name} rate-limited (HTTP ${response.status}) — retrying on ${next.name}`);
+      const prepared = await ensureFreshToken(next, state);
+      if (!prepared) {
+        attemptedAccounts.add(next.name);
+        continue;
+      }
+      current = prepared;
+      response = await send(current);
+      fetches += 1;
+      attemptedAccounts.add(current.name);
+      continue;
+    }
+    if ((response.status === 401 || response.status === 403) && !authRetryUsed) {
+      const errorBody = await response.clone().text().catch(() => "");
+      const isScopeError = errorBody.includes("scope") || errorBody.includes("unauthorized") || errorBody.includes("invalid");
+      if (!isScopeError)
+        break;
+      markAuthFailure(state, current.name);
+      attemptedAccounts.add(current.name);
+      authRetryUsed = true;
+      const available = accounts.filter((candidate) => !attemptedAccounts.has(candidate.name) && (!state.authFailures[candidate.name] || state.authFailures[candidate.name] <= Date.now()));
+      if (available.length === 0)
+        break;
+      const next = selectAccount(available, state, model).account;
+      if (next.name === current.name)
+        break;
+      await log(`${current.name} auth failure (HTTP ${response.status}) — retrying on ${next.name}`);
+      const prepared = await ensureFreshToken(next, state);
+      if (!prepared)
+        break;
+      current = prepared;
+      response = await send(current);
+      fetches += 1;
+      attemptedAccounts.add(current.name);
+      continue;
+    }
+    break;
+  }
+  return { response, account: current };
+}
+async function ensureFreshToken(account, state) {
+  if (isAccessTokenFresh(account))
+    return account;
+  const result = await refreshAccountToken(account.refresh);
+  if (result.ok && result.access && result.refresh && result.expires) {
+    account.access = result.access;
+    account.refresh = result.refresh;
+    account.expires = result.expires;
+    await updateAccountTokens(account.name, result.access, result.refresh, result.expires);
+    return account;
+  }
+  markAuthFailure(state, account.name);
+  return null;
+}
+
 // src/index.ts
 function selectionSnapshot(state) {
   return {
@@ -1014,7 +1100,7 @@ var AuthSwitcherPlugin = async ({ client }) => {
             const attemptedAccounts = new Set;
             while (true) {
               attemptedAccounts.add(account.name);
-              if (!account.access || account.expires <= Date.now()) {
+              if (!isAccessTokenFresh(account)) {
                 const result = await refreshAccountToken(account.refresh);
                 if (result.ok && result.access && result.refresh && result.expires) {
                   account.access = result.access;
@@ -1043,6 +1129,19 @@ var AuthSwitcherPlugin = async ({ client }) => {
               body = rewriteRequestBody(body);
             }
             const rewritten = rewriteUrl(input);
+            const bodyReplayable = isReplayableBody(init?.body);
+            const sendWithAccount = async (acct) => {
+              const headers = mergeHeaders(input, init);
+              setOAuthHeaders(headers, acct.access);
+              return fetch(rewritten.input, {
+                ...init,
+                body,
+                headers,
+                ...isInsecure() && {
+                  tls: { rejectUnauthorized: false }
+                }
+              });
+            };
             const response = await fetch(rewritten.input, {
               ...init,
               body,
@@ -1051,48 +1150,29 @@ var AuthSwitcherPlugin = async ({ client }) => {
                 tls: { rejectUnauthorized: false }
               }
             });
-            if ((response.status === 401 || response.status === 403) && !attemptedAccounts.has("__retried__")) {
-              const errorBody = await response.clone().text().catch(() => "");
-              const isScopeError = errorBody.includes("scope") || errorBody.includes("unauthorized") || errorBody.includes("invalid");
-              if (isScopeError) {
-                markAuthFailure(state, account.name);
-                const available = accounts.filter((candidate) => !attemptedAccounts.has(candidate.name) && (!state.authFailures[candidate.name] || state.authFailures[candidate.name] <= Date.now()));
-                const next = available.length > 0 ? selectAccount(available, state, model).account : undefined;
-                if (next) {
-                  attemptedAccounts.add("__retried__");
-                  account = next;
-                  state.currentAccount = next.name;
-                  if (!next.access || next.expires <= Date.now()) {
-                    const result = await refreshAccountToken(next.refresh);
-                    if (result.ok && result.access && result.refresh && result.expires) {
-                      next.access = result.access;
-                      next.refresh = result.refresh;
-                      next.expires = result.expires;
-                      await updateAccountTokens(next.name, result.access, result.refresh, result.expires);
-                    }
+            const retried = await retryAcrossAccounts(response, account, {
+              accounts,
+              state,
+              model,
+              bodyReplayable,
+              attemptedAccounts,
+              send: sendWithAccount,
+              log: async (message) => {
+                await client.app.log({
+                  body: {
+                    service: "oc-auth-switcher",
+                    level: "info",
+                    message
                   }
-                  const retryHeaders = mergeHeaders(input, init);
-                  setOAuthHeaders(retryHeaders, next.access);
-                  const retryResponse = await fetch(rewritten.input, {
-                    ...init,
-                    body,
-                    headers: retryHeaders,
-                    ...isInsecure() && {
-                      tls: { rejectUnauthorized: false }
-                    }
-                  });
-                  updateUsageFromHeaders(state, next.name, retryResponse.headers);
-                  clearAuthFailure(state, next.name);
-                  await saveRequestState(state, initiallyLoadedSelection);
-                  return createStrippedStream(retryResponse);
-                }
+                }).catch(() => {});
               }
-            }
-            updateUsageFromHeaders(state, account.name, response.headers);
-            clearAuthFailure(state, account.name);
-            state.requestCount = (state.requestCount || 0) + 1;
+            });
+            account = retried.account;
+            state.currentAccount = account.name;
+            const finalResponse = retried.response;
+            finalizeRequestAccounting(state, account.name, finalResponse);
             await saveRequestState(state, initiallyLoadedSelection);
-            return createStrippedStream(response);
+            return createStrippedStream(finalResponse);
           }
         };
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-auth-switcher",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",