oc-auth-switcher 0.8.0 → 0.9.0

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";
@@ -260,6 +263,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 +329,99 @@ 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;
+}
 
 // src/rotation.ts
 function isTemporarilyUnavailable(state, accountName) {
@@ -434,6 +544,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];
 }
@@ -854,6 +967,132 @@ 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 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);
+        return result;
+      }
+      if (response.ok || updated) {
+        result.success = true;
+        result.model = model;
+        clearAuthFailure(state, account.name);
+        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 () => {
@@ -909,6 +1148,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/package.json

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