@askalf/dario 3.4.6 → 3.5.0

package/dist/proxy.js

@@ -7,6 +7,9 @@ import { homedir } from 'node:os';
 import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 import { buildCCRequest, reverseMapResponse } from './cc-template.js';
+import { AccountPool, parseRateLimits } from './pool.js';
+import { Analytics } from './analytics.js';
+import { loadAllAccounts, loadAccount, refreshAccountToken } from './accounts.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
 const DEFAULT_PORT = 3456;
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB — generous for large prompts, prevents abuse
@@ -321,11 +324,59 @@ export async function startProxy(opts = {}) {
     const host = opts.host ?? process.env.DARIO_HOST ?? DEFAULT_HOST;
     const verbose = opts.verbose ?? false;
     const passthrough = opts.passthrough ?? false;
-    // Verify auth before starting
-    const status = await getStatus();
-    if (!status.authenticated) {
-        console.error('[dario] Not authenticated. Run `dario login` first.');
-        process.exit(1);
+    // Multi-account pool — activated when ~/.dario/accounts/ has 2+ entries.
+    // Single-account dario keeps its existing code path unchanged.
+    const accountsList = await loadAllAccounts();
+    const pool = accountsList.length >= 2 ? new AccountPool() : null;
+    const analytics = pool ? new Analytics() : null;
+    let status;
+    if (pool) {
+        for (const acc of accountsList) {
+            pool.add(acc.alias, {
+                accessToken: acc.accessToken,
+                refreshToken: acc.refreshToken,
+                expiresAt: acc.expiresAt,
+                deviceId: acc.deviceId,
+                accountUuid: acc.accountUuid,
+            });
+        }
+        console.log(`  Pool mode: ${accountsList.length} accounts loaded`);
+        // Background refresh — keep every account's token fresh without blocking requests
+        const refreshInterval = setInterval(async () => {
+            for (const acc of pool.all()) {
+                if (acc.expiresAt < Date.now() + 45 * 60 * 1000) {
+                    try {
+                        const saved = await loadAccount(acc.alias);
+                        if (!saved)
+                            continue;
+                        const refreshed = await refreshAccountToken(saved);
+                        pool.updateTokens(acc.alias, refreshed.accessToken, refreshed.refreshToken, refreshed.expiresAt);
+                    }
+                    catch (err) {
+                        console.error(`[dario] Background refresh failed for ${acc.alias}: ${err instanceof Error ? err.message : err}`);
+                    }
+                }
+            }
+        }, 15 * 60 * 1000);
+        refreshInterval.unref();
+        // Pool mode doesn't check single-account status — compute a placeholder
+        // for the startup banner using the pool's earliest expiry.
+        const earliest = Math.min(...pool.all().map(a => a.expiresAt));
+        const msLeft = Math.max(0, earliest - Date.now());
+        status = {
+            authenticated: true,
+            status: 'healthy',
+            expiresAt: earliest,
+            expiresIn: `${Math.floor(msLeft / 3600000)}h ${Math.floor((msLeft % 3600000) / 60000)}m`,
+        };
+    }
+    else {
+        // Single-account mode — existing auth check
+        status = await getStatus();
+        if (!status.authenticated) {
+            console.error('[dario] Not authenticated. Run `dario login` first.');
+            process.exit(1);
+        }
     }
     const cliVersion = detectCliVersion();
     const modelOverride = opts.model ? (MODEL_ALIASES[opts.model] ?? opts.model) : null;
@@ -433,6 +484,39 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify(s));
             return;
         }
+        // Pool status endpoint — shows loaded accounts, headroom, and the
+        // account that would be selected next. Read-only; mutation flows through
+        // the `dario accounts` CLI, not HTTP.
+        if (urlPath === '/accounts' && req.method === 'GET') {
+            if (!pool) {
+                res.writeHead(200, JSON_HEADERS);
+                res.end(JSON.stringify({ mode: 'single-account', accounts: 0 }));
+                return;
+            }
+            const accounts = pool.all().map(a => ({
+                alias: a.alias,
+                util5h: a.rateLimit.util5h,
+                util7d: a.rateLimit.util7d,
+                claim: a.rateLimit.claim,
+                status: a.rateLimit.status,
+                requestCount: a.requestCount,
+                expiresInMs: Math.max(0, a.expiresAt - Date.now()),
+            }));
+            res.writeHead(200, JSON_HEADERS);
+            res.end(JSON.stringify({ mode: 'pool', ...pool.status(), accounts }));
+            return;
+        }
+        // Analytics endpoint — request history + burn-rate summary (pool mode only).
+        if (urlPath === '/analytics' && req.method === 'GET') {
+            if (!analytics) {
+                res.writeHead(200, JSON_HEADERS);
+                res.end(JSON.stringify({ mode: 'single-account', note: 'Analytics are only collected in pool mode.' }));
+                return;
+            }
+            res.writeHead(200, JSON_HEADERS);
+            res.end(JSON.stringify(analytics.summary()));
+            return;
+        }
         if (urlPath === '/v1/models' && req.method === 'GET') {
             requestCount++;
             res.writeHead(200, { ...JSON_HEADERS, 'Access-Control-Allow-Origin': corsOrigin });
@@ -465,7 +549,26 @@ export async function startProxy(opts = {}) {
         let onClientClose = null;
         let upstreamAbortReason = null;
         try {
-            const accessToken = await getAccessToken();
+            // Pool mode: select an account by headroom. Single-account mode:
+            // fall through to getAccessToken() exactly as before. Request-path
+            // 429 failover (retry with the next-best account before returning a
+            // rate-limit error to the client) lands in v3.5.1 — this release
+            // ships the pool scaffolding and headroom-aware selection across
+            // requests, not within a single 429 retry.
+            let poolAccount = null;
+            let accessToken;
+            if (pool) {
+                poolAccount = pool.select();
+                if (!poolAccount) {
+                    res.writeHead(503, JSON_HEADERS);
+                    res.end(JSON.stringify({ error: 'No accounts available in pool' }));
+                    return;
+                }
+                accessToken = poolAccount.accessToken;
+            }
+            else {
+                accessToken = await getAccessToken();
+            }
             // Read request body with size limit and timeout (prevents slow-loris)
             const chunks = [];
             let totalBytes = 0;
@@ -511,7 +614,10 @@ export async function startProxy(opts = {}) {
                         const fullVersion = `${cliVersion}.${buildTag}`;
                         const billingTag = `x-anthropic-billing-header: cc_version=${fullVersion}; cc_entrypoint=cli; cch=${cch};`;
                         const CACHE_1H = { type: 'ephemeral', ttl: '1h' };
-                        const { body: ccBody, toolMap } = buildCCRequest(r, billingTag, CACHE_1H, { deviceId: identity.deviceId, accountUuid: identity.accountUuid, sessionId: SESSION_ID }, { preserveTools: opts.preserveTools ?? false });
+                        const bodyIdentity = poolAccount
+                            ? poolAccount.identity
+                            : { deviceId: identity.deviceId, accountUuid: identity.accountUuid, sessionId: SESSION_ID };
+                        const { body: ccBody, toolMap } = buildCCRequest(r, billingTag, CACHE_1H, bodyIdentity, { preserveTools: opts.preserveTools ?? false });
                         // Store tool map for response reverse-mapping
                         ccToolMap = toolMap;
                         // Replace request body entirely with CC template
@@ -555,12 +661,16 @@ export async function startProxy(opts = {}) {
                 await new Promise(r => setTimeout(r, MIN_REQUEST_INTERVAL_MS - elapsed));
             }
             lastRequestTime = Date.now();
-            // Rotate session ID per request — fresh UUID avoids persistent-session fingerprinting
-            SESSION_ID = randomUUID();
+            // Rotate session ID per request — fresh UUID avoids persistent-session fingerprinting.
+            // Pool mode uses the per-account identity.sessionId which is stable across
+            // a given account's lifetime; single-account mode rotates per request.
+            if (!poolAccount)
+                SESSION_ID = randomUUID();
+            const outboundSessionId = poolAccount ? poolAccount.identity.sessionId : SESSION_ID;
             const headers = {
                 ...staticHeaders,
                 'Authorization': `Bearer ${accessToken}`,
-                'x-claude-code-session-id': SESSION_ID,
+                'x-claude-code-session-id': outboundSessionId,
                 'anthropic-version': passthrough ? (req.headers['anthropic-version'] || '2023-06-01') : '2023-06-01',
                 'anthropic-beta': beta,
                 'x-client-request-id': randomUUID(),
@@ -595,6 +705,18 @@ export async function startProxy(opts = {}) {
                 body: finalBody ? new Uint8Array(finalBody) : undefined,
                 signal: upstreamAbort.signal,
             });
+            // Pool mode: capture rate-limit snapshot from the response. parseRateLimits
+            // returns status='rejected' on 429, which makes the next `select()` call
+            // route traffic away from this account until it resets.
+            if (pool && poolAccount) {
+                const snapshot = parseRateLimits(upstream.headers);
+                if (upstream.status === 429) {
+                    pool.markRejected(poolAccount.alias, snapshot);
+                }
+                else {
+                    pool.updateRateLimits(poolAccount.alias, snapshot);
+                }
+            }
             // Auto-retry without context-1m if it triggers a long-context billing error.
             // Anthropic returns this as either 400 ("long context beta is not yet available
             // for this subscription") or 429 ("Extra usage is required for long context
@@ -622,6 +744,16 @@ export async function startProxy(opts = {}) {
                     // Use the retry response from here on — peeked body is now stale
                     upstream = retry;
                     peekedBody = null;
+                    // Pool mode: re-capture after the context-1m retry as the snapshot may have changed.
+                    if (pool && poolAccount) {
+                        const retrySnapshot = parseRateLimits(upstream.headers);
+                        if (upstream.status === 429) {
+                            pool.markRejected(poolAccount.alias, retrySnapshot);
+                        }
+                        else {
+                            pool.updateRateLimits(poolAccount.alias, retrySnapshot);
+                        }
+                    }
                 }
                 else if (upstream.status === 429) {
                     // Not a context-1m issue — return enriched 429 directly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.4.6",
+  "version": "3.5.0",
   "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
   "type": "module",
   "bin": {