@askalf/dario 3.4.5 → 3.5.0

package/dist/accounts.d.ts

@@ -0,0 +1,23 @@
+export interface AccountCredentials {
+    alias: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    scopes: string[];
+    deviceId: string;
+    accountUuid: string;
+}
+export declare function listAccountAliases(): Promise<string[]>;
+export declare function loadAccount(alias: string): Promise<AccountCredentials | null>;
+export declare function loadAllAccounts(): Promise<AccountCredentials[]>;
+export declare function saveAccount(creds: AccountCredentials): Promise<void>;
+export declare function removeAccount(alias: string): Promise<boolean>;
+/** Refresh an account's OAuth token using dario's auto-detected CC OAuth config. */
+export declare function refreshAccountToken(creds: AccountCredentials): Promise<AccountCredentials>;
+/**
+ * Interactive OAuth flow that adds a new account to the pool. Uses dario's
+ * auto-detected CC OAuth config (same scanner the single-account path uses).
+ * Saves to `~/.dario/accounts/<alias>.json` on success.
+ */
+export declare function addAccountViaOAuth(alias: string): Promise<AccountCredentials>;
+export declare function getAccountsDir(): string;

package/dist/accounts.js

@@ -0,0 +1,253 @@
+/**
+ * Multi-account credential storage.
+ *
+ * Accounts live at `~/.dario/accounts/<alias>.json`. Single-account dario
+ * still uses `~/.dario/credentials.json` and does not touch this module.
+ * When `~/.dario/accounts/` contains 2+ files the proxy activates pool mode
+ * (see pool.ts). Each account has its own independent OAuth lifecycle and
+ * can refresh without affecting the others.
+ *
+ * OAuth config (client_id, scopes, authorize URL, token URL) comes from
+ * dario's cc-oauth-detect scanner — the same source the single-account
+ * path already uses. No hardcoded client IDs here.
+ */
+import { readFile, writeFile, mkdir, readdir, unlink, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID, randomBytes, createHash } from 'node:crypto';
+import { createServer } from 'node:http';
+import { detectCCOAuthConfig } from './cc-oauth-detect.js';
+const DARIO_DIR = join(homedir(), '.dario');
+const ACCOUNTS_DIR = join(DARIO_DIR, 'accounts');
+async function ensureDir() {
+    await mkdir(ACCOUNTS_DIR, { recursive: true, mode: 0o700 });
+}
+export async function listAccountAliases() {
+    try {
+        await ensureDir();
+        const entries = await readdir(ACCOUNTS_DIR);
+        return entries.filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''));
+    }
+    catch {
+        return [];
+    }
+}
+export async function loadAccount(alias) {
+    const path = join(ACCOUNTS_DIR, `${alias}.json`);
+    try {
+        const raw = await readFile(path, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadAllAccounts() {
+    const aliases = await listAccountAliases();
+    const loaded = await Promise.all(aliases.map(a => loadAccount(a)));
+    return loaded.filter((a) => a !== null);
+}
+export async function saveAccount(creds) {
+    await ensureDir();
+    const path = join(ACCOUNTS_DIR, `${creds.alias}.json`);
+    const tmp = `${path}.tmp.${randomBytes(4).toString('hex')}`;
+    await writeFile(tmp, JSON.stringify(creds, null, 2), { mode: 0o600 });
+    try {
+        await rename(tmp, path);
+    }
+    catch {
+        // Windows can fail renames on busy files — fall back to direct write
+        await writeFile(path, JSON.stringify(creds, null, 2), { mode: 0o600 });
+        try {
+            await unlink(tmp);
+        }
+        catch { /* ignore */ }
+    }
+}
+export async function removeAccount(alias) {
+    const path = join(ACCOUNTS_DIR, `${alias}.json`);
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Detect deviceId + accountUuid from an installed Claude Code. */
+async function detectClaudeIdentity() {
+    const paths = [
+        join(homedir(), '.claude', '.claude.json'),
+        join(homedir(), '.claude.json'),
+    ];
+    for (const p of paths) {
+        try {
+            const raw = await readFile(p, 'utf-8');
+            const data = JSON.parse(raw);
+            const deviceId = data.userID || data.installId || data.deviceId || '';
+            const accountUuid = data.oauthAccount?.accountUuid || data.accountUuid || '';
+            if (deviceId || accountUuid) {
+                return { deviceId, accountUuid };
+            }
+        }
+        catch { /* try next */ }
+    }
+    return null;
+}
+/** Refresh an account's OAuth token using dario's auto-detected CC OAuth config. */
+export async function refreshAccountToken(creds) {
+    const cfg = await detectCCOAuthConfig();
+    const res = await fetch(cfg.tokenUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: creds.refreshToken,
+            client_id: cfg.clientId,
+        }).toString(),
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok) {
+        const errBody = await res.text().catch(() => '');
+        throw new Error(`Refresh failed for ${creds.alias} (${res.status}): ${errBody.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    const updated = {
+        ...creds,
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresAt: Date.now() + data.expires_in * 1000,
+    };
+    await saveAccount(updated);
+    return updated;
+}
+// ── PKCE OAuth flow for adding a new account ────────────────────────────
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function generatePKCE() {
+    const codeVerifier = base64url(randomBytes(32));
+    const codeChallenge = base64url(createHash('sha256').update(codeVerifier).digest());
+    return { codeVerifier, codeChallenge };
+}
+function openBrowser(url) {
+    const { exec } = require('node:child_process');
+    const cmd = process.platform === 'win32' ? `start "" "${url}"`
+        : process.platform === 'darwin' ? `open "${url}"`
+            : `xdg-open "${url}"`;
+    exec(cmd, () => { });
+}
+/**
+ * Interactive OAuth flow that adds a new account to the pool. Uses dario's
+ * auto-detected CC OAuth config (same scanner the single-account path uses).
+ * Saves to `~/.dario/accounts/<alias>.json` on success.
+ */
+export async function addAccountViaOAuth(alias) {
+    const cfg = await detectCCOAuthConfig();
+    const { codeVerifier, codeChallenge } = generatePKCE();
+    const state = base64url(randomBytes(16));
+    return new Promise((resolve, reject) => {
+        let port = 0;
+        const server = createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url || '', `http://${req.headers.host || 'localhost'}`);
+                if (url.pathname !== '/callback') {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                const code = url.searchParams.get('code');
+                const returnedState = url.searchParams.get('state');
+                if (!code) {
+                    res.writeHead(400);
+                    res.end('No authorization code received');
+                    server.close();
+                    reject(new Error('No authorization code received'));
+                    return;
+                }
+                if (returnedState !== state) {
+                    res.writeHead(400);
+                    res.end('Invalid state parameter');
+                    server.close();
+                    reject(new Error('OAuth state mismatch — possible CSRF'));
+                    return;
+                }
+                res.writeHead(302, {
+                    Location: 'https://platform.claude.com/oauth/code/success?app=claude-code',
+                });
+                res.end();
+                server.close();
+                // Exchange code for tokens
+                const tokenRes = await fetch(cfg.tokenUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        grant_type: 'authorization_code',
+                        client_id: cfg.clientId,
+                        code,
+                        redirect_uri: `http://localhost:${port}/callback`,
+                        code_verifier: codeVerifier,
+                        state,
+                    }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!tokenRes.ok) {
+                    const body = await tokenRes.text().catch(() => '');
+                    throw new Error(`Token exchange failed (${tokenRes.status}): ${body.slice(0, 200)}`);
+                }
+                const tokens = await tokenRes.json();
+                // Prefer CC identity if installed; otherwise generate fresh IDs.
+                const identity = (await detectClaudeIdentity()) ?? {
+                    deviceId: randomUUID(),
+                    accountUuid: randomUUID(),
+                };
+                const creds = {
+                    alias,
+                    accessToken: tokens.access_token,
+                    refreshToken: tokens.refresh_token,
+                    expiresAt: Date.now() + tokens.expires_in * 1000,
+                    scopes: tokens.scope?.split(' ') ?? cfg.scopes.split(' '),
+                    deviceId: identity.deviceId,
+                    accountUuid: identity.accountUuid,
+                };
+                await saveAccount(creds);
+                resolve(creds);
+            }
+            catch (err) {
+                server.close();
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        server.listen(0, 'localhost', () => {
+            const addr = server.address();
+            port = typeof addr === 'object' && addr ? addr.port : 0;
+            const params = new URLSearchParams({
+                code: 'true',
+                client_id: cfg.clientId,
+                response_type: 'code',
+                redirect_uri: `http://localhost:${port}/callback`,
+                scope: cfg.scopes,
+                code_challenge: codeChallenge,
+                code_challenge_method: 'S256',
+                state,
+            });
+            const authUrl = `${cfg.authorizeUrl}?${params.toString()}`;
+            console.log(`  Opening browser to add account "${alias}"...`);
+            console.log(`  If the browser didn't open, visit:`);
+            console.log(`  ${authUrl}`);
+            console.log();
+            openBrowser(authUrl);
+        });
+        server.on('error', (err) => {
+            reject(new Error(`Failed to start OAuth callback server: ${err.message}`));
+        });
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('OAuth flow timed out after 5 minutes. Try `dario accounts add` again.'));
+        }, 300_000);
+        timeout.unref();
+    });
+}
+export function getAccountsDir() {
+    return ACCOUNTS_DIR;
+}

package/dist/analytics.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Token analytics — per-request billing tracking, utilization trends,
+ * window exhaustion predictions, cost estimation.
+ *
+ * In-memory rolling window; exposed via the /analytics endpoint when
+ * pool mode is active.
+ */
+export interface RequestRecord {
+    timestamp: number;
+    account: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreateTokens: number;
+    thinkingTokens: number;
+    claim: string;
+    util5h: number;
+    util7d: number;
+    overageUtil: number;
+    latencyMs: number;
+    status: number;
+    isStream: boolean;
+    isOpenAI: boolean;
+}
+export declare class Analytics {
+    private records;
+    private maxRecords;
+    constructor(maxRecords?: number);
+    record(r: RequestRecord): void;
+    /** Parse usage from a non-streaming Anthropic response body. */
+    static parseUsage(body: Record<string, unknown>): {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheCreateTokens: number;
+        thinkingTokens: number;
+        model: string;
+    };
+    summary(windowMinutes?: number): AnalyticsSummary;
+    private computeStats;
+    private perAccountStats;
+    private perModelStats;
+    private utilizationTrend;
+    private predict;
+}
+interface PerAccountStat {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCost: number;
+    currentUtil5h: number;
+    currentUtil7d: number;
+    lastClaim: string;
+}
+interface PerModelStat {
+    requests: number;
+    avgInputTokens: number;
+    avgOutputTokens: number;
+    avgThinkingTokens: number;
+    estimatedCost: number;
+}
+export interface AnalyticsSummary {
+    window: {
+        minutes: number;
+        requests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalThinkingTokens: number;
+        estimatedCost: number;
+        avgLatencyMs: number;
+        errorRate: number;
+        claimBreakdown: Record<string, number>;
+    };
+    allTime: {
+        requests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalThinkingTokens: number;
+        estimatedCost: number;
+        avgLatencyMs: number;
+        errorRate: number;
+        claimBreakdown: Record<string, number>;
+    };
+    perAccount: Record<string, PerAccountStat>;
+    perModel: Record<string, PerModelStat>;
+    utilization: Array<{
+        timestamp: number;
+        avgUtil5h: number;
+        avgUtil7d: number;
+        requests: number;
+    }>;
+    predictions: {
+        estimatedExhaustionMinutes: number | null;
+        tokenBurnRate: number;
+        costBurnRate: number;
+    };
+}
+export {};

package/dist/analytics.js

@@ -0,0 +1,198 @@
+/**
+ * Token analytics — per-request billing tracking, utilization trends,
+ * window exhaustion predictions, cost estimation.
+ *
+ * In-memory rolling window; exposed via the /analytics endpoint when
+ * pool mode is active.
+ */
+// Anthropic pricing (per 1M tokens, USD). Not authoritative — used for
+// rough burn-rate display in the /analytics summary.
+const PRICING = {
+    'claude-opus-4-6': { input: 15, output: 75, cacheRead: 1.5, cacheCreate: 18.75 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cacheRead: 0.3, cacheCreate: 3.75 },
+    'claude-haiku-4-5': { input: 0.8, output: 4, cacheRead: 0.08, cacheCreate: 1 },
+};
+function estimateCost(record) {
+    const p = PRICING[record.model] ?? PRICING['claude-sonnet-4-6'];
+    return ((record.inputTokens * p.input) +
+        (record.outputTokens * p.output) +
+        (record.cacheReadTokens * p.cacheRead) +
+        (record.cacheCreateTokens * p.cacheCreate)) / 1_000_000;
+}
+export class Analytics {
+    records = [];
+    maxRecords;
+    constructor(maxRecords = 10_000) {
+        this.maxRecords = maxRecords;
+    }
+    record(r) {
+        this.records.push(r);
+        if (this.records.length > this.maxRecords) {
+            this.records = this.records.slice(-this.maxRecords);
+        }
+    }
+    /** Parse usage from a non-streaming Anthropic response body. */
+    static parseUsage(body) {
+        const u = body.usage;
+        const content = body.content;
+        const thinkingChars = content
+            ?.filter(b => b.type === 'thinking')
+            .reduce((s, b) => s + (b.thinking?.length ?? 0), 0) ?? 0;
+        const thinkingTokens = Math.round(thinkingChars / 4);
+        return {
+            inputTokens: u?.input_tokens ?? 0,
+            outputTokens: u?.output_tokens ?? 0,
+            cacheReadTokens: u?.cache_read_input_tokens ?? 0,
+            cacheCreateTokens: u?.cache_creation_input_tokens ?? 0,
+            thinkingTokens,
+            model: body.model ?? 'unknown',
+        };
+    }
+    summary(windowMinutes = 60) {
+        const cutoff = Date.now() - windowMinutes * 60_000;
+        const recent = this.records.filter(r => r.timestamp >= cutoff);
+        const allTime = this.records;
+        return {
+            window: {
+                minutes: windowMinutes,
+                requests: recent.length,
+                ...this.computeStats(recent),
+            },
+            allTime: {
+                requests: allTime.length,
+                ...this.computeStats(allTime),
+            },
+            perAccount: this.perAccountStats(recent),
+            perModel: this.perModelStats(recent),
+            utilization: this.utilizationTrend(recent),
+            predictions: this.predict(recent),
+        };
+    }
+    computeStats(records) {
+        if (records.length === 0) {
+            return {
+                totalInputTokens: 0, totalOutputTokens: 0, totalThinkingTokens: 0,
+                estimatedCost: 0, avgLatencyMs: 0, errorRate: 0,
+                claimBreakdown: {},
+            };
+        }
+        const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
+        const totalOutput = records.reduce((s, r) => s + r.outputTokens, 0);
+        const totalThinking = records.reduce((s, r) => s + r.thinkingTokens, 0);
+        const cost = records.reduce((s, r) => s + estimateCost(r), 0);
+        const avgLatency = records.reduce((s, r) => s + r.latencyMs, 0) / records.length;
+        const errors = records.filter(r => r.status >= 400).length;
+        const claims = {};
+        for (const r of records) {
+            claims[r.claim] = (claims[r.claim] ?? 0) + 1;
+        }
+        return {
+            totalInputTokens: totalInput,
+            totalOutputTokens: totalOutput,
+            totalThinkingTokens: totalThinking,
+            estimatedCost: Math.round(cost * 10000) / 10000,
+            avgLatencyMs: Math.round(avgLatency),
+            errorRate: Math.round((errors / records.length) * 10000) / 10000,
+            claimBreakdown: claims,
+        };
+    }
+    perAccountStats(records) {
+        const grouped = {};
+        for (const r of records) {
+            (grouped[r.account] ??= []).push(r);
+        }
+        const result = {};
+        for (const [account, recs] of Object.entries(grouped)) {
+            const last = recs[recs.length - 1];
+            result[account] = {
+                requests: recs.length,
+                inputTokens: recs.reduce((s, r) => s + r.inputTokens, 0),
+                outputTokens: recs.reduce((s, r) => s + r.outputTokens, 0),
+                estimatedCost: Math.round(recs.reduce((s, r) => s + estimateCost(r), 0) * 10000) / 10000,
+                currentUtil5h: last.util5h,
+                currentUtil7d: last.util7d,
+                lastClaim: last.claim,
+            };
+        }
+        return result;
+    }
+    perModelStats(records) {
+        const grouped = {};
+        for (const r of records) {
+            (grouped[r.model] ??= []).push(r);
+        }
+        const result = {};
+        for (const [model, recs] of Object.entries(grouped)) {
+            result[model] = {
+                requests: recs.length,
+                avgInputTokens: Math.round(recs.reduce((s, r) => s + r.inputTokens, 0) / recs.length),
+                avgOutputTokens: Math.round(recs.reduce((s, r) => s + r.outputTokens, 0) / recs.length),
+                avgThinkingTokens: Math.round(recs.reduce((s, r) => s + r.thinkingTokens, 0) / recs.length),
+                estimatedCost: Math.round(recs.reduce((s, r) => s + estimateCost(r), 0) * 10000) / 10000,
+            };
+        }
+        return result;
+    }
+    utilizationTrend(records) {
+        if (records.length === 0)
+            return [];
+        const bucketMs = 5 * 60_000;
+        const buckets = new Map();
+        for (const r of records) {
+            const key = Math.floor(r.timestamp / bucketMs) * bucketMs;
+            const existing = buckets.get(key);
+            if (existing) {
+                existing.push(r);
+            }
+            else {
+                buckets.set(key, [r]);
+            }
+        }
+        return [...buckets.entries()]
+            .sort(([a], [b]) => a - b)
+            .map(([ts, recs]) => ({
+            timestamp: ts,
+            avgUtil5h: Math.round(recs.reduce((s, r) => s + r.util5h, 0) / recs.length * 100) / 100,
+            avgUtil7d: Math.round(recs.reduce((s, r) => s + r.util7d, 0) / recs.length * 100) / 100,
+            requests: recs.length,
+        }));
+    }
+    predict(records) {
+        if (records.length < 3) {
+            return { estimatedExhaustionMinutes: null, tokenBurnRate: 0, costBurnRate: 0 };
+        }
+        const sorted = [...records].sort((a, b) => a.timestamp - b.timestamp);
+        const first = sorted[0];
+        const last = sorted[sorted.length - 1];
+        const durationMin = (last.timestamp - first.timestamp) / 60_000;
+        if (durationMin < 1) {
+            return { estimatedExhaustionMinutes: null, tokenBurnRate: 0, costBurnRate: 0 };
+        }
+        const totalTokens = sorted.reduce((s, r) => s + r.inputTokens + r.outputTokens, 0);
+        const totalCost = sorted.reduce((s, r) => s + estimateCost(r), 0);
+        const tokenBurnRate = totalTokens / durationMin;
+        const costBurnRate = (totalCost / durationMin) * 60;
+        const currentUtil = last.util5h;
+        if (currentUtil >= 0.95) {
+            return {
+                estimatedExhaustionMinutes: 0,
+                tokenBurnRate: Math.round(tokenBurnRate),
+                costBurnRate: Math.round(costBurnRate * 100) / 100,
+            };
+        }
+        const utilGrowthRate = (last.util5h - first.util5h) / durationMin;
+        if (utilGrowthRate <= 0) {
+            return {
+                estimatedExhaustionMinutes: null,
+                tokenBurnRate: Math.round(tokenBurnRate),
+                costBurnRate: Math.round(costBurnRate * 100) / 100,
+            };
+        }
+        const minutesToExhaustion = (1.0 - currentUtil) / utilGrowthRate;
+        return {
+            estimatedExhaustionMinutes: Math.round(minutesToExhaustion),
+            tokenBurnRate: Math.round(tokenBurnRate),
+            costBurnRate: Math.round(costBurnRate * 100) / 100,
+        };
+    }
+}