oc-auth-switcher 0.1.0 → 0.1.2

package/README.md

@@ -1,37 +1,31 @@
 # oc-auth-switcher
 
-Multi-account rotation companion plugin for OpenCode. Works alongside `@ex-machina/opencode-anthropic-auth` to automatically rotate between multiple Anthropic Claude Max accounts based on utilization thresholds.
+OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover. Captures rate-limit headers in real-time and switches accounts before you hit usage limits.
 
 ## How It Works
 
-This plugin does **not** replace your auth plugin. Instead it:
+This plugin registers as the Anthropic auth provider for OpenCode. It uses [`@ex-machina/opencode-anthropic-auth`](https://github.com/ex-machina-co/opencode-anthropic-auth) as a library for request/response transformation (billing header, system prompt sanitization, tool name prefixing) and adds:
 
-1. Maintains a pool of Anthropic OAuth accounts in a separate file
-2. Monitors utilization metrics via CLI `ping` commands
-3. Rotates the active account by writing credentials to `auth.json` via the OpenCode SDK
-4. `@ex-machina/opencode-anthropic-auth` reads the rotated credentials on the next API request
-
-The plugin also hooks into OpenCode's `session.idle` and `chat.message` events to check cached metrics and rotate proactively before thresholds are hit.
+1. **Multi-account rotation** — maintains a pool of OAuth accounts and selects the best one on each request
+2. **Real-time metric capture** — reads Anthropic's rate-limit response headers on every API call (no manual pinging needed)
+3. **Automatic failover** — when any utilization metric exceeds the threshold (default 90%), the next request automatically uses a different account
 
 ## Setup
 
-### 1. Install both plugins
+### 1. Add the plugin to your `opencode.json`
 
 ```json
 {
-  "plugin": [
-    "@ex-machina/opencode-anthropic-auth@1.8.0",
-    "oc-auth-switcher@latest"
-  ]
+  "plugin": ["oc-auth-switcher@latest"]
 }
 ```
 
-**Important:** `@ex-machina/opencode-anthropic-auth` must be listed first.
+This is the **only** auth plugin you need for Anthropic. Do not also list `@ex-machina/opencode-anthropic-auth` — it is included as a dependency.
 
 ### 2. Add accounts
 
 ```bash
-# Add your primary account
+# Add your primary account (first account = always preferred)
 oc-auth-switcher add primary
 
 # Add fallback accounts
@@ -41,34 +35,31 @@ oc-auth-switcher add fallback-2
 
 Each `add` command runs an OAuth flow — you'll be given a URL to open in your browser and prompted to paste the callback.
 
-### 3. Ping to capture initial metrics
-
-```bash
-oc-auth-switcher ping
-```
-
-### 4. Use OpenCode normally
+### 3. Use OpenCode normally
 
-The plugin handles rotation automatically. The first account in the pool is always the "primary" (preferred). When it exceeds the utilization threshold, traffic switches to the next available fallback. When the primary recovers, it switches back.
+Metrics update automatically on every API request. When the primary account exceeds the utilization threshold, the plugin switches to the next available fallback. When the primary recovers, it switches back.
 
 ## CLI Commands
 
+```
+oc-auth-switcher <command> [options]
+```
+
 | Command | Description |
 |---------|-------------|
 | `add [name]` | Add a new account via OAuth |
-| `remove <name>` | Remove an account from the pool |
+| `reauth <name>` | Re-authenticate an existing account |
 | `usage [--watch]` | Show utilization dashboard with progress bars |
 | `config [options]` | View/modify thresholds and check interval |
-| `ping [name]` | Ping account(s) to refresh utilization metrics |
-| `reauth <name>` | Re-authenticate an existing account |
 | `switch <name>` | Manually switch to a specific account |
 | `status` | Show current active account and rotation state |
+| `remove <name>` | Remove an account from the pool |
 
 ## Configuration
 
 ```bash
-# Set uniform threshold (default: 70%)
-oc-auth-switcher config --threshold 0.80
+# Set uniform threshold (default: 90%)
+oc-auth-switcher config --threshold 0.90
 
 # Set per-metric thresholds (5h, 7d, 7d-sonnet)
 oc-auth-switcher config --thresholds 90,80,70
@@ -96,6 +87,21 @@ Both files use atomic writes with `.bak` fallback for crash safety.
 - If all fallbacks are also over threshold, pick the one with the lowest utilization score
 - When on a fallback, periodically check if the primary has recovered (configurable interval)
 - Auth failures trigger a 1-hour cooldown per account
+- Token refresh is handled automatically with retry and fallback to other accounts
+
+## Running the CLI
+
+When installed via npm (as part of the OpenCode plugin):
+
+```bash
+npx oc-auth-switcher <command>
+```
+
+From the project directory (development):
+
+```bash
+bun dist/cli.js <command>
+```
 
 ## Building from Source
 
@@ -104,6 +110,36 @@ bun install
 bun run build
 ```
 
+## Publishing to npm
+
+```bash
+npm login
+npm publish
+```
+
+The `prepublishOnly` script automatically runs `bun run build` before publishing.
+
+### Versioning
+
+```bash
+# Patch (bug fixes)
+npm version patch && npm publish && git push --follow-tags
+
+# Minor (new features)
+npm version minor && npm publish && git push --follow-tags
+
+# Major (breaking changes)
+npm version major && npm publish && git push --follow-tags
+```
+
+### Updating the ex-machina dependency
+
+```bash
+bun update @ex-machina/opencode-anthropic-auth
+bun run build
+# Test, then publish
+```
+
 ## License
 
 MIT

package/dist/cli.js

@@ -13,7 +13,7 @@ var ACCOUNTS_FILE = path.join(configDir, "auth-switcher-accounts.json");
 var STATE_FILE = path.join(configDir, "auth-switcher-state.json");
 var DEFAULT_THRESHOLD = 0.9;
 var DEFAULT_CHECK_INTERVAL = 60 * 60 * 1000;
-var AUTH_FAILURE_COOLDOWN = 60 * 60 * 1000;
+var AUTH_FAILURE_COOLDOWN = 10 * 60 * 1000;
 
 // src/accounts.ts
 function normalizeAccount(raw) {

package/dist/index.js

@@ -415,7 +415,7 @@ var ACCOUNTS_FILE = path.join(configDir, "auth-switcher-accounts.json");
 var STATE_FILE = path.join(configDir, "auth-switcher-state.json");
 var DEFAULT_THRESHOLD = 0.9;
 var DEFAULT_CHECK_INTERVAL = 60 * 60 * 1000;
-var AUTH_FAILURE_COOLDOWN = 60 * 60 * 1000;
+var AUTH_FAILURE_COOLDOWN = 10 * 60 * 1000;
 
 // src/accounts.ts
 function normalizeAccount(raw) {
@@ -659,10 +659,44 @@ function getEarliestReset(usage) {
   ].filter((r) => r > 0);
   return resets.length > 0 ? Math.min(...resets) * 1000 : 0;
 }
+function purgeExpiredCooldowns(state) {
+  const now = Date.now();
+  for (const name of Object.keys(state.authFailures)) {
+    if (state.authFailures[name] <= now) {
+      delete state.authFailures[name];
+    }
+  }
+}
+function findBestAvailable(candidates, state, exclude) {
+  for (const acct of candidates) {
+    if (exclude.has(acct.name))
+      continue;
+    if (isTemporarilyUnavailable(state, acct.name))
+      continue;
+    if (!isOverThreshold(state.usage[acct.name], state)) {
+      return acct;
+    }
+  }
+  let best = null;
+  let bestScore = Infinity;
+  for (const acct of candidates) {
+    if (exclude.has(acct.name))
+      continue;
+    if (isTemporarilyUnavailable(state, acct.name))
+      continue;
+    const score = getUtilizationScore(state.usage[acct.name], state);
+    if (score < bestScore) {
+      bestScore = score;
+      best = acct;
+    }
+  }
+  return best;
+}
 function selectAccount(accounts, state) {
   if (accounts.length === 0) {
     throw new Error("No accounts available");
   }
+  purgeExpiredCooldowns(state);
   if (accounts.length === 1) {
     return { account: accounts[0], switched: false };
   }
@@ -690,40 +724,39 @@ function selectAccount(accounts, state) {
   if (isPrimary) {
     if (isOverThreshold(primaryUsage, state)) {
       const exceededMetric = getExceededMetric(primaryUsage, state);
-      for (const fb of fallbacks) {
-        if (isTemporarilyUnavailable(state, fb.name))
-          continue;
-        const fbUsage = state.usage[fb.name];
-        if (!isOverThreshold(fbUsage, state)) {
-          return {
-            account: fb,
-            switched: true,
-            reason: `Primary exceeded ${exceededMetric} threshold — switching to ${fb.name}`
-          };
-        }
-      }
-      let bestFb = null;
-      let bestScore = Infinity;
-      for (const fb of fallbacks) {
-        if (isTemporarilyUnavailable(state, fb.name))
-          continue;
-        const score = getUtilizationScore(state.usage[fb.name], state);
-        if (score < bestScore) {
-          bestScore = score;
-          bestFb = fb;
-        }
-      }
-      if (bestFb) {
+      const best = findBestAvailable(fallbacks, state, new Set);
+      if (best) {
         return {
-          account: bestFb,
+          account: best,
           switched: true,
-          reason: `Primary exceeded threshold, all fallbacks busy — using least loaded: ${bestFb.name}`
+          reason: `Primary exceeded ${exceededMetric} threshold — switching to ${best.name}`
         };
       }
       return { account: primary, switched: false };
     }
     return { account: primary, switched: false };
   }
+  const currentOverThreshold = isOverThreshold(currentUsage, state);
+  const currentInCooldown = isTemporarilyUnavailable(state, current.name);
+  if (currentOverThreshold || currentInCooldown) {
+    const reason = currentInCooldown ? `${current.name} in auth-failure cooldown` : `${current.name} exceeded threshold`;
+    if (!isOverThreshold(primaryUsage, state) && !isTemporarilyUnavailable(state, primary.name)) {
+      return {
+        account: primary,
+        switched: true,
+        reason: `${reason} — switching back to primary`
+      };
+    }
+    const best = findBestAvailable(accounts, state, new Set([current.name]));
+    if (best && best.name !== current.name) {
+      return {
+        account: best,
+        switched: true,
+        reason: `${reason} — switching to ${best.name}`
+      };
+    }
+    return { account: current, switched: false };
+  }
   const now = Date.now();
   const checkInterval = state.config.checkInterval;
   const earliestReset = getEarliestReset(primaryUsage);
@@ -739,30 +772,6 @@ function selectAccount(accounts, state) {
       };
     }
   }
-  if (!isTemporarilyUnavailable(state, current.name)) {
-    return { account: current, switched: false };
-  }
-  for (const fb of fallbacks) {
-    if (fb.name === current.name)
-      continue;
-    if (isTemporarilyUnavailable(state, fb.name))
-      continue;
-    const fbUsage = state.usage[fb.name];
-    if (!isOverThreshold(fbUsage, state)) {
-      return {
-        account: fb,
-        switched: true,
-        reason: `Current account ${current.name} in cooldown — switching to ${fb.name}`
-      };
-    }
-  }
-  if (!isTemporarilyUnavailable(state, primary.name)) {
-    return {
-      account: primary,
-      switched: true,
-      reason: "All fallbacks unavailable — falling back to primary"
-    };
-  }
   return { account: current, switched: false };
 }
 function markAuthFailure(state, accountName) {

package/package.json

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