oc-auth-switcher 0.8.0 → 0.9.1

package/dist/cli.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env bun
 // @bun
 
+// src/cli.ts
+import { createHash } from "crypto";
+
 // src/accounts.ts
 import fs from "fs";
 import path2 from "path";
@@ -203,11 +206,12 @@ async function refreshAccountToken(refreshTokenValue) {
 
 // src/state.ts
 var EMPTY_METRIC = { utilization: 0, reset: 0, status: "" };
+var EMPTY_MODEL_METRIC = { utilization: null, reset: 0, status: "" };
 var EMPTY_USAGE = {
   session5h: { ...EMPTY_METRIC },
   weekly7d: { ...EMPTY_METRIC },
-  weekly7dSonnet: { ...EMPTY_METRIC },
-  weekly7dFable: { ...EMPTY_METRIC },
+  weekly7dSonnet: { ...EMPTY_MODEL_METRIC },
+  weekly7dFable: { ...EMPTY_MODEL_METRIC },
   rejected: { ...EMPTY_METRIC }
 };
 function defaultState() {
@@ -260,6 +264,20 @@ function loadState(stateFile = STATE_FILE) {
 function saveState(state) {
   return safeWriteJSON(STATE_FILE, state);
 }
+async function saveStateMerged(state, accountsToMerge) {
+  const onDisk = loadState();
+  for (const name of accountsToMerge) {
+    if (state.usage[name]) {
+      onDisk.usage[name] = state.usage[name];
+    }
+    if (state.authFailures[name] !== undefined) {
+      onDisk.authFailures[name] = state.authFailures[name];
+    } else {
+      delete onDisk.authFailures[name];
+    }
+  }
+  await safeWriteJSON(STATE_FILE, onDisk);
+}
 function getThresholds(config) {
   if (typeof config.threshold === "number") {
     return {
@@ -312,6 +330,178 @@ function ensureAccountsInState(state, accountNames) {
     }
   }
 }
+function updateUsageFromHeaders(state, accountName, headers) {
+  if (!state.usage[accountName]) {
+    state.usage[accountName] = {
+      session5h: { ...EMPTY_METRIC },
+      weekly7d: { ...EMPTY_METRIC },
+      weekly7dSonnet: { ...EMPTY_METRIC },
+      weekly7dFable: { ...EMPTY_METRIC },
+      rejected: { ...EMPTY_METRIC }
+    };
+  }
+  const usage = state.usage[accountName];
+  let updated = false;
+  const metricFamilies = [
+    {
+      key: "session5h",
+      prefix: "anthropic-ratelimit-unified-5h"
+    },
+    {
+      key: "weekly7d",
+      prefix: "anthropic-ratelimit-unified-7d"
+    },
+    {
+      key: "weekly7dSonnet",
+      prefix: "anthropic-ratelimit-unified-7d_sonnet"
+    },
+    {
+      key: "weekly7dFable",
+      prefix: "anthropic-ratelimit-unified-7d_fable"
+    }
+  ];
+  for (const { key, prefix } of metricFamilies) {
+    const utilHeader = headers.get(`${prefix}-utilization`);
+    const resetHeader = headers.get(`${prefix}-reset`);
+    const statusHeader = headers.get(`${prefix}-status`);
+    if (utilHeader !== null || resetHeader !== null || statusHeader !== null) {
+      if (utilHeader !== null) {
+        const val = parseFloat(utilHeader);
+        if (!isNaN(val)) {
+          usage[key].utilization = val;
+          updated = true;
+        }
+      }
+      if (resetHeader !== null) {
+        const val = Number(resetHeader);
+        if (!isNaN(val)) {
+          usage[key].reset = val;
+          updated = true;
+        } else {
+          const parsed = Date.parse(resetHeader);
+          if (!isNaN(parsed)) {
+            usage[key].reset = parsed / 1000;
+            updated = true;
+          }
+        }
+      }
+      if (statusHeader !== null) {
+        usage[key].status = statusHeader;
+        updated = true;
+      }
+    }
+  }
+  for (const [headerName, headerValue] of headers.entries()) {
+    const normalizedName = headerName.toLowerCase();
+    const statusMatch = normalizedName.match(/^anthropic-ratelimit-unified-(.+)-status$/);
+    if (!statusMatch || !quotaWindowScope(statusMatch[1]) || headerValue.toLowerCase() !== "rejected") {
+      continue;
+    }
+    const prefix = normalizedName.slice(0, -"-status".length);
+    const resetHeader = headers.get(`${prefix}-reset`) ?? headers.get("anthropic-ratelimit-unified-reset");
+    let reset = resetHeader ? Number(resetHeader) : NaN;
+    if (isNaN(reset) && resetHeader) {
+      const parsed = Date.parse(resetHeader);
+      if (!isNaN(parsed))
+        reset = parsed / 1000;
+    }
+    if (!Number.isFinite(reset) || reset <= 0) {
+      const retryAfterHeader = headers.get("retry-after");
+      const retryAfter = retryAfterHeader === null ? NaN : Number(retryAfterHeader);
+      reset = Date.now() / 1000 + (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : REJECTION_FALLBACK_SECONDS);
+    }
+    usage.rejected = {
+      utilization: 1,
+      reset: Math.max(usage.rejected.reset, reset),
+      status: "rejected",
+      prefix
+    };
+    updated = true;
+  }
+  if (updated) {
+    usage.timestamp = new Date().toISOString();
+  }
+  return updated;
+}
+async function fetchOAuthUsage(accessToken) {
+  try {
+    const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${accessToken}`,
+        "anthropic-version": "2023-06-01",
+        "user-agent": "claude-cli/2.1.87 (external, cli)"
+      }
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return { ok: false, error: `HTTP ${response.status}: ${body.slice(0, 100)}` };
+    }
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function mapModelDisplayNameToField(displayName) {
+  const normalized = displayName.toLowerCase();
+  if (normalized === "fable")
+    return "weekly7dFable";
+  if (normalized === "sonnet")
+    return "weekly7dSonnet";
+  return;
+}
+function isoToEpochSeconds(iso) {
+  if (!iso)
+    return 0;
+  const parsed = Date.parse(iso);
+  return isNaN(parsed) ? 0 : parsed / 1000;
+}
+function percentToFraction(percent) {
+  return percent / 100;
+}
+function updateUsageFromOAuthEndpoint(state, accountName, response) {
+  if (!state.usage[accountName]) {
+    state.usage[accountName] = {
+      session5h: { ...EMPTY_METRIC },
+      weekly7d: { ...EMPTY_METRIC },
+      weekly7dSonnet: { ...EMPTY_MODEL_METRIC },
+      weekly7dFable: { ...EMPTY_MODEL_METRIC },
+      rejected: { ...EMPTY_METRIC }
+    };
+  }
+  const usage = state.usage[accountName];
+  let updated = false;
+  const warnings = [];
+  const limits = response.limits ?? [];
+  for (const limit of limits) {
+    if (limit.kind !== "weekly_scoped")
+      continue;
+    if (!limit.scope?.model?.display_name)
+      continue;
+    const displayName = limit.scope.model.display_name;
+    const field = mapModelDisplayNameToField(displayName);
+    if (!field) {
+      warnings.push(`unknown model "${displayName}" in weekly_scoped limit`);
+      continue;
+    }
+    const utilization = percentToFraction(limit.percent);
+    const reset = isoToEpochSeconds(limit.resets_at);
+    usage[field] = {
+      utilization,
+      reset,
+      status: limit.severity || ""
+    };
+    updated = true;
+  }
+  if (updated) {
+    usage.timestamp = new Date().toISOString();
+  }
+  return { updated, warnings };
+}
 
 // src/rotation.ts
 function isTemporarilyUnavailable(state, accountName) {
@@ -364,7 +554,7 @@ function isRejectionRelevant(prefix, modelFamily) {
 function metricEntries(usage, thresholds, modelFamily) {
   return Object.keys(METRIC_MODEL_FAMILY).filter((key) => isMetricRelevant(key, modelFamily)).map((key) => ({
     name: key,
-    util: usage[key].utilization,
+    util: usage[key].utilization ?? 0,
     threshold: thresholds[key]
   }));
 }
@@ -434,6 +624,9 @@ function selectAccount(accounts, state, model) {
   }
   return { account: current, switched: false };
 }
+function markAuthFailure(state, accountName) {
+  state.authFailures[accountName] = Date.now() + AUTH_FAILURE_COOLDOWN;
+}
 function clearAuthFailure(state, accountName) {
   delete state.authFailures[accountName];
 }
@@ -493,7 +686,7 @@ function tokenExpiryDescription(account, nowMs) {
 function deriveAccountHealth(account, usage, thresholds, cooldownUntil, nowMs = Date.now()) {
   const availability = Object.fromEntries(MODEL_FAMILIES.map((family) => [family, true]));
   const reasons = [];
-  const metrics = usage ? Object.keys(METRIC_MODEL_FAMILY).filter((metric) => thresholds[metric] > 0).map((metric) => ({
+  const metrics = usage ? Object.keys(METRIC_MODEL_FAMILY).filter((metric) => thresholds[metric] > 0).filter((metric) => usage[metric].utilization !== null).map((metric) => ({
     metric,
     utilization: usage[metric].utilization,
     threshold: thresholds[metric],
@@ -688,6 +881,13 @@ function progressBar(value, threshold, width = 30) {
   const label = `${(value * 100).toFixed(1)}%`;
   return `${bar} ${color}${label}${RESET}`;
 }
+function formatMetric(value, threshold) {
+  if (value === null) {
+    const emptyBar = DIM + "\u2591".repeat(30) + RESET;
+    return `${emptyBar} ${DIM}n/a${RESET}`;
+  }
+  return progressBar(value, threshold);
+}
 function resetSuffix(metric, now) {
   if (!metric.reset || metric.reset * 1000 <= now)
     return "";
@@ -854,6 +1054,145 @@ async function refreshExpiredAccounts(data, state) {
     }
   }
 }
+var PROBE_CONCURRENCY = 3;
+var PROBE_API_URL = "https://api.anthropic.com/v1/messages?beta=true";
+var PROBE_MODELS = [
+  "claude-sonnet-4-5",
+  "claude-opus-4-5"
+];
+var PROBE_BETA_HEADERS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
+var PROBE_USER_AGENT = "claude-cli/2.1.87 (external, cli)";
+var PROBE_VERSION = "2023-06-01";
+var CLAUDE_CODE_VERSION = "2.1.87";
+var CLAUDE_CODE_IDENTITY = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+var CCH_SALT = "59cf53e54c78";
+var CCH_POSITIONS = [4, 7, 20];
+function computeCCH(messageText) {
+  return createHash("sha256").update(messageText).digest("hex").slice(0, 5);
+}
+function computeVersionSuffix(messageText) {
+  const chars = CCH_POSITIONS.map((i) => messageText[i] || "0").join("");
+  return createHash("sha256").update(`${CCH_SALT}${chars}${CLAUDE_CODE_VERSION}`).digest("hex").slice(0, 3);
+}
+function buildBillingHeader(messageText) {
+  const suffix = computeVersionSuffix(messageText);
+  const cch = computeCCH(messageText);
+  return "x-anthropic-billing-header: " + `cc_version=${CLAUDE_CODE_VERSION}.${suffix}; ` + `cc_entrypoint=sdk-cli; ` + `cch=${cch};`;
+}
+async function fetchAndApplyOAuthUsage(account, state, result) {
+  const oauthResult = await fetchOAuthUsage(account.access);
+  if (!oauthResult.ok) {
+    result.oauthUsageWarnings = [`oauth usage: ${oauthResult.error}`];
+    return;
+  }
+  const { warnings } = updateUsageFromOAuthEndpoint(state, account.name, oauthResult.data);
+  if (warnings.length > 0) {
+    result.oauthUsageWarnings = warnings;
+  }
+}
+async function probeAccount(account, state) {
+  const result = { name: account.name, success: false };
+  if (!account.access || account.expires <= Date.now()) {
+    if (!account.refresh) {
+      result.error = "missing refresh token";
+      return result;
+    }
+    const refreshResult = await refreshAccountToken(account.refresh);
+    if (!refreshResult.ok || !refreshResult.access) {
+      result.error = `token refresh failed: ${refreshResult.error || "unknown"}`;
+      markAuthFailure(state, account.name);
+      return result;
+    }
+    account.access = refreshResult.access;
+    account.refresh = refreshResult.refresh;
+    account.expires = refreshResult.expires;
+    await updateAccountTokens(account.name, refreshResult.access, refreshResult.refresh, refreshResult.expires);
+    clearAuthFailure(state, account.name);
+  }
+  let lastStatus = 0;
+  let lastBody = "";
+  for (const model of PROBE_MODELS) {
+    try {
+      const messageText = ".";
+      const billingHeader = buildBillingHeader(messageText);
+      const response = await fetch(PROBE_API_URL, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${account.access}`,
+          "anthropic-beta": PROBE_BETA_HEADERS,
+          "anthropic-version": PROBE_VERSION,
+          "user-agent": PROBE_USER_AGENT,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: 1,
+          system: [
+            { type: "text", text: billingHeader },
+            { type: "text", text: CLAUDE_CODE_IDENTITY }
+          ],
+          messages: [{ role: "user", content: messageText }]
+        })
+      });
+      lastStatus = response.status;
+      const updated = updateUsageFromHeaders(state, account.name, response.headers);
+      if (response.status === 401 || response.status === 403) {
+        result.error = `auth error ${response.status}`;
+        markAuthFailure(state, account.name);
+        return result;
+      }
+      if (response.status === 429 && updated) {
+        result.success = true;
+        result.model = model;
+        clearAuthFailure(state, account.name);
+        await fetchAndApplyOAuthUsage(account, state, result);
+        return result;
+      }
+      if (response.ok || updated) {
+        result.success = true;
+        result.model = model;
+        clearAuthFailure(state, account.name);
+        await fetchAndApplyOAuthUsage(account, state, result);
+        return result;
+      }
+      lastBody = await response.text().catch(() => "");
+      if (response.status === 400 && lastBody.includes("model")) {
+        continue;
+      }
+    } catch (err) {
+      result.error = err instanceof Error ? err.message : String(err);
+      return result;
+    }
+  }
+  result.error = `HTTP ${lastStatus}: ${lastBody.slice(0, 100)}`;
+  return result;
+}
+async function probeAllAccounts(accounts) {
+  const state = loadState();
+  const results = [];
+  const probeErrors = [];
+  for (let i = 0;i < accounts.length; i += PROBE_CONCURRENCY) {
+    const batch = accounts.slice(i, i + PROBE_CONCURRENCY);
+    const batchResults = await Promise.allSettled(batch.map((account) => probeAccount(account, state)));
+    for (const settled of batchResults) {
+      if (settled.status === "fulfilled") {
+        results.push(settled.value);
+        if (!settled.value.success && settled.value.error) {
+          probeErrors.push(`${settled.value.name}: ${settled.value.error}`);
+        }
+      } else {
+        probeErrors.push(`unexpected error: ${settled.reason}`);
+      }
+    }
+  }
+  await saveStateMerged(state, accounts.map((a) => a.name));
+  if (probeErrors.length > 0) {
+    for (const err of probeErrors) {
+      console.log(`  ${YELLOW}Warning: probe failed for ${err}${RESET}`);
+    }
+  }
+  return { state, results };
+}
 async function cmdUsage(args) {
   const watch = args.includes("--watch") || args.includes("-w");
   const showUsage = async () => {
@@ -887,10 +1226,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)}${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)}`);
+        console.log(`    5h session:  ${formatMetric(usage.session5h.utilization, thresholds.session5h)}${resetSuffix(usage.session5h, now)}`);
+        console.log(`    7d weekly:   ${formatMetric(usage.weekly7d.utilization, thresholds.weekly7d)}${resetSuffix(usage.weekly7d, now)}`);
+        console.log(`    7d sonnet:   ${formatMetric(usage.weekly7dSonnet.utilization, thresholds.weekly7dSonnet)}${resetSuffix(usage.weekly7dSonnet, now)}`);
+        console.log(`    7d fable:    ${formatMetric(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)}` : "";
@@ -909,6 +1248,18 @@ ${BOLD}${CYAN}=== Auth Switcher Usage Dashboard ===${RESET}
       console.log();
     }
   };
+  const accountsData = loadAccounts();
+  if (accountsData.accounts.length > 0) {
+    process.stdout.write(`${DIM}  Probing ${accountsData.accounts.length} account(s) for current usage...${RESET}`);
+    const { results } = await probeAllAccounts(accountsData.accounts);
+    const successCount = results.filter((r) => r.success).length;
+    const models = [...new Set(results.filter((r) => r.model).map((r) => r.model))];
+    process.stdout.write(`\r\x1B[K`);
+    if (successCount < accountsData.accounts.length) {
+      console.log(`${DIM}  Probed ${successCount}/${accountsData.accounts.length} accounts successfully${models.length ? ` (${models.join(", ")})` : ""}${RESET}
+`);
+    }
+  }
   await showUsage();
   if (watch) {
     console.log(`${DIM}Refreshing every 5 seconds. Press Ctrl+C to stop.${RESET}

package/dist/index.js

@@ -571,11 +571,12 @@ async function refreshAccountToken(refreshTokenValue) {
 
 // src/state.ts
 var EMPTY_METRIC = { utilization: 0, reset: 0, status: "" };
+var EMPTY_MODEL_METRIC = { utilization: null, reset: 0, status: "" };
 var EMPTY_USAGE = {
   session5h: { ...EMPTY_METRIC },
   weekly7d: { ...EMPTY_METRIC },
-  weekly7dSonnet: { ...EMPTY_METRIC },
-  weekly7dFable: { ...EMPTY_METRIC },
+  weekly7dSonnet: { ...EMPTY_MODEL_METRIC },
+  weekly7dFable: { ...EMPTY_MODEL_METRIC },
   rejected: { ...EMPTY_METRIC }
 };
 function defaultState() {
@@ -825,7 +826,7 @@ function isRejectionRelevant(prefix, modelFamily) {
 function metricEntries(usage, thresholds, modelFamily) {
   return Object.keys(METRIC_MODEL_FAMILY).filter((key) => isMetricRelevant(key, modelFamily)).map((key) => ({
     name: key,
-    util: usage[key].utilization,
+    util: usage[key].utilization ?? 0,
     threshold: thresholds[key]
   }));
 }
@@ -1228,6 +1229,6 @@ var AuthSwitcherPlugin = async ({ client }) => {
 };
 var src_default = AuthSwitcherPlugin;
 export {
-  src_default as default,
-  AuthSwitcherPlugin
+  AuthSwitcherPlugin,
+  src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-auth-switcher",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
     "@opencode-ai/plugin": "*"
   },
   "dependencies": {
-    "@ex-machina/opencode-anthropic-auth": "1.8.1"
+    "@ex-machina/opencode-anthropic-auth": "1.8.2"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "latest",