@askalf/dario 3.38.6 → 4.0.1

package/dist/live-fingerprint.js

@@ -777,7 +777,7 @@ export function _resetInstalledVersionProbeForTest() {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.142',
+    maxTested: '2.1.143',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/proxy.js

@@ -567,7 +567,12 @@ export async function startProxy(opts = {}) {
     // eventual `7d_opus`) doesn't slip past unnoticed. Pure observability —
     // routing already handles unknown families generically.
     const seenPerModelBuckets = new Set();
-    const analytics = pool ? new Analytics() : null;
+    // v4 promotion: analytics is always-on so the TUI's Analytics + Hits
+    // tabs work in both pool and single-account mode. Pre-v4 this was
+    // `pool ? new Analytics() : null` — that gated the /analytics
+    // endpoint, but burn-rate / per-request visibility is useful for
+    // single-account users too.
+    const analytics = new Analytics();
     let status;
     if (pool) {
         for (const acc of accountsList) {
@@ -912,17 +917,70 @@ export async function startProxy(opts = {}) {
             }));
             return;
         }
-        // Analytics endpoint — request history + burn-rate summary (pool mode only).
+        // Analytics endpoint — rolling-window summary + burn-rate snapshot.
+        // Always-on as of v4 (pre-v4 this was gated to pool mode).
         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;
         }
+        // Analytics live stream — SSE of new RequestRecord JSON, one event
+        // per record as it lands. Drives the v4 TUI's Hits tab. Sends a
+        // backlog of the most-recent 50 records on connect so a freshly-
+        // attached subscriber sees state immediately, then live-tails.
+        //
+        // Auth: same as /analytics — no auth in single-account default mode;
+        // the proxy listens on loopback by default. DARIO_API_KEY users
+        // get rejected by the earlier auth gate up the handler chain.
+        //
+        // Disconnect handling: the 'close' event on `req` removes our
+        // listener from the Analytics EventEmitter so we don't leak.
+        if (urlPath === '/analytics/stream' && req.method === 'GET') {
+            // SECURITY_HEADERS sets Cache-Control: no-store; SSE wants
+            // no-cache, no-transform. Spread SECURITY_HEADERS first then
+            // override the cache directive — order matters since spread
+            // overlap is last-wins in JS.
+            const sseHeaders = {
+                ...SECURITY_HEADERS,
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache, no-transform',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no', // disable any proxy buffering
+                'Access-Control-Allow-Origin': corsOrigin,
+            };
+            res.writeHead(200, sseHeaders);
+            // Backlog: replay recent records so a TUI attaching mid-session
+            // sees something. 50 is a soft default; lots of room to send more
+            // since this is one-time on connect.
+            for (const past of analytics.recent(50)) {
+                res.write(`data: ${JSON.stringify(past)}\n\n`);
+            }
+            // Live tail
+            const onRecord = (r) => {
+                // Use try/catch so a broken socket (peer hung up between events)
+                // doesn't crash the request hot-path — Analytics already wraps
+                // its emit in try/catch but the .write itself can also throw.
+                try {
+                    res.write(`data: ${JSON.stringify(r)}\n\n`);
+                }
+                catch { /* ignored */ }
+            };
+            analytics.on('record', onRecord);
+            // Heartbeat every 25s — SSE comments are ignored by clients but
+            // keep middle-boxes (CDNs, dev-proxies) from closing the pipe.
+            const heartbeat = setInterval(() => {
+                try {
+                    res.write(`: heartbeat ${Date.now()}\n\n`);
+                }
+                catch { /* ignored */ }
+            }, 25_000);
+            heartbeat.unref?.();
+            req.on('close', () => {
+                analytics.off('record', onRecord);
+                clearInterval(heartbeat);
+            });
+            return;
+        }
         if (urlPath === '/v1/models' && req.method === 'GET') {
             requestCount++;
             res.writeHead(200, { ...JSON_HEADERS, 'Access-Control-Allow-Origin': corsOrigin });
@@ -1585,12 +1643,19 @@ export async function startProxy(opts = {}) {
                             }
                         }
                         requestCount++;
-                        if (analytics && poolAccount) {
+                        // v4: analytics is always-on. Pool mode supplies the rate-limit
+                        // snapshot from `poolAccount.rateLimit` (already authoritative);
+                        // single-account mode parses it from the upstream response
+                        // headers on the spot so the TUI's Hits feed shows the same
+                        // bucket / utilization fields in both modes.
+                        {
+                            const rl = poolAccount?.rateLimit ?? parseRateLimits(upstream.headers);
                             analytics.record({
-                                timestamp: Date.now(), account: poolAccount.alias, model: requestModel,
+                                timestamp: Date.now(),
+                                account: poolAccount?.alias ?? ACCOUNT_KEY_SINGLE,
+                                model: requestModel,
                                 inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0,
-                                claim: poolAccount.rateLimit.claim, util5h: poolAccount.rateLimit.util5h,
-                                util7d: poolAccount.rateLimit.util7d, overageUtil: poolAccount.rateLimit.overageUtil,
+                                claim: rl.claim, util5h: rl.util5h, util7d: rl.util7d, overageUtil: rl.overageUtil,
                                 latencyMs: Date.now() - startTime, status: 429, isStream: false, isOpenAI,
                             });
                         }
@@ -1669,12 +1734,14 @@ export async function startProxy(opts = {}) {
                         }
                     }
                     requestCount++;
-                    if (analytics && poolAccount) {
+                    {
+                        const rl = poolAccount?.rateLimit ?? parseRateLimits(upstream.headers);
                         analytics.record({
-                            timestamp: Date.now(), account: poolAccount.alias, model: requestModel,
+                            timestamp: Date.now(),
+                            account: poolAccount?.alias ?? ACCOUNT_KEY_SINGLE,
+                            model: requestModel,
                             inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0,
-                            claim: poolAccount.rateLimit.claim, util5h: poolAccount.rateLimit.util5h,
-                            util7d: poolAccount.rateLimit.util7d, overageUtil: poolAccount.rateLimit.overageUtil,
+                            claim: rl.claim, util5h: rl.util5h, util7d: rl.util7d, overageUtil: rl.overageUtil,
                             latencyMs: Date.now() - startTime, status: 429, isStream: false, isOpenAI,
                         });
                     }
@@ -1880,14 +1947,16 @@ export async function startProxy(opts = {}) {
                     lastResponseTime = Date.now();
                     lastResponseTokens = streamOutputTokens;
                 }
-                if (analytics && poolAccount) {
+                {
+                    const rl = poolAccount?.rateLimit ?? parseRateLimits(upstream.headers);
                     analytics.record({
-                        timestamp: Date.now(), account: poolAccount.alias, model: requestModel,
+                        timestamp: Date.now(),
+                        account: poolAccount?.alias ?? ACCOUNT_KEY_SINGLE,
+                        model: requestModel,
                         inputTokens: streamInputTokens, outputTokens: streamOutputTokens,
                         cacheReadTokens: streamCacheReadTokens, cacheCreateTokens: streamCacheCreateTokens,
                         thinkingTokens: 0,
-                        claim: poolAccount.rateLimit.claim, util5h: poolAccount.rateLimit.util5h,
-                        util7d: poolAccount.rateLimit.util7d, overageUtil: poolAccount.rateLimit.overageUtil,
+                        claim: rl.claim, util5h: rl.util5h, util7d: rl.util7d, overageUtil: rl.overageUtil,
                         latencyMs: Date.now() - startTime, status: upstream.status, isStream: true, isOpenAI,
                     });
                 }
@@ -1938,16 +2007,17 @@ export async function startProxy(opts = {}) {
                     lastResponseTime = Date.now();
                     lastResponseTokens = bufferedUsage?.outputTokens ?? 0;
                 }
-                if (analytics && poolAccount && bufferedUsage) {
+                if (bufferedUsage) {
                     try {
+                        const rl = poolAccount?.rateLimit ?? parseRateLimits(upstream.headers);
                         analytics.record({
-                            timestamp: Date.now(), account: poolAccount.alias,
+                            timestamp: Date.now(),
+                            account: poolAccount?.alias ?? ACCOUNT_KEY_SINGLE,
                             model: bufferedUsage.model || requestModel,
                             inputTokens: bufferedUsage.inputTokens, outputTokens: bufferedUsage.outputTokens,
                             cacheReadTokens: bufferedUsage.cacheReadTokens, cacheCreateTokens: bufferedUsage.cacheCreateTokens,
                             thinkingTokens: bufferedUsage.thinkingTokens,
-                            claim: poolAccount.rateLimit.claim, util5h: poolAccount.rateLimit.util5h,
-                            util7d: poolAccount.rateLimit.util7d, overageUtil: poolAccount.rateLimit.overageUtil,
+                            claim: rl.claim, util5h: rl.util5h, util7d: rl.util7d, overageUtil: rl.overageUtil,
                             latencyMs: Date.now() - startTime, status: upstream.status, isStream: false, isOpenAI,
                         });
                     }

package/dist/tui/app.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The TUI App — main render loop + lifecycle + key dispatch.
+ *
+ * The shape is deliberately simple: one render function (caller-
+ * supplied) that takes `state + dimensions` and returns the full frame
+ * as a string. The App drives the loop, manages stdin raw mode, handles
+ * resize events, and flushes one write per frame. Tabs (M4) are
+ * decoupled state machines that the caller's render() composes.
+ *
+ * Lifecycle invariants:
+ *
+ *   - Enters alt-screen on start, leaves on stop. The shell that
+ *     spawned dario sees its prior content restored when the TUI quits.
+ *   - Hides the cursor on start, restores it on stop. ALWAYS, even on
+ *     uncaught exceptions or SIGINT — we install signal + exit hooks.
+ *   - Sets stdin raw mode on start, restores it on stop.
+ *
+ * The hook chain is registered on process events; quit calls them all
+ * synchronously so no terminal state leaks out.
+ */
+import { type Key } from './input.js';
+export interface AppOptions<S> {
+    /**
+     * Initial state. The App holds a reference and re-renders when
+     * `setState` is called.
+     */
+    initialState: S;
+    /**
+     * Pure function: state + dimensions → full screen content.
+     * The App calls this on every redraw + flushes the returned string
+     * to stdout in a single write.
+     */
+    render: (state: S, dim: {
+        cols: number;
+        rows: number;
+    }) => string;
+    /**
+     * Key dispatch. Receives every parsed key from stdin (after the
+     * App has already handled global keys like Ctrl-C). Return a new
+     * state (or undefined for no change) — same shape as React's
+     * setState reducer.
+     */
+    onKey: (state: S, key: Key) => S | undefined;
+    /**
+     * Optional: called on every redraw after the new frame has been
+     * written. Used by tabs that have async data (e.g. SSE-fed Hits
+     * tab) to schedule periodic refreshes.
+     */
+    afterFrame?: (state: S) => void;
+    /**
+     * stdin / stdout — overridable for tests. Defaults to process.stdin
+     * and process.stdout.
+     */
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}
+export declare class App<S> {
+    private state;
+    private renderFn;
+    private keyFn;
+    private afterFrameFn?;
+    private stdin;
+    private stdout;
+    private cleanupFns;
+    private running;
+    private redrawScheduled;
+    constructor(opts: AppOptions<S>);
+    /**
+     * Replace state. If the new state differs from the old (shallow
+     * equality), schedule a redraw. Tabs use this both for synchronous
+     * key-driven updates and for async data arrivals (SSE 'record').
+     *
+     * The "differs" check is intentionally shallow — deep equality on
+     * potentially-large analytics records would be expensive and the
+     * caller almost always passes new object identity when it mutates.
+     * If you mutate state in place and don't change identity, the
+     * redraw won't fire (this is documented; sometimes desired).
+     */
+    setState(updater: Partial<S> | ((s: S) => S)): void;
+    /** Read-only state accessor — for callers that need to compute next state from current. */
+    getState(): S;
+    /**
+     * Start the TUI: enter alt-screen, hide cursor, raw stdin, attach
+     * resize listener, render once, then idle until stop() or process
+     * exit.
+     *
+     * Returns a Promise that resolves when stop() is called. Wires
+     * process exit / signal hooks so a Ctrl-C / kill leaves the
+     * terminal sane.
+     */
+    start(): Promise<void>;
+    /** Stop the TUI — restore terminal state and resolve the start() promise. */
+    stop(): void;
+    private scheduleRedraw;
+    private redraw;
+}

package/dist/tui/app.js

@@ -0,0 +1,178 @@
+/**
+ * The TUI App — main render loop + lifecycle + key dispatch.
+ *
+ * The shape is deliberately simple: one render function (caller-
+ * supplied) that takes `state + dimensions` and returns the full frame
+ * as a string. The App drives the loop, manages stdin raw mode, handles
+ * resize events, and flushes one write per frame. Tabs (M4) are
+ * decoupled state machines that the caller's render() composes.
+ *
+ * Lifecycle invariants:
+ *
+ *   - Enters alt-screen on start, leaves on stop. The shell that
+ *     spawned dario sees its prior content restored when the TUI quits.
+ *   - Hides the cursor on start, restores it on stop. ALWAYS, even on
+ *     uncaught exceptions or SIGINT — we install signal + exit hooks.
+ *   - Sets stdin raw mode on start, restores it on stop.
+ *
+ * The hook chain is registered on process events; quit calls them all
+ * synchronously so no terminal state leaks out.
+ */
+import { attachKeyHandler } from './input.js';
+import { clearScreen, enterAltScreen, leaveAltScreen, hideCursor, showCursor, } from './render.js';
+export class App {
+    state;
+    renderFn;
+    keyFn;
+    afterFrameFn;
+    stdin;
+    stdout;
+    cleanupFns = [];
+    running = false;
+    // Coalesce setState calls that arrive in the same tick — only one
+    // redraw per tick regardless of how many setStates fire.
+    redrawScheduled = false;
+    constructor(opts) {
+        this.state = opts.initialState;
+        this.renderFn = opts.render;
+        this.keyFn = opts.onKey;
+        this.afterFrameFn = opts.afterFrame;
+        this.stdin = opts.stdin ?? process.stdin;
+        this.stdout = opts.stdout ?? process.stdout;
+    }
+    /**
+     * Replace state. If the new state differs from the old (shallow
+     * equality), schedule a redraw. Tabs use this both for synchronous
+     * key-driven updates and for async data arrivals (SSE 'record').
+     *
+     * The "differs" check is intentionally shallow — deep equality on
+     * potentially-large analytics records would be expensive and the
+     * caller almost always passes new object identity when it mutates.
+     * If you mutate state in place and don't change identity, the
+     * redraw won't fire (this is documented; sometimes desired).
+     */
+    setState(updater) {
+        const next = typeof updater === 'function'
+            ? updater(this.state)
+            : { ...this.state, ...updater };
+        if (next !== this.state) {
+            this.state = next;
+            this.scheduleRedraw();
+        }
+    }
+    /** Read-only state accessor — for callers that need to compute next state from current. */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Start the TUI: enter alt-screen, hide cursor, raw stdin, attach
+     * resize listener, render once, then idle until stop() or process
+     * exit.
+     *
+     * Returns a Promise that resolves when stop() is called. Wires
+     * process exit / signal hooks so a Ctrl-C / kill leaves the
+     * terminal sane.
+     */
+    start() {
+        if (this.running)
+            throw new Error('TUI already running');
+        this.running = true;
+        // Enter alt-screen + hide cursor in one write so the terminal
+        // doesn't briefly show a normal screen with a hidden cursor.
+        this.stdout.write(enterAltScreen + hideCursor + clearScreen);
+        // Raw-mode key handler
+        try {
+            const detachKeys = attachKeyHandler(this.stdin, (key) => {
+                // Global keys handled by the App itself; everything else
+                // falls through to the user's onKey reducer.
+                if (key.name === 'printable' && key.ctrl && key.ch === 'c') {
+                    // Ctrl-C → quit
+                    this.stop();
+                    return;
+                }
+                if (key.name === 'printable' && key.ctrl && key.ch === 'l') {
+                    // Ctrl-L → forced redraw (no state change, but force a
+                    // re-render which also re-clears the screen — clears any
+                    // garbage left by misbehaving processes that wrote past the
+                    // alt-screen boundary)
+                    this.scheduleRedraw(true);
+                    return;
+                }
+                const next = this.keyFn(this.state, key);
+                if (next !== undefined && next !== this.state) {
+                    this.state = next;
+                    this.scheduleRedraw();
+                }
+            });
+            this.cleanupFns.push(detachKeys);
+        }
+        catch (err) {
+            // Couldn't attach to stdin (not a TTY). Restore screen state
+            // before propagating so we don't leave the terminal in
+            // alt-screen mode.
+            this.stdout.write(leaveAltScreen + showCursor);
+            this.running = false;
+            throw err;
+        }
+        // Window resize → redraw with new dimensions
+        const onResize = () => this.scheduleRedraw(true);
+        this.stdout.on('resize', onResize);
+        this.cleanupFns.push(() => this.stdout.off('resize', onResize));
+        // Process-level safety net — any abnormal exit should leave the
+        // terminal in a usable state.
+        const finalCleanup = () => {
+            if (this.running)
+                this.stop();
+        };
+        process.once('SIGINT', finalCleanup);
+        process.once('SIGTERM', finalCleanup);
+        process.once('exit', finalCleanup);
+        this.cleanupFns.push(() => {
+            process.off('SIGINT', finalCleanup);
+            process.off('SIGTERM', finalCleanup);
+            process.off('exit', finalCleanup);
+        });
+        // First frame
+        this.redraw();
+        return new Promise((resolve) => {
+            this.cleanupFns.push(() => resolve());
+        });
+    }
+    /** Stop the TUI — restore terminal state and resolve the start() promise. */
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        // Run cleanup fns in reverse order so most-recent goes first
+        // (matches typical resource-stack semantics).
+        while (this.cleanupFns.length > 0) {
+            const fn = this.cleanupFns.pop();
+            try {
+                fn();
+            }
+            catch { /* keep unwinding */ }
+        }
+        // Final state restore
+        this.stdout.write(leaveAltScreen + showCursor);
+    }
+    scheduleRedraw(force = false) {
+        if (this.redrawScheduled && !force)
+            return;
+        this.redrawScheduled = true;
+        queueMicrotask(() => {
+            this.redrawScheduled = false;
+            if (!this.running)
+                return;
+            this.redraw();
+        });
+    }
+    redraw() {
+        const cols = this.stdout.columns ?? 80;
+        const rows = this.stdout.rows ?? 24;
+        const frame = this.renderFn(this.state, { cols, rows });
+        // Single write — minimizes flicker
+        this.stdout.write(clearScreen + frame);
+        if (this.afterFrameFn)
+            this.afterFrameFn(this.state);
+    }
+}

package/dist/tui/input.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TUI input handling — stdin raw-mode key parser.
+ *
+ * Why not Node's `readline.emitKeypressEvents`: it works, but the Key
+ * shape (`{ name, ctrl, meta, sequence }`) is loosely typed, the
+ * legacy event flag is awkward to disable cleanly, and its escape-
+ * sequence parser has historically lagged on edge cases (Windows
+ * Terminal modifyOtherKeys, Kitty progressive enhancement, etc).
+ *
+ * Writing ~150 lines that handle the keys we ACTUALLY use is more
+ * predictable. The keys we care about:
+ *
+ *   - Printable ASCII (0x20-0x7e)
+ *   - Enter, Tab, Backspace, Escape
+ *   - Arrow up/down/left/right
+ *   - Home, End, PgUp, PgDn
+ *   - Ctrl+C, Ctrl+D (exit), Ctrl+L (redraw)
+ *
+ * Standalone Esc vs Esc-led sequence (e.g. arrow): we use the same
+ * heuristic xterm uses — if ESC arrives in the same buffer chunk as
+ * subsequent bytes, treat as a CSI sequence. If ESC arrives alone in
+ * a chunk, treat as a standalone Escape keypress. This is reliable
+ * on real terminals and avoids the alternative (a wait-timer + lookahead)
+ * which adds complexity and a delay every Esc keypress.
+ */
+export interface Key {
+    /** A short name for the key. 'printable' for normal characters. */
+    name: 'printable' | 'enter' | 'tab' | 'backspace' | 'escape' | 'up' | 'down' | 'left' | 'right' | 'home' | 'end' | 'pageup' | 'pagedown' | 'delete' | 'unknown';
+    /** The printable character (or the raw sequence for `unknown`). */
+    ch: string;
+    /** True if a Ctrl modifier was held. */
+    ctrl: boolean;
+    /** True if a Shift modifier was held (only detectable on some keys). */
+    shift: boolean;
+    /** True if an Alt/Meta modifier was held. */
+    meta: boolean;
+}
+/**
+ * Parse one stdin chunk into zero or more Key events. Pure function;
+ * the caller drives stdin and accumulates the result. Most chunks
+ * yield exactly one key (interactive typing); paste / IME burst can
+ * yield several.
+ */
+export declare function parseKeys(chunk: Buffer): Key[];
+/**
+ * Put stdin into raw mode and start emitting Key events to `handler`.
+ * Returns a cleanup function that restores stdin's pre-raw mode and
+ * unbinds the listener. ALWAYS call the cleanup on exit (including
+ * abnormal exits — wire a process exit / signal hook).
+ *
+ * Defaults are picked so the caller doesn't have to think about them:
+ * UTF-8 encoding (we don't see Buffer chunks split mid-character),
+ * resume() so paused stdin doesn't drop key events.
+ *
+ * Throws if stdin isn't a TTY — the TUI doesn't make sense in a pipe.
+ */
+export declare function attachKeyHandler(stdin: NodeJS.ReadStream, handler: (key: Key) => void): () => void;