@askalf/dario 3.38.6 → 4.0.1

package/dist/tui/tabs/analytics.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Analytics tab — rolling-window summary + per-model + rate-limit bars.
+ *
+ * Polls /analytics on the running proxy every 2s. Renders:
+ *
+ *   - Top-line counters (requests, tokens in/out, cache hit, cost saved)
+ *   - Per-model bars (request share by model)
+ *   - Rate-limit bars (5h / 7d utilization)
+ *   - Billing-bucket breakdown (subscription vs extra-usage vs api)
+ *
+ * State machine is straightforward — fetch + cache; no key interaction
+ * beyond 'r' for forced refresh.
+ */
+import type { Tab } from '../tab.js';
+/** Subset of AnalyticsSummary the Analytics tab actually renders. */
+interface SummaryShape {
+    window: {
+        minutes: number;
+        requests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        totalThinkingTokens: number;
+        estimatedCost: number;
+        avgLatencyMs: number;
+        subscriptionPercent: number;
+        billingBucketBreakdown: Record<string, number>;
+    };
+    allTime: {
+        requests: number;
+    };
+    perModel: Record<string, {
+        requests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+    }>;
+    utilization: {
+        lastUtil5h: number;
+        lastUtil7d: number;
+    };
+}
+export interface AnalyticsState {
+    summary: SummaryShape | null;
+    loading: boolean;
+    error: string | null;
+    lastFetchAt: number;
+    /**
+     * If true, ignore the polling cadence and refetch on the next tick.
+     * Set by the 'r' key handler.
+     */
+    forceRefresh: boolean;
+}
+export declare const AnalyticsTab: Tab<AnalyticsState>;
+export {};

package/dist/tui/tabs/analytics.js

@@ -0,0 +1,161 @@
+/**
+ * Analytics tab — rolling-window summary + per-model + rate-limit bars.
+ *
+ * Polls /analytics on the running proxy every 2s. Renders:
+ *
+ *   - Top-line counters (requests, tokens in/out, cache hit, cost saved)
+ *   - Per-model bars (request share by model)
+ *   - Rate-limit bars (5h / 7d utilization)
+ *   - Billing-bucket breakdown (subscription vs extra-usage vs api)
+ *
+ * State machine is straightforward — fetch + cache; no key interaction
+ * beyond 'r' for forced refresh.
+ */
+import { fg, dim, brand, progressBar, pad } from '../render.js';
+import { renderKvRow } from '../layout.js';
+const POLL_INTERVAL_MS = 2000;
+export const AnalyticsTab = {
+    id: 'analytics',
+    label: 'Analytics',
+    hotkey: 'A', // capital A to avoid colliding with Accounts (a)
+    initialState() {
+        return {
+            summary: null,
+            loading: true,
+            error: null,
+            lastFetchAt: 0,
+            forceRefresh: false,
+        };
+    },
+    onMount(_state, ctx) {
+        void fetchSummary(ctx);
+        return undefined;
+    },
+    onTick(state, ctx) {
+        const now = Date.now();
+        if (state.forceRefresh) {
+            ctx.setState({ forceRefresh: false });
+            void fetchSummary(ctx);
+            return;
+        }
+        if (now - state.lastFetchAt >= POLL_INTERVAL_MS && !state.loading) {
+            void fetchSummary(ctx);
+        }
+    },
+    onKey(state, key) {
+        if (key.name === 'printable' && key.ch === 'r' && !key.ctrl) {
+            return { ...state, forceRefresh: true };
+        }
+        return undefined;
+    },
+    render(state, dimv) {
+        const lines = [];
+        const w = dimv.cols;
+        const barWidth = Math.min(36, w - 32);
+        lines.push(' ' + brand('Analytics') + dim(`  — last ${state.summary?.window.minutes ?? 60} min`));
+        if (!state.summary && state.loading) {
+            lines.push('');
+            lines.push('  ' + dim('Loading…'));
+            return lines.join('\n');
+        }
+        if (!state.summary && state.error) {
+            lines.push('');
+            lines.push('  ' + fg('red', `Cannot reach proxy: ${state.error}`));
+            lines.push('  ' + dim('Start the proxy with `dario proxy`, then this view refreshes automatically.'));
+            return lines.join('\n');
+        }
+        if (!state.summary) {
+            lines.push('');
+            lines.push('  ' + dim('(no data yet)'));
+            return lines.join('\n');
+        }
+        const s = state.summary;
+        // ── Counters ───────────────────────────────────────────────
+        const rpm = s.window.requests / Math.max(1, s.window.minutes);
+        lines.push('');
+        lines.push('  ' + renderKvRow('Requests', `${s.window.requests}  ${dim(`(${rpm.toFixed(1)}/min)`)}`, w - 4));
+        lines.push('  ' + renderKvRow('Tokens in', formatNumber(s.window.totalInputTokens), w - 4));
+        lines.push('  ' + renderKvRow('Tokens out', formatNumber(s.window.totalOutputTokens), w - 4));
+        lines.push('  ' + renderKvRow('Thinking tokens', formatNumber(s.window.totalThinkingTokens), w - 4));
+        lines.push('  ' + renderKvRow('Avg latency', `${Math.round(s.window.avgLatencyMs)}ms`, w - 4));
+        lines.push('  ' + renderKvRow('Subscription %', `${(s.window.subscriptionPercent * 100).toFixed(0)}%`, w - 4));
+        // ── Per-model bars ─────────────────────────────────────────
+        const models = Object.entries(s.perModel).sort((a, b) => b[1].requests - a[1].requests);
+        if (models.length > 0) {
+            lines.push('');
+            lines.push(' ' + brand('Per-model'));
+            const totalReq = Math.max(1, models.reduce((sum, [, m]) => sum + m.requests, 0));
+            for (const [name, m] of models) {
+                const share = m.requests / totalReq;
+                const sharePct = `${(share * 100).toFixed(0)}%`.padStart(4);
+                lines.push('  ' + pad(shortenModelName(name), 18) +
+                    fg('green', progressBar(share, barWidth)) +
+                    '  ' + dim(`${sharePct} (${m.requests})`));
+            }
+        }
+        // ── Rate-limit ────────────────────────────────────────────
+        lines.push('');
+        lines.push(' ' + brand('Rate-limit'));
+        lines.push('  ' + pad('5h', 6) +
+            fg('cyan', progressBar(s.utilization.lastUtil5h, barWidth)) +
+            '  ' + dim(`${(s.utilization.lastUtil5h * 100).toFixed(0)}%`));
+        lines.push('  ' + pad('7d', 6) +
+            fg('cyan', progressBar(s.utilization.lastUtil7d, barWidth)) +
+            '  ' + dim(`${(s.utilization.lastUtil7d * 100).toFixed(0)}%`));
+        // ── Billing buckets ───────────────────────────────────────
+        const buckets = s.window.billingBucketBreakdown;
+        const totalBucketCount = Object.values(buckets).reduce((a, b) => a + b, 0);
+        if (totalBucketCount > 0) {
+            lines.push('');
+            lines.push(' ' + brand('Billing'));
+            for (const [bucket, count] of Object.entries(buckets)) {
+                if (count === 0)
+                    continue;
+                lines.push('  ' + pad(bucket, 22) + dim(`${count} req`));
+            }
+        }
+        // Footer
+        lines.push('');
+        lines.push(' ' + dim(`Updated ${ago(state.lastFetchAt)}. Press ${fg('cyan', 'r')} to refresh.`));
+        return lines.join('\n');
+    },
+};
+async function fetchSummary(ctx) {
+    ctx.setState({ loading: true });
+    try {
+        const s = await ctx.client.getJson('/analytics');
+        ctx.setState({
+            summary: s,
+            loading: false,
+            lastFetchAt: Date.now(),
+            error: null,
+        });
+    }
+    catch (e) {
+        ctx.setState({
+            loading: false,
+            lastFetchAt: Date.now(),
+            error: e.message,
+        });
+    }
+}
+function formatNumber(n) {
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(1) + 'M';
+    if (n >= 1000)
+        return (n / 1000).toFixed(1) + 'k';
+    return String(n);
+}
+function shortenModelName(model) {
+    return model.replace(/^claude-/, '').slice(0, 18);
+}
+function ago(ts) {
+    if (ts === 0)
+        return 'never';
+    const sec = Math.floor((Date.now() - ts) / 1000);
+    if (sec < 1)
+        return 'just now';
+    if (sec < 60)
+        return `${sec}s ago`;
+    return `${Math.floor(sec / 60)}m ago`;
+}

package/dist/tui/tabs/backends.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Backends tab — OpenAI-compat backends configured locally.
+ *
+ * Read-only view. apiKey is masked. Mutations via CLI:
+ *   dario backend add <name> --key=sk-... [--base-url=...]
+ *   dario backend remove <name>
+ */
+import type { Tab } from '../tab.js';
+export interface BackendsState {
+    loading: boolean;
+    backends: Array<{
+        name: string;
+        provider: string;
+        baseUrl: string;
+    }>;
+    error: string | null;
+}
+export declare const BackendsTab: Tab<BackendsState>;
+export declare function refreshBackends(): Promise<BackendsState>;

package/dist/tui/tabs/backends.js

@@ -0,0 +1,77 @@
+/**
+ * Backends tab — OpenAI-compat backends configured locally.
+ *
+ * Read-only view. apiKey is masked. Mutations via CLI:
+ *   dario backend add <name> --key=sk-... [--base-url=...]
+ *   dario backend remove <name>
+ */
+import { fg, dim, brand, pad } from '../render.js';
+export const BackendsTab = {
+    id: 'backends',
+    label: 'Backends',
+    hotkey: 'b',
+    initialState() {
+        return { loading: true, backends: [], error: null };
+    },
+    async onMount() {
+        return refreshBackends();
+    },
+    onKey(state, key) {
+        if (key.name === 'printable' && key.ch === 'r' && !key.ctrl) {
+            return { ...state, loading: true };
+        }
+        return undefined;
+    },
+    render(state, dimv) {
+        const lines = [];
+        const w = dimv.cols;
+        lines.push(' ' + brand('OpenAI-compat Backends'));
+        if (state.loading && state.backends.length === 0) {
+            lines.push('');
+            lines.push('  ' + dim('Loading backends…'));
+            return lines.join('\n');
+        }
+        if (state.backends.length === 0) {
+            lines.push('');
+            lines.push('  ' + dim('No OpenAI-compat backends configured.'));
+            lines.push('  ' + 'Add one: ' + fg('cyan', 'dario backend add openai --key=sk-...'));
+            return lines.join('\n');
+        }
+        // Header
+        lines.push('  ' + dim(pad('name', 16) + pad('provider', 12) + pad('base url', 40)));
+        lines.push('  ' + dim('─'.repeat(Math.min(w - 4, 68))));
+        for (const b of state.backends) {
+            lines.push('  ' +
+                pad(b.name, 16) +
+                pad(b.provider, 12) +
+                b.baseUrl);
+        }
+        if (state.error) {
+            lines.push('');
+            lines.push(' ' + fg('red', `Load error: ${state.error}`));
+        }
+        lines.push('');
+        lines.push(' ' + dim('Mutations via CLI:'));
+        lines.push('   ' + fg('cyan', 'dario backend add <name> --key=sk-... [--base-url=...]'));
+        lines.push('   ' + fg('cyan', 'dario backend remove <name>'));
+        return lines.join('\n');
+    },
+};
+export async function refreshBackends() {
+    try {
+        const { listBackends } = await import('../../openai-backend.js');
+        const all = await listBackends();
+        return {
+            loading: false,
+            backends: all.map(b => ({
+                name: b.name,
+                provider: b.provider,
+                baseUrl: b.baseUrl,
+            })),
+            error: null,
+        };
+    }
+    catch (e) {
+        return { loading: false, backends: [], error: e.message };
+    }
+}

package/dist/tui/tabs/config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Config tab — view + edit the persistent ~/.dario/config.json.
+ *
+ * Renders a flat list of editable fields. Each field has a typed
+ * editor: bool toggles inline, numbers / strings open an input prompt
+ * at the bottom of the panel.
+ *
+ * Keys:
+ *   ↑↓        navigate
+ *   Enter     edit (bool: toggle; number/string: open input)
+ *   Esc       cancel input
+ *   s         save → write ~/.dario/config.json
+ *   d         discard local changes
+ *   r         reload from disk
+ *
+ * Coverage in v4.0: port, host, stealth, pacing/thinkTime/sessionStart
+ * sub-knobs, drainOnClose. Additional fields (preserveTools, mergeTools,
+ * etc.) can follow the same FieldDef pattern in v4.x without API
+ * change. The DarioConfig schema is the source of truth — adding a
+ * field there + a row here lights it up.
+ */
+import type { Tab } from '../tab.js';
+import { type DarioConfig } from '../../config-file.js';
+export interface ConfigState {
+    config: DarioConfig;
+    /** Loaded snapshot — used to compute dirty. */
+    snapshot: DarioConfig;
+    selectedIdx: number;
+    /** Active edit buffer, or null when not in edit mode. */
+    editBuffer: string | null;
+    /** Transient status line (e.g. "Saved."). */
+    statusMessage: string | null;
+    statusKind: 'info' | 'success' | 'error' | null;
+}
+export declare const ConfigTab: Tab<ConfigState>;

package/dist/tui/tabs/config.js

@@ -0,0 +1,267 @@
+/**
+ * Config tab — view + edit the persistent ~/.dario/config.json.
+ *
+ * Renders a flat list of editable fields. Each field has a typed
+ * editor: bool toggles inline, numbers / strings open an input prompt
+ * at the bottom of the panel.
+ *
+ * Keys:
+ *   ↑↓        navigate
+ *   Enter     edit (bool: toggle; number/string: open input)
+ *   Esc       cancel input
+ *   s         save → write ~/.dario/config.json
+ *   d         discard local changes
+ *   r         reload from disk
+ *
+ * Coverage in v4.0: port, host, stealth, pacing/thinkTime/sessionStart
+ * sub-knobs, drainOnClose. Additional fields (preserveTools, mergeTools,
+ * etc.) can follow the same FieldDef pattern in v4.x without API
+ * change. The DarioConfig schema is the source of truth — adding a
+ * field there + a row here lights it up.
+ */
+import { fg, dim, brand, inverse, pad } from '../render.js';
+import { CONFIG_SCHEMA_VERSION, defaultConfig, loadConfig, saveConfig, } from '../../config-file.js';
+/**
+ * The visible field registry. Order = display order. New fields just
+ * append; the tab grows automatically. Path → DarioConfig is dotted.
+ */
+const FIELDS = [
+    { path: 'port', label: 'Port', type: 'number', hint: 'default 3456' },
+    { path: 'host', label: 'Host', type: 'string', hint: '127.0.0.1 (loopback only)' },
+    { path: 'stealth', label: 'Stealth preset', type: 'bool', hint: 'enables behavioural pacing + jitter' },
+    { path: 'drainOnClose', label: 'Drain on close', type: 'bool', hint: 'finish upstream SSE after client disconnects' },
+    { path: 'pacing.minMs', label: 'Pacing min (ms)', type: 'number', hint: 'min inter-request distance' },
+    { path: 'pacing.jitterMs', label: 'Pacing jitter (ms)', type: 'number', hint: 'uniform-random extra delay' },
+    { path: 'thinkTime.baseMs', label: 'Think-time base (ms)', type: 'number' },
+    { path: 'thinkTime.perTokenMs', label: 'Think-time per-token', type: 'number', hint: 'ms per output token of last response' },
+    { path: 'thinkTime.jitterMs', label: 'Think-time jitter', type: 'number' },
+    { path: 'thinkTime.maxMs', label: 'Think-time cap (ms)', type: 'number', hint: 'upper bound for the whole formula' },
+    { path: 'sessionStart.minMs', label: 'Session-start min', type: 'number', hint: 'first-request delay floor' },
+    { path: 'sessionStart.jitterMs', label: 'Session-start jitter', type: 'number' },
+];
+export const ConfigTab = {
+    id: 'config',
+    label: 'Config',
+    hotkey: 'c',
+    initialState() {
+        const loaded = loadConfig();
+        return {
+            config: loaded.config,
+            snapshot: structuredClone(loaded.config),
+            selectedIdx: 0,
+            editBuffer: null,
+            statusMessage: null,
+            statusKind: null,
+        };
+    },
+    onKey(state, key) {
+        // ── Edit mode key handling ─────────────────────────────────
+        if (state.editBuffer !== null) {
+            if (key.name === 'escape') {
+                return { ...state, editBuffer: null, statusMessage: 'Edit cancelled.', statusKind: 'info' };
+            }
+            if (key.name === 'enter') {
+                return commitEdit(state);
+            }
+            if (key.name === 'backspace') {
+                return { ...state, editBuffer: state.editBuffer.slice(0, -1) };
+            }
+            if (key.name === 'printable' && !key.ctrl) {
+                return { ...state, editBuffer: state.editBuffer + key.ch };
+            }
+            return undefined;
+        }
+        // ── Normal mode ────────────────────────────────────────────
+        if (key.name === 'up') {
+            return { ...state, selectedIdx: Math.max(0, state.selectedIdx - 1), statusMessage: null, statusKind: null };
+        }
+        if (key.name === 'down') {
+            return { ...state, selectedIdx: Math.min(FIELDS.length - 1, state.selectedIdx + 1), statusMessage: null, statusKind: null };
+        }
+        if (key.name === 'enter') {
+            return startEdit(state);
+        }
+        if (key.name === 'printable' && !key.ctrl) {
+            if (key.ch === 's')
+                return doSave(state);
+            if (key.ch === 'd')
+                return doDiscard(state);
+            if (key.ch === 'r')
+                return doReload();
+        }
+        return undefined;
+    },
+    render(state, dimv) {
+        const lines = [];
+        const w = dimv.cols;
+        const labelW = 26;
+        const valueW = w - labelW - 6;
+        const dirty = isDirty(state);
+        const title = dirty
+            ? brand('Config') + dim('  — ') + fg('yellow', '● unsaved changes')
+            : brand('Config');
+        lines.push(' ' + title);
+        lines.push('');
+        for (let i = 0; i < FIELDS.length; i++) {
+            const field = FIELDS[i];
+            const value = getByPath(state.config, field.path);
+            const orig = getByPath(state.snapshot, field.path);
+            const changed = !Object.is(value, orig);
+            const valueRender = renderValue(field, value, changed);
+            const hint = field.hint ? '  ' + dim('— ' + field.hint) : '';
+            const row = '  ' + pad(field.label + ':', labelW) + pad(valueRender, valueW) + hint;
+            lines.push(i === state.selectedIdx ? inverse(row) : row);
+        }
+        // ── Edit prompt or status line ─────────────────────────────
+        lines.push('');
+        if (state.editBuffer !== null) {
+            const f = FIELDS[state.selectedIdx];
+            lines.push(' ' + fg('cyan', `Edit ${f.label}:`) + ' ' + state.editBuffer + fg('cyan', '_'));
+            lines.push(' ' + dim('Enter to confirm · Esc to cancel'));
+        }
+        else if (state.statusMessage) {
+            const color = state.statusKind === 'error' ? 'red'
+                : state.statusKind === 'success' ? 'green'
+                    : 'cyan';
+            lines.push(' ' + fg(color, state.statusMessage));
+        }
+        else {
+            lines.push(' ' + dim('↑↓ navigate · Enter edit · s save · d discard · r reload'));
+        }
+        return lines.join('\n');
+    },
+};
+// ── Helpers ───────────────────────────────────────────────────
+function getByPath(obj, path) {
+    return path.split('.').reduce((acc, part) => {
+        if (acc && typeof acc === 'object' && part in acc) {
+            return acc[part];
+        }
+        return undefined;
+    }, obj);
+}
+function setByPath(obj, path, value) {
+    // Guard against prototype-pollution paths. `path` is always sourced
+    // from FIELDS (the static registry at the top of this file), but
+    // CodeQL flags the recursive descent as risky because it can't
+    // prove that statically — and rightly so: if a future caller ever
+    // passes a user-controlled path, walking `__proto__` or
+    // `constructor` would mutate Object.prototype. Reject those
+    // segments explicitly so the seam is safe by construction.
+    const parts = path.split('.');
+    for (const part of parts) {
+        if (part === '__proto__' || part === 'constructor' || part === 'prototype') {
+            throw new Error(`refusing to set forbidden path segment: ${part}`);
+        }
+    }
+    const next = structuredClone(obj);
+    let cursor = next;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        // Object.prototype.hasOwnProperty.call so we don't accidentally
+        // pick up inherited keys when probing for existing nested groups.
+        if (!Object.prototype.hasOwnProperty.call(cursor, part)
+            || typeof cursor[part] !== 'object'
+            || cursor[part] === null) {
+            cursor[part] = {};
+        }
+        cursor = cursor[part];
+    }
+    cursor[parts[parts.length - 1]] = value;
+    return next;
+}
+function renderValue(field, value, changed) {
+    let text;
+    if (field.type === 'bool')
+        text = value === true ? 'on' : 'off';
+    else if (value === null || value === undefined)
+        text = '—';
+    else
+        text = String(value);
+    // Yellow if changed-from-snapshot; green for bool-on; default otherwise
+    if (changed)
+        return fg('yellow', text);
+    if (field.type === 'bool' && value === true)
+        return fg('green', text);
+    return text;
+}
+function startEdit(state) {
+    const f = FIELDS[state.selectedIdx];
+    if (f.type === 'bool') {
+        // Toggle in place
+        const current = getByPath(state.config, f.path);
+        const next = setByPath(state.config, f.path, !current);
+        return { ...state, config: next, statusMessage: null, statusKind: null };
+    }
+    // String / number: open the prompt with the current value
+    const current = getByPath(state.config, f.path);
+    return { ...state, editBuffer: current === null || current === undefined ? '' : String(current) };
+}
+function commitEdit(state) {
+    if (state.editBuffer === null)
+        return state;
+    const f = FIELDS[state.selectedIdx];
+    let parsed;
+    if (f.type === 'number') {
+        if (state.editBuffer === '') {
+            // Empty number → null (clears the override)
+            parsed = null;
+        }
+        else {
+            const n = Number(state.editBuffer);
+            if (!Number.isFinite(n)) {
+                return { ...state, editBuffer: null, statusMessage: `Not a number: "${state.editBuffer}"`, statusKind: 'error' };
+            }
+            parsed = n;
+        }
+    }
+    else {
+        parsed = state.editBuffer;
+    }
+    const next = setByPath(state.config, f.path, parsed);
+    return { ...state, config: next, editBuffer: null, statusMessage: `Updated ${f.label}.`, statusKind: 'success' };
+}
+function doSave(state) {
+    try {
+        saveConfig(undefined, { ...state.config, version: CONFIG_SCHEMA_VERSION });
+        return {
+            ...state,
+            snapshot: structuredClone(state.config),
+            statusMessage: 'Saved to ~/.dario/config.json',
+            statusKind: 'success',
+        };
+    }
+    catch (err) {
+        return {
+            ...state,
+            statusMessage: `Save failed: ${err.message}`,
+            statusKind: 'error',
+        };
+    }
+}
+function doDiscard(state) {
+    return {
+        ...state,
+        config: structuredClone(state.snapshot),
+        statusMessage: 'Local changes discarded.',
+        statusKind: 'info',
+    };
+}
+function doReload() {
+    const loaded = loadConfig();
+    return {
+        config: loaded.config,
+        snapshot: structuredClone(loaded.config),
+        selectedIdx: 0,
+        editBuffer: null,
+        statusMessage: loaded.source === 'file' ? 'Reloaded from disk.'
+            : loaded.source === 'missing' ? 'No file on disk — showing defaults.'
+                : `Invalid file: ${loaded.error}`,
+        statusKind: loaded.source === 'invalid' ? 'error' : 'info',
+    };
+}
+function isDirty(state) {
+    return JSON.stringify(state.config) !== JSON.stringify(state.snapshot);
+}
+// Avoid "unused" lint
+void defaultConfig;

package/dist/tui/tabs/hits.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Hits tab — live request stream with per-record detail drill-down.
+ *
+ * Subscribes to /analytics/stream on mount. Each incoming RequestRecord
+ * is prepended to the buffer (newest at the top of the visible list).
+ * Up/Down navigate the selection; the lower pane shows the selected
+ * record's full field set.
+ *
+ * Layout:
+ *
+ *   ┌─ Hits ────────────────────────[ ↑↓ select · r refresh ]
+ *   │  HH:MM:SS  METHOD  MODEL          IN     OUT   LAT    ST
+ *   │  18:42:01  POST    opus-4-7       842    216   1.2s  200  ←
+ *   │  18:42:03  POST    sonnet-4-6     1.2k   480   0.8s  200
+ *   │  …
+ *   ├─────────────────────────────────────────────────────────────
+ *   │  selected: 18:42:01  req_011…NvMn
+ *   │    account:  sprayberryit (single)
+ *   │    model:    claude-opus-4-7
+ *   │    bucket:   subscription
+ *   │    tokens:   in 842 / out 216 / cache-read 6.2k / thinking 84
+ *   │    latency:  1.18s   stream: yes  status: 200
+ *   │    5h util:  18%     7d util: 8%
+ *   └─────────────────────────────────────────────────────────────
+ */
+import type { Tab } from '../tab.js';
+import type { RequestRecord } from '../../analytics.js';
+export interface HitsState {
+    buffer: RequestRecord[];
+    selectedIdx: number;
+    subscribed: boolean;
+    connectionError: string | null;
+}
+export declare const HitsTab: Tab<HitsState>;