oc-auth-switcher 0.7.1 → 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

@@ -21,6 +21,14 @@ var METRIC_MODEL_FAMILY = {
   weekly7dSonnet: "sonnet",
   weekly7dFable: "fable"
 };
+var UNIFIED_RATE_LIMIT_PREFIX = "anthropic-ratelimit-unified-";
+var QUOTA_WINDOW_SCOPE_PATTERN = /^\d+[hmd](?:_[a-z0-9.\-]+)?$/i;
+function quotaWindowScope(prefix) {
+  if (!prefix)
+    return;
+  const scope = prefix.toLowerCase().startsWith(UNIFIED_RATE_LIMIT_PREFIX) ? prefix.slice(UNIFIED_RATE_LIMIT_PREFIX.length) : prefix;
+  return QUOTA_WINDOW_SCOPE_PATTERN.test(scope) ? scope : undefined;
+}
 
 // node_modules/@ex-machina/opencode-anthropic-auth/dist/constants.js
 var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
@@ -40,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 || "";
@@ -217,17 +230,20 @@ function normalizeState(raw) {
     weekly7dSonnet: threshold.weekly7dSonnet ?? DEFAULT_THRESHOLD,
     weekly7dFable: threshold.weekly7dFable ?? DEFAULT_THRESHOLD
   } : threshold ?? defaults.config.threshold;
-  const usage = Object.fromEntries(Object.entries(raw.usage ?? {}).map(([name, accountUsage]) => [
-    name,
-    {
-      session5h: { ...EMPTY_METRIC, ...accountUsage?.session5h },
-      weekly7d: { ...EMPTY_METRIC, ...accountUsage?.weekly7d },
-      weekly7dSonnet: { ...EMPTY_METRIC, ...accountUsage?.weekly7dSonnet },
-      weekly7dFable: { ...EMPTY_METRIC, ...accountUsage?.weekly7dFable },
-      rejected: { ...EMPTY_METRIC, ...accountUsage?.rejected },
-      timestamp: accountUsage?.timestamp
-    }
-  ]));
+  const usage = Object.fromEntries(Object.entries(raw.usage ?? {}).map(([name, accountUsage]) => {
+    const rejected = { ...EMPTY_METRIC, ...accountUsage?.rejected };
+    return [
+      name,
+      {
+        session5h: { ...EMPTY_METRIC, ...accountUsage?.session5h },
+        weekly7d: { ...EMPTY_METRIC, ...accountUsage?.weekly7d },
+        weekly7dSonnet: { ...EMPTY_METRIC, ...accountUsage?.weekly7dSonnet },
+        weekly7dFable: { ...EMPTY_METRIC, ...accountUsage?.weekly7dFable },
+        rejected: rejected.status?.toLowerCase() === "rejected" && !quotaWindowScope(rejected.prefix) ? { ...EMPTY_METRIC } : rejected,
+        timestamp: accountUsage?.timestamp
+      }
+    ];
+  }));
   return {
     currentAccount: raw.currentAccount ?? defaults.currentAccount,
     requestCount: raw.requestCount ?? defaults.requestCount,
@@ -238,8 +254,8 @@ function normalizeState(raw) {
     authFailures: raw.authFailures ?? defaults.authFailures
   };
 }
-function loadState() {
-  return normalizeState(safeReadJSON(STATE_FILE, {}));
+function loadState(stateFile = STATE_FILE) {
+  return normalizeState(safeReadJSON(stateFile, {}));
 }
 function saveState(state) {
   return safeWriteJSON(STATE_FILE, state);
@@ -360,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) {
@@ -368,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) {
@@ -393,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");
@@ -461,6 +468,10 @@ function formatRelativeDuration(targetMs, nowMs = Date.now()) {
     parts.push(`${Math.max(1, Math.round(remaining))}s`);
   return difference >= 0 ? `in ${parts.join(" ")}` : `${parts.join(" ")} ago`;
 }
+function formatResetTime(reset, nowMs = Date.now()) {
+  const resetMs = reset * 1000;
+  return `${new Date(resetMs).toLocaleString()} (${formatRelativeDuration(resetMs, nowMs)})`;
+}
 function displayRejectionPrefix(prefix) {
   return prefix?.replace(/^anthropic-ratelimit-unified-/i, "");
 }
@@ -677,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 {
@@ -865,17 +881,20 @@ ${BOLD}${CYAN}=== Auth Switcher Usage Dashboard ===${RESET}
     }
     for (const account of data.accounts) {
       const usage = state.usage[account.name];
+      const now = Date.now();
       const isActive = account.name === state.currentAccount;
-      const isCooling = !!state.authFailures[account.name] && state.authFailures[account.name] > Date.now();
+      const isCooling = !!state.authFailures[account.name] && state.authFailures[account.name] > now;
       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)}`);
-        if (usage.rejected.status === "rejected") {
-          console.log(`    ${RED}Rate limit status: REJECTED${RESET}`);
+        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)}` : "";
+          console.log(`    ${RED}Rate limit status: ${rejection.message}${reset}${RESET}`);
         }
         if (usage.timestamp) {
           console.log(`    ${DIM}Last updated: ${usage.timestamp}${RESET}`);
@@ -1067,8 +1086,7 @@ ${BOLD}${CYAN}=== Auth Switcher Status ===${RESET}
         console.log(`    ${RED}Reason: ${reason.message}${RESET}`);
       }
       if (health.earliestReset) {
-        const resetMs = health.earliestReset * 1000;
-        console.log(`    Reset: ${new Date(resetMs).toLocaleString()} (${formatRelativeDuration(resetMs, now)})`);
+        console.log(`    Reset: ${formatResetTime(health.earliestReset, now)}`);
       }
       const tokenColor = health.reasons.some((reason) => reason.kind === "token") ? RED : DIM;
       console.log(`    ${tokenColor}Token: ${health.tokenExpiry}${RESET}`);

package/dist/index.js

@@ -423,8 +423,21 @@ var METRIC_MODEL_FAMILY = {
   weekly7dSonnet: "sonnet",
   weekly7dFable: "fable"
 };
+var UNIFIED_RATE_LIMIT_PREFIX = "anthropic-ratelimit-unified-";
+var QUOTA_WINDOW_SCOPE_PATTERN = /^\d+[hmd](?:_[a-z0-9.\-]+)?$/i;
+function quotaWindowScope(prefix) {
+  if (!prefix)
+    return;
+  const scope = prefix.toLowerCase().startsWith(UNIFIED_RATE_LIMIT_PREFIX) ? prefix.slice(UNIFIED_RATE_LIMIT_PREFIX.length) : prefix;
+  return QUOTA_WINDOW_SCOPE_PATTERN.test(scope) ? scope : undefined;
+}
 
 // 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 || "";
@@ -585,17 +598,20 @@ function normalizeState(raw) {
     weekly7dSonnet: threshold.weekly7dSonnet ?? DEFAULT_THRESHOLD,
     weekly7dFable: threshold.weekly7dFable ?? DEFAULT_THRESHOLD
   } : threshold ?? defaults.config.threshold;
-  const usage = Object.fromEntries(Object.entries(raw.usage ?? {}).map(([name, accountUsage]) => [
-    name,
-    {
-      session5h: { ...EMPTY_METRIC, ...accountUsage?.session5h },
-      weekly7d: { ...EMPTY_METRIC, ...accountUsage?.weekly7d },
-      weekly7dSonnet: { ...EMPTY_METRIC, ...accountUsage?.weekly7dSonnet },
-      weekly7dFable: { ...EMPTY_METRIC, ...accountUsage?.weekly7dFable },
-      rejected: { ...EMPTY_METRIC, ...accountUsage?.rejected },
-      timestamp: accountUsage?.timestamp
-    }
-  ]));
+  const usage = Object.fromEntries(Object.entries(raw.usage ?? {}).map(([name, accountUsage]) => {
+    const rejected = { ...EMPTY_METRIC, ...accountUsage?.rejected };
+    return [
+      name,
+      {
+        session5h: { ...EMPTY_METRIC, ...accountUsage?.session5h },
+        weekly7d: { ...EMPTY_METRIC, ...accountUsage?.weekly7d },
+        weekly7dSonnet: { ...EMPTY_METRIC, ...accountUsage?.weekly7dSonnet },
+        weekly7dFable: { ...EMPTY_METRIC, ...accountUsage?.weekly7dFable },
+        rejected: rejected.status?.toLowerCase() === "rejected" && !quotaWindowScope(rejected.prefix) ? { ...EMPTY_METRIC } : rejected,
+        timestamp: accountUsage?.timestamp
+      }
+    ];
+  }));
   return {
     currentAccount: raw.currentAccount ?? defaults.currentAccount,
     requestCount: raw.requestCount ?? defaults.requestCount,
@@ -606,8 +622,8 @@ function normalizeState(raw) {
     authFailures: raw.authFailures ?? defaults.authFailures
   };
 }
-function loadState() {
-  return normalizeState(safeReadJSON(STATE_FILE, {}));
+function loadState(stateFile = STATE_FILE) {
+  return normalizeState(safeReadJSON(stateFile, {}));
 }
 function saveState(state) {
   return safeWriteJSON(STATE_FILE, state);
@@ -727,7 +743,8 @@ function updateUsageFromHeaders(state, accountName, headers) {
   }
   for (const [headerName, headerValue] of headers.entries()) {
     const normalizedName = headerName.toLowerCase();
-    if (!/^anthropic-ratelimit-unified-(?:.*-)?status$/.test(normalizedName) || headerValue.toLowerCase() !== "rejected") {
+    const statusMatch = normalizedName.match(/^anthropic-ratelimit-unified-(.+)-status$/);
+    if (!statusMatch || !quotaWindowScope(statusMatch[1]) || headerValue.toLowerCase() !== "rejected") {
       continue;
     }
     const prefix = normalizedName.slice(0, -"-status".length);
@@ -820,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) {
@@ -828,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) {
@@ -853,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");
@@ -894,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 {
@@ -1002,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;
@@ -1031,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,
@@ -1039,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.1",
+  "version": "0.8.0",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",