pi-antigravity-rotator 1.0.1 → 1.2.0

package/README.md

@@ -67,7 +67,7 @@ After starting the proxy, open `http://localhost:51200/dashboard` or `http://<yo
 The dashboard shows:
 
 - **Model Routing table** -- Which account each model (Gemini Pro, Flash, Claude) is currently routed to
-- **Account cards** with:
+- **Account cards** sorted by total quota (highest first), flagged/disabled last:
   - Status badge: `active`, `ready`, `cooldown`, `flagged`, `disabled`, or `error`
   - Model badges: which models this account is currently serving
   - Per-model quota bars with timer type (`fresh`/`7d`/`5h`) and reset countdown
@@ -121,27 +121,40 @@ Three mechanisms trigger rotation, scoped to the specific model:
 
 The proxy detects blocked/suspended accounts at three levels:
 
-1. **Quota API check** (on startup + every poll) -- If the quota API returns `403 PERMISSION_DENIED` with "violation of Terms of Service", the account is immediately flagged. This catches suspended accounts before any request is wasted.
+1. **Quota API check** (on startup + every poll) -- If the quota API returns `403 PERMISSION_DENIED` with "violation of Terms of Service", the account is immediately flagged.
 
-2. **API endpoint 401** (on request) -- If all 3 endpoints (daily, autopush, prod) reject the token with `401 UNAUTHENTICATED`, the account is flagged. The proxy cascades through all endpoints before giving up.
+2. **API 401** (on request) -- If the prod endpoint rejects the token with `401 UNAUTHENTICATED`, the account is flagged.
 
-3. **API endpoint 403** (on request) -- If the response body contains infringement keywords (`infring`, `suspend`, `abus`, `terminat`, `violat`, `banned`, `policy`, `forbidden`), the account is flagged.
+3. **API 403** (on request) -- If the response body contains infringement keywords (`infring`, `suspend`, `abus`, `terminat`, `violat`, `banned`, `policy`, `forbidden`), the account is flagged.
 
-Flagged accounts are **immediately excluded** from all model routing. The dashboard shows a red `FLAGGED` badge with the error message. Use the Re-enable button or `POST /api/enable/<email>` to clear the flag after resolving the issue with Google.
+Flagged accounts are **immediately excluded** from all model routing. The dashboard shows a red `FLAGGED` badge with the error message. Use the Re-enable button or `POST /api/enable/<email>` to clear the flag.
 
-### Endpoint Cascade
+### Cooldown Management
 
-The proxy tries three Google API endpoints in order for each request:
+- Cooldowns are capped at **30 minutes** max
+- Stale cooldowns from previous sessions are capped on startup
+- Use `POST /api/reset-cooldowns` to clear all cooldowns at once
+- Quota-based rotation only triggers if a healthy account is available; the proxy won't rotate away from a working account if there's no better alternative
 
-1. `daily-cloudcode-pa.sandbox.googleapis.com`
-2. `autopush-cloudcode-pa.sandbox.googleapis.com`
-3. `cloudcode-pa.googleapis.com` (prod)
+### Error Handling
 
-On `401`, `403`, or `404`, it cascades to the next endpoint. Only the final endpoint's response is used for flagging decisions.
+- **429** (rate limit) -- account is marked exhausted with cooldown, rotates to next
+- **503** (no capacity) -- returned directly to the agent for its own retry/backoff
+- **5xx** (other server errors) -- account error counter incremented, rotates to next
 
 ## Configuration
 
-All configuration is in `accounts.json`, created automatically by `npm run login`:
+Config files (`accounts.json`, `state.json`) are stored in `~/.pi-antigravity-rotator/` by default. Override with:
+
+```bash
+# Environment variable
+export PI_ROTATOR_DIR=/path/to/config
+
+# Or CLI flag
+pi-antigravity-rotator start --config-dir /path/to/config
+```
+
+`accounts.json` is created automatically by the login command:
 
 ```json
 {
@@ -185,6 +198,7 @@ All configuration is in `accounts.json`, created automatically by `npm run login
 | `GET` | `/dashboard` | Web dashboard |
 | `GET` | `/api/status` | JSON status: accounts, quotas, model routing, flags |
 | `POST` | `/api/enable/<email>` | Clear flagged/disabled state and re-enable an account |
+| `POST` | `/api/reset-cooldowns` | Clear all cooldowns on all accounts |
 | `POST` | `/v1internal:streamGenerateContent` | Proxy endpoint (used by pi) |
 
 ## Running as a Service

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Multi-account rotation proxy for Google Antigravity with per-model routing, real-time quota tracking, and infringement detection",
   "license": "MIT",
   "type": "module",
@@ -20,6 +20,8 @@
   "keywords": [
     "pi-package",
     "pi",
+    "pi-coding",
+    "pi-coding-agent",
     "antigravity",
     "proxy",
     "rotation",
@@ -31,7 +33,7 @@
     "type": "git",
     "url": "https://github.com/tuxevil/pi-antigravity-rotator.git"
   },
-  "author": "tuxevil",
+  "author": "Sebastián Real (tuxevil)",
   "dependencies": {
     "tsx": "^4.19.0"
   },

package/src/dashboard.ts

@@ -22,6 +22,12 @@ export function serveEnableApi(res: ServerResponse, rotator: AccountRotator, ema
 	res.end(JSON.stringify({ ok, email }));
 }
 
+export function serveResetCooldownsApi(res: ServerResponse, rotator: AccountRotator): void {
+	const count = rotator.resetAllCooldowns();
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify({ ok: true, resetCount: count }));
+}
+
 const DASHBOARD_HTML = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -248,6 +254,17 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
     word-break: break-all;
   }
 
+  .card-hint {
+    margin-top: 6px;
+    padding: 8px 10px;
+    background: rgba(250, 204, 21, 0.08);
+    border-radius: 8px;
+    border-left: 3px solid var(--yellow);
+    font-size: 11px;
+    color: var(--yellow);
+    line-height: 1.4;
+  }
+
   .card-actions { margin-top: 10px; display: flex; gap: 8px; }
 
   .btn-enable {
@@ -358,7 +375,8 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
   <div class="header-stats">
     Uptime: <span id="uptime">--</span> |
     Port: <span id="port">--</span> |
-    Rotation: <span id="rotation">--</span> reqs
+    Rotation: <span id="rotation">--</span> reqs |
+    <button id="maskBtn" onclick="toggleMask()" style="background:none;border:1px solid var(--border);color:var(--text-dim);padding:2px 8px;border-radius:4px;cursor:pointer;font-size:12px;font-family:inherit;">PII: Visible</button>
   </div>
 </div>
 
@@ -437,7 +455,7 @@ function renderModelRouting(activeAccounts) {
     return '<div class="model-route">' +
       '<span class="model-name">' + e[0] + '</span>' +
       '<span class="route-arrow">-></span>' +
-      '<span class="account-name">' + e[1] + '</span>' +
+      '<span class="account-name">' + maskText(e[1]) + '</span>' +
     '</div>';
   }).join('');
   container.innerHTML = '<div class="model-routing-title">Model Routing</div>' + rows;
@@ -456,7 +474,15 @@ function renderAccounts(data) {
   renderModelRouting(data.activeAccounts);
 
   var container = document.getElementById('accounts');
-  container.innerHTML = data.accounts.map(function(a) {
+  var sorted = data.accounts.slice().sort(function(a, b) {
+    var aFlagged = a.status === 'flagged' || a.status === 'disabled' ? 1 : 0;
+    var bFlagged = b.status === 'flagged' || b.status === 'disabled' ? 1 : 0;
+    if (aFlagged !== bFlagged) return aFlagged - bFlagged;
+    var aQuota = (a.quota || []).reduce(function(s, q) { return s + q.percentRemaining; }, 0);
+    var bQuota = (b.quota || []).reduce(function(s, q) { return s + q.percentRemaining; }, 0);
+    return bQuota - aQuota;
+  });
+  container.innerHTML = sorted.map(function(a) {
     var isActive = a.status === 'active';
     var isCooldown = a.status === 'cooldown' || a.status === 'exhausted';
     var isDisabled = a.status === 'disabled' || a.status === 'flagged';
@@ -473,13 +499,13 @@ function renderAccounts(data) {
 
     return '<div class="account-card ' + a.status + '">' +
       '<div class="card-header">' +
-        '<div class="card-label">' + a.label + '</div>' +
+        '<div class="card-label">' + maskText(a.label) + '</div>' +
         '<div class="card-badges">' +
           '<span class="badge badge-' + a.status + (isActive ? ' pulse' : '') + '">' + a.status + '</span>' +
           modelBadges +
         '</div>' +
       '</div>' +
-      '<div class="card-email">' + a.email + '</div>' +
+      '<div class="card-email">' + maskEmail(a.email) + '</div>' +
       (a.quota && a.quota.length > 0 ? renderQuotaBars(a.quota) : '') +
       '<div class="card-stats">' +
         '<div class="card-stat"><div class="stat-label">Requests</div><div class="stat-value">' +
@@ -492,7 +518,12 @@ function renderAccounts(data) {
           (a.hasValidToken ? 'var(--green)' : 'var(--text-dim)') + '">' +
           (a.hasValidToken ? 'Valid' : 'Expired') + '</div></div>' +
       '</div>' +
-      (a.lastError ? '<div class="card-error">' + a.lastError.slice(0, 150) + '</div>' : '') +
+      (a.lastError ? '<div class="card-error">' + a.lastError.slice(0, 150) + '</div>' +
+        (a.lastError.toLowerCase().includes('verif') ?
+          '<div class="card-hint">Fix: Open Antigravity IDE, sign in with this account, and complete the verification prompt. Then click Re-enable.</div>' :
+        a.lastError.toLowerCase().includes('terms of service') ?
+          '<div class="card-hint">This account was suspended by Google. Submit an appeal at <a href="https://support.google.com/accounts/troubleshooter/2402620" target="_blank" style="color:var(--cyan)">Google Account Recovery</a>, then Re-enable.</div>' :
+          '') : '') +
       (isDisabled ? '<div class="card-actions"><button class="btn-enable" onclick="enableAccount(\\'' +
         a.email + '\\')">Re-enable</button></div>' : '') +
       (isCooldown && cooldownPercent > 0 ? '<div class="cooldown-bar" style="width:' + cooldownPercent + '%"></div>' : '') +
@@ -500,6 +531,25 @@ function renderAccounts(data) {
   }).join('');
 }
 
+var MASK_MODE = new URLSearchParams(window.location.search).has('mask');
+var maskCounter = 0;
+var maskMap = {};
+
+function maskText(text) {
+  if (!MASK_MODE) return text;
+  if (!maskMap[text]) {
+    maskCounter++;
+    maskMap[text] = 'Account ' + maskCounter;
+  }
+  return maskMap[text];
+}
+
+function maskEmail(email) {
+  if (!MASK_MODE) return email;
+  var masked = maskText(email.split('@')[0]);
+  return masked.toLowerCase().replace(/ /g, '-') + '@***.com';
+}
+
 async function enableAccount(email) {
   await fetch('/api/enable/' + encodeURIComponent(email), { method: 'POST' });
   refresh();
@@ -510,11 +560,23 @@ async function refresh() {
     var res = await fetch('/api/status');
     var data = await res.json();
     renderAccounts(data);
+    var btn = document.getElementById('maskBtn');
+    if (btn) btn.textContent = MASK_MODE ? 'PII: Hidden' : 'PII: Visible';
   } catch (err) {
     console.error('Status fetch failed:', err);
   }
 }
 
+function toggleMask() {
+  var url = new URL(window.location);
+  if (MASK_MODE) {
+    url.searchParams.delete('mask');
+  } else {
+    url.searchParams.set('mask', '1');
+  }
+  window.location.href = url.toString();
+}
+
 refresh();
 setInterval(refresh, 3000);
 </script>

package/src/proxy.ts

@@ -1,12 +1,14 @@
 // HTTP reverse proxy - forwards requests to Antigravity with credential rotation
 
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { Readable } from "node:stream";
 import { ANTIGRAVITY_ENDPOINTS } from "./types.js";
 import type { AccountRuntime } from "./types.js";
 import type { AccountRotator } from "./rotator.js";
-import { serveDashboard, serveStatusApi, serveEnableApi } from "./dashboard.js";
+import { serveDashboard, serveStatusApi, serveEnableApi, serveResetCooldownsApi } from "./dashboard.js";
 
 const MAX_ENDPOINT_RETRIES = 3;
+const MAX_COOLDOWN_MS = 30 * 60 * 1000; // 30 minutes max cooldown
 
 interface RequestBody {
 	project: string;
@@ -73,6 +75,10 @@ function extractRetryDelay(errorText: string, headers: Headers): number {
 	return 60_000;
 }
 
+function capCooldown(ms: number): number {
+	return Math.min(ms, MAX_COOLDOWN_MS);
+}
+
 /**
  * Read the full request body from an IncomingMessage.
  */
@@ -87,14 +93,12 @@ function readBody(req: IncomingMessage): Promise<Buffer> {
 
 /**
  * Forward a request to the real Antigravity endpoint with credential swapping.
- * Handles endpoint cascade (daily -> autopush -> prod) and 429 retry.
  */
 async function forwardRequest(
 	account: AccountRuntime,
 	body: RequestBody,
 	originalHeaders: Record<string, string>,
-	rotator: AccountRotator,
-): Promise<{ status: number; headers: Headers; body: ReadableStream<Uint8Array> | null }> {
+): Promise<Response> {
 	// Swap credentials
 	body.project = account.config.projectId;
 	const requestBody = JSON.stringify(body);
@@ -117,32 +121,34 @@ async function forwardRequest(
 	delete forwardHeaders["transfer-encoding"];
 	delete forwardHeaders["content-length"];
 
-	// Try endpoints with cascade on 403/404
+	// Try endpoints with cascade on 401/403/404
 	for (let endpointIdx = 0; endpointIdx < ANTIGRAVITY_ENDPOINTS.length; endpointIdx++) {
 		const endpoint = ANTIGRAVITY_ENDPOINTS[endpointIdx];
 		const url = `${endpoint}/v1internal:streamGenerateContent?alt=sse`;
+		const isProd = endpointIdx === ANTIGRAVITY_ENDPOINTS.length - 1;
 
 		try {
+			const controller = !isProd ? new AbortController() : undefined;
+			const timeout = controller ? setTimeout(() => controller.abort(), 10_000) : undefined;
+
 			const response = await fetch(url, {
 				method: "POST",
 				headers: forwardHeaders,
 				body: requestBody,
+				signal: controller?.signal,
 			});
+			if (timeout) clearTimeout(timeout);
 
-			// On 401/403/404, try next endpoint
 			if ((response.status === 401 || response.status === 403 || response.status === 404) && endpointIdx < ANTIGRAVITY_ENDPOINTS.length - 1) {
 				log(`Endpoint ${endpoint} returned ${response.status}, cascading...`);
+				response.text().catch(() => {});
 				continue;
 			}
 
-			return {
-				status: response.status,
-				headers: response.headers,
-				body: response.body,
-			};
+			return response;
 		} catch (err) {
 			if (endpointIdx < ANTIGRAVITY_ENDPOINTS.length - 1) {
-				log(`Endpoint ${endpoint} failed: ${err}, cascading...`);
+				log(`Endpoint ${endpoint} failed: ${err instanceof Error ? err.message : err}, cascading...`);
 				continue;
 			}
 			throw err;
@@ -175,7 +181,6 @@ async function handleProxyRequest(
 		return;
 	}
 
-	// Try up to MAX_ENDPOINT_RETRIES accounts on 429
 	for (let attempt = 0; attempt < MAX_ENDPOINT_RETRIES; attempt++) {
 		const account = await rotator.getActiveAccount(body.model);
 		if (!account) {
@@ -188,31 +193,29 @@ async function handleProxyRequest(
 		log(`[${label}] Forwarding ${body.model} request (attempt ${attempt + 1})`);
 
 		try {
-			const upstream = await forwardRequest(account, { ...body }, flattenHeaders(req.headers), rotator);
+			const response = await forwardRequest(account, { ...body }, flattenHeaders(req.headers));
 
-			if (upstream.status === 429) {
-				// Rate limited - extract delay, mark exhausted, try next account
-				const errorText = upstream.body ? await streamToString(upstream.body) : "";
-				const cooldownMs = extractRetryDelay(errorText, upstream.headers);
+			if (response.status === 429) {
+				const errorText = await response.text().catch(() => "");
+				const cooldownMs = capCooldown(extractRetryDelay(errorText, response.headers));
 				log(`[${label}] 429 rate limited, cooldown ${Math.ceil(cooldownMs / 1000)}s`);
 				rotator.markExhausted(account, cooldownMs);
 				await rotator.rotateToNext(body.model);
 				continue;
 			}
 
-			if (upstream.status === 401) {
-				// Token was valid but API rejected it - account is blocked
-				const errorText = upstream.body ? await streamToString(upstream.body) : "";
+			if (response.status === 401) {
+				const errorText = await response.text().catch(() => "");
 				log(`[${label}] BLOCKED (401): ${errorText.slice(0, 200)}`);
 				rotator.markFlagged(account, `Account blocked (401): ${errorText.slice(0, 300)}`);
 				await rotator.rotateToNext(body.model);
 				continue;
 			}
 
-			if (upstream.status === 403) {
-				const errorText = upstream.body ? await streamToString(upstream.body) : "";
+			if (response.status === 403) {
+				const errorText = await response.text().catch(() => "");
 				const lower = errorText.toLowerCase();
-				const flagPatterns = ["infring", "suspend", "abus", "terminat", "violat", "banned", "policy", "forbidden"];
+				const flagPatterns = ["infring", "suspend", "abus", "terminat", "violat", "banned", "policy", "forbidden", "verif"];
 				const isFlagged = flagPatterns.some((p) => lower.includes(p));
 
 				if (isFlagged) {
@@ -221,47 +224,56 @@ async function handleProxyRequest(
 					await rotator.rotateToNext(body.model);
 					continue;
 				}
-				// Non-infringement 403 falls through to cascade in forwardRequest
+				// Non-flagging 403: return to client
+				log(`[${label}] 403: ${errorText.slice(0, 200)}`);
+				res.writeHead(403, { "Content-Type": "application/json" });
+				res.end(errorText || JSON.stringify({ error: "Forbidden" }));
+				return;
 			}
 
-			if (upstream.status >= 500) {
-				const errorText = upstream.body ? await streamToString(upstream.body) : "";
-				log(`[${label}] Server error ${upstream.status}: ${errorText.slice(0, 200)}`);
-				rotator.markError(account, `${upstream.status}: ${errorText.slice(0, 200)}`);
+			if (response.status >= 500) {
+				const errorText = await response.text().catch(() => "");
+				log(`[${label}] Server error ${response.status}: ${errorText.slice(0, 200)}`);
+				if (response.status === 503) {
+					res.writeHead(503, { "Content-Type": "application/json" });
+					res.end(errorText || JSON.stringify({ error: "Server unavailable" }));
+					return;
+				}
+				rotator.markError(account, `${response.status}: ${errorText.slice(0, 200)}`);
 				await rotator.rotateToNext(body.model);
 				continue;
 			}
 
-			// Success or client error (4xx other than 429)
+			// Success or non-error client response
 			const shouldRotate = rotator.recordRequest(account);
 
-			// Copy response headers
 			const responseHeaders: Record<string, string> = {};
-			upstream.headers.forEach((value, key) => {
-				// Skip hop-by-hop headers
+			response.headers.forEach((value, key) => {
 				if (key.toLowerCase() !== "transfer-encoding" && key.toLowerCase() !== "connection") {
 					responseHeaders[key] = value;
 				}
 			});
 
-			res.writeHead(upstream.status, responseHeaders);
+			res.writeHead(response.status, responseHeaders);
 
-			// Stream the body back to the client
-			if (upstream.body) {
-				const reader = upstream.body.getReader();
+			// Stream body using Node.js Readable (avoids ReadableStream locking issues)
+			if (response.body) {
 				try {
-					while (true) {
-						const { done, value } = await reader.read();
-						if (done) break;
-						res.write(value);
-					}
+					const nodeStream = Readable.fromWeb(response.body as import("node:stream/web").ReadableStream);
+					await new Promise<void>((resolve) => {
+						nodeStream.on("data", (chunk: Buffer) => res.write(chunk));
+						nodeStream.on("end", resolve);
+						nodeStream.on("error", (err) => {
+							log(`[${label}] Stream error: ${err}`);
+							resolve();
+						});
+					});
 				} catch (err) {
-					log(`[${label}] Stream error: ${err}`);
+					log(`[${label}] Stream setup error: ${err}`);
 				}
 			}
 			res.end();
 
-			// Rotate after response completes if threshold was hit
 			if (shouldRotate) {
 				await rotator.rotateToNext(body.model);
 			}
@@ -269,13 +281,18 @@ async function handleProxyRequest(
 		} catch (err) {
 			log(`[${label}] Request failed: ${err}`);
 			rotator.markError(account, err instanceof Error ? err.message : String(err));
+			if (res.headersSent) {
+				res.end();
+				return;
+			}
 			await rotator.rotateToNext(body.model);
 			continue;
 		}
 	}
 
-	// All retry attempts exhausted
-	res.writeHead(502, { "Content-Type": "application/json" });
+	if (!res.headersSent) {
+		res.writeHead(502, { "Content-Type": "application/json" });
+	}
 	res.end(JSON.stringify({ error: "All retry attempts failed" }));
 }
 
@@ -289,25 +306,13 @@ function flattenHeaders(headers: IncomingMessage["headers"]): Record<string, str
 	return flat;
 }
 
-async function streamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
-	const reader = stream.getReader();
-	const decoder = new TextDecoder();
-	let result = "";
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		result += decoder.decode(value, { stream: true });
-	}
-	return result;
-}
-
 export function startProxy(rotator: AccountRotator, port: number): void {
 	const server = createServer((req, res) => {
-		const url = req.url || "/";
-		const method = req.method || "GET";
+		const method = req.method?.toUpperCase();
+		const url = req.url || "";
+		const pathname = url.split("?")[0];
 
-		// Dashboard and API routes
-		if (method === "GET" && (url === "/" || url === "/dashboard")) {
+		if (method === "GET" && (pathname === "/" || pathname === "/dashboard")) {
 			serveDashboard(res);
 			return;
 		}
@@ -323,6 +328,11 @@ export function startProxy(rotator: AccountRotator, port: number): void {
 			return;
 		}
 
+		if (method === "POST" && url === "/api/reset-cooldowns") {
+			serveResetCooldownsApi(res, rotator);
+			return;
+		}
+
 		// Proxy route
 		if (method === "POST" && url.includes("v1internal")) {
 			handleProxyRequest(req, res, rotator).catch((err) => {
@@ -335,24 +345,12 @@ export function startProxy(rotator: AccountRotator, port: number): void {
 			return;
 		}
 
-		// 404
 		res.writeHead(404, { "Content-Type": "application/json" });
 		res.end(JSON.stringify({ error: "Not found" }));
 	});
 
 	server.listen(port, "0.0.0.0", () => {
-		log(`Proxy listening on http://0.0.0.0:${port}`);
-		log(`Dashboard: http://localhost:${port}/dashboard`);
-		log(`API endpoint: http://localhost:${port}/v1internal:streamGenerateContent?alt=sse`);
+		console.log(`[proxy] Listening on 0.0.0.0:${port}`);
+		console.log(`[proxy] Dashboard: http://localhost:${port}/dashboard`);
 	});
-
-	// Graceful shutdown
-	const shutdown = () => {
-		log("Shutting down...");
-		rotator.saveState();
-		server.close();
-		process.exit(0);
-	};
-	process.on("SIGINT", shutdown);
-	process.on("SIGTERM", shutdown);
 }

package/src/rotator.ts

@@ -87,6 +87,14 @@ export class AccountRotator {
 				account.flagged = saved.flagged ?? false;
 				}
 			}
+			// Cap any stale cooldowns to 30 min max from now
+			const maxCooldown = 30 * 60 * 1000;
+			const now = Date.now();
+			for (const account of this.accounts) {
+				if (account.cooldownUntil > now + maxCooldown) {
+					account.cooldownUntil = now + maxCooldown;
+				}
+			}
 			this.log("Loaded state from disk");
 		} catch {
 			this.log("Could not load state, starting fresh");
@@ -170,10 +178,21 @@ export class AccountRotator {
 				} else {
 					const drop = mState.quotaAtRotationStart - modelQuota;
 					if (drop >= this.config.rotateOnQuotaDrop) {
-						this.log(
-							`${account.config.label || account.config.email} [${modelKey}]: quota dropped ${drop}% (${mState.quotaAtRotationStart}% -> ${modelQuota}%), rotating`,
+						// Only rotate if there's a healthy account to rotate to
+						const hasHealthy = this.accounts.some(
+							(a, idx) => idx !== mState.activeAccountIndex && this.isAvailable(a, Date.now()),
 						);
-						await this.rotateModel(modelKey);
+						if (hasHealthy) {
+							this.log(
+								`${account.config.label || account.config.email} [${modelKey}]: quota dropped ${drop}% (${mState.quotaAtRotationStart}% -> ${modelQuota}%), rotating`,
+							);
+							await this.rotateModel(modelKey);
+						} else {
+							this.log(
+								`${account.config.label || account.config.email} [${modelKey}]: quota dropped ${drop}% but no healthy accounts available, staying`,
+							);
+							mState.quotaAtRotationStart = modelQuota; // Reset baseline
+						}
 					}
 				}
 			}
@@ -291,6 +310,16 @@ export class AccountRotator {
 
 		const current = this.accounts[idx];
 		if (current && this.isAvailable(current, now)) {
+			// Check if this account has quota for the requested model
+			if (modelKey) {
+				const quota = this.getModelQuota(current, modelKey);
+				if (quota === 0) {
+					this.log(
+						`${current.config.label || current.config.email} [${modelKey}]: 0% quota, skipping`,
+					);
+					return this.rotateModel(modelKey);
+				}
+			}
 			await this.ensureValidToken(current);
 			return current;
 		}
@@ -314,9 +343,13 @@ export class AccountRotator {
 			const account = this.accounts[i];
 
 			if (this.isAvailable(account, now)) {
-				const priority = this.getModelTimerPriority(account, modelKey);
 				const quota = this.getModelQuota(account, modelKey);
 
+				// Skip accounts with 0% quota for this model (they will 429)
+				if (quota === 0) continue;
+
+				const priority = this.getModelTimerPriority(account, modelKey);
+
 				if (priority < bestPriority || (priority === bestPriority && quota > bestQuota)) {
 					best = account;
 					bestPriority = priority;
@@ -455,6 +488,22 @@ export class AccountRotator {
 		return true;
 	}
 
+	resetAllCooldowns(): number {
+		let count = 0;
+		for (const account of this.accounts) {
+			if (account.cooldownUntil > Date.now()) {
+				account.cooldownUntil = 0;
+				account.quotaExhaustedAt = 0;
+				count++;
+			}
+		}
+		if (count > 0) {
+			this.saveState();
+			this.log(`Reset cooldowns on ${count} accounts`);
+		}
+		return count;
+	}
+
 	async ensureValidToken(account: AccountRuntime): Promise<void> {
 		const now = Date.now();
 		if (account.accessToken && account.tokenExpires > now) {

package/src/types.ts

@@ -59,7 +59,7 @@ export const QUOTA_MODEL_KEYS: Record<string, { key: string; altKeys: string[];
 	},
 	claude: {
 		key: "claude-opus-4-6-thinking",
-		altKeys: ["claude-opus-4-5-thinking", "claude-opus-4-5", "claude-sonnet-4-6", "claude-sonnet-4-5"],
+		altKeys: ["claude-opus-4-5-thinking", "claude-opus-4-5", "claude-sonnet-4-6-thinking", "claude-sonnet-4-6", "claude-sonnet-4-5-thinking", "claude-sonnet-4-5"],
 		display: "Claude",
 	},
 };
@@ -161,8 +161,6 @@ export const CLIENT_SECRET = atob("R09DU1BYLUs1OEZXUjQ4NkxkTEoxbUxCOHNYQzR6NnFEQ
 export const TOKEN_URL = "https://oauth2.googleapis.com/token";
 
 export const ANTIGRAVITY_ENDPOINTS = [
-	"https://daily-cloudcode-pa.sandbox.googleapis.com",
-	"https://autopush-cloudcode-pa.sandbox.googleapis.com",
 	"https://cloudcode-pa.googleapis.com",
 ] as const;