@askalf/dario 3.38.6 → 4.0.0

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>;

package/dist/tui/tabs/hits.js

@@ -0,0 +1,223 @@
+/**
+ * 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 { fg, dim, brand, inverse, BOX, pad, truncate } from '../render.js';
+import { renderKvRow } from '../layout.js';
+import { billingBucketFromClaim } from '../../analytics.js';
+const MAX_BUFFER = 5000;
+export const HitsTab = {
+    id: 'hits',
+    label: 'Hits',
+    hotkey: 'h',
+    initialState() {
+        return { buffer: [], selectedIdx: -1, subscribed: false, connectionError: null };
+    },
+    onMount(_state, ctx) {
+        // Subscribe to the live stream. Each record is prepended-conceptually
+        // (we push to the array and render in reverse, which keeps the
+        // buffer's mutation simple — Array.push is O(1) while unshift is O(n)).
+        const close = ctx.client.subscribeAnalyticsStream((record) => {
+            ctx.setState((s) => {
+                const next = {
+                    ...s,
+                    buffer: [...s.buffer, record].slice(-MAX_BUFFER),
+                    subscribed: true,
+                    connectionError: null,
+                };
+                // If user was at top (newest), keep them there. -1 means "no
+                // selection yet"; auto-select newest on first record.
+                if (s.selectedIdx === -1 || s.selectedIdx === 0) {
+                    next.selectedIdx = 0;
+                }
+                return next;
+            });
+        }, (err) => {
+            ctx.setState({ subscribed: false, connectionError: err.message });
+        });
+        ctx.registerCleanup(close);
+        return undefined;
+    },
+    onKey(state, key) {
+        if (state.buffer.length === 0)
+            return undefined;
+        // ↑ — go to OLDER (toward higher index in our reversed display)
+        if (key.name === 'up') {
+            const max = state.buffer.length - 1;
+            return { ...state, selectedIdx: Math.min(state.selectedIdx + 1, max) };
+        }
+        // ↓ — go to NEWER
+        if (key.name === 'down') {
+            return { ...state, selectedIdx: Math.max(state.selectedIdx - 1, 0) };
+        }
+        // PgUp / PgDn — step by 10
+        if (key.name === 'pageup') {
+            const max = state.buffer.length - 1;
+            return { ...state, selectedIdx: Math.min(state.selectedIdx + 10, max) };
+        }
+        if (key.name === 'pagedown') {
+            return { ...state, selectedIdx: Math.max(state.selectedIdx - 10, 0) };
+        }
+        // Home — jump to newest
+        if (key.name === 'home') {
+            return { ...state, selectedIdx: 0 };
+        }
+        // End — jump to oldest
+        if (key.name === 'end') {
+            return { ...state, selectedIdx: state.buffer.length - 1 };
+        }
+        return undefined;
+    },
+    render(state, dimv) {
+        const lines = [];
+        const w = dimv.cols;
+        const totalRows = dimv.rows;
+        // Split the body roughly 60/40 between list and detail.
+        const detailRows = 9;
+        const listRows = Math.max(3, totalRows - detailRows - 2);
+        if (state.buffer.length === 0) {
+            lines.push(' ' + brand('Hits') + dim('  — live request stream'));
+            lines.push('');
+            if (state.connectionError) {
+                lines.push('  ' + fg('red', `SSE error: ${state.connectionError}`));
+                lines.push('  ' + dim('Is `dario proxy` running? The stream reconnects automatically on the next mount.'));
+            }
+            else if (!state.subscribed) {
+                lines.push('  ' + dim('Connecting to /analytics/stream …'));
+            }
+            else {
+                lines.push('  ' + dim('Waiting for requests. Send one through dario to see it land here.'));
+            }
+            return lines.join('\n');
+        }
+        // Render newest-first: the LAST element of the buffer renders at
+        // the TOP of the list.
+        const newestFirst = [...state.buffer].reverse();
+        const startIdx = clampVisibleStart(state.selectedIdx, listRows, newestFirst.length);
+        const endIdx = Math.min(startIdx + listRows, newestFirst.length);
+        // Column layout — fixed widths to keep alignment stable across
+        // varied content. Fall back to truncation when columns overflow.
+        const colTime = 9;
+        const colModel = 18;
+        const colIn = 8, colOut = 7, colLat = 7, colStatus = 5;
+        lines.push(' ' + brand('Hits') +
+            dim(`  ${state.buffer.length} buffered · ${state.subscribed ? fg('green', 'live') : fg('yellow', 'disconnected')}`));
+        lines.push('');
+        // Header row (aligned with data rows)
+        lines.push('  ' + dim(pad('time', colTime) +
+            pad('model', colModel) +
+            pad('in', colIn) +
+            pad('out', colOut) +
+            pad('lat', colLat) +
+            pad('st', colStatus)));
+        for (let i = startIdx; i < endIdx; i++) {
+            const r = newestFirst[i];
+            const marker = i === state.selectedIdx ? fg('cyan', '▎') : ' ';
+            const row = marker + ' ' +
+                pad(formatTime(r.timestamp), colTime) +
+                pad(shortenModel(r.model), colModel) +
+                pad(formatTokens(r.inputTokens), colIn) +
+                pad(formatTokens(r.outputTokens), colOut) +
+                pad(formatLatency(r.latencyMs), colLat) +
+                pad(formatStatus(r.status), colStatus);
+            lines.push(i === state.selectedIdx ? inverse(truncate(row, w - 2)) : truncate(row, w - 2));
+        }
+        // Scroll hint
+        if (newestFirst.length > listRows) {
+            lines.push(' ' + dim(`${state.selectedIdx + 1} / ${newestFirst.length}  ` +
+                (startIdx > 0 ? '↑ more ' : '') +
+                (endIdx < newestFirst.length ? '↓ more' : '')));
+        }
+        // Separator
+        lines.push(' ' + dim(BOX.horizontal.repeat(w - 2)));
+        // Detail pane
+        if (state.selectedIdx >= 0 && state.selectedIdx < newestFirst.length) {
+            const r = newestFirst[state.selectedIdx];
+            lines.push('  ' + brand('Selected') + dim(`  ${formatTime(r.timestamp)}`));
+            lines.push('  ' + renderKvRow('Account', r.account, w - 4));
+            lines.push('  ' + renderKvRow('Model', r.model, w - 4));
+            lines.push('  ' + renderKvRow('Billing bucket', billingBucketFromClaim(r.claim), w - 4));
+            lines.push('  ' + renderKvRow('Tokens', tokenBreakdown(r), w - 4));
+            lines.push('  ' + renderKvRow('Latency', `${formatLatency(r.latencyMs)}  ${dim(r.isStream ? '(streaming)' : '(buffered)')}`, w - 4));
+            lines.push('  ' + renderKvRow('Util at request', `5h ${(r.util5h * 100).toFixed(0)}%   7d ${(r.util7d * 100).toFixed(0)}%`, w - 4));
+            lines.push('  ' + renderKvRow('Status', formatStatus(r.status), w - 4));
+        }
+        else {
+            lines.push('');
+            lines.push('  ' + dim('Use ↑↓ to select a request for details.'));
+        }
+        return lines.join('\n');
+    },
+};
+/**
+ * Decide what range of the (newest-first) buffer to show given the
+ * current selection. Keeps the selection visible: if selected drifts
+ * off the bottom we scroll down; off the top we scroll up.
+ */
+function clampVisibleStart(selectedIdx, listRows, total) {
+    if (selectedIdx < 0)
+        return 0;
+    // Try to keep selection roughly centered when scrolling
+    const desired = selectedIdx - Math.floor(listRows / 3);
+    return Math.max(0, Math.min(desired, Math.max(0, total - listRows)));
+}
+function formatTime(ts) {
+    const d = new Date(ts);
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+function pad2(n) { return n < 10 ? '0' + n : String(n); }
+function shortenModel(model) {
+    return model.replace(/^claude-/, '');
+}
+function formatTokens(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 formatLatency(ms) {
+    if (ms >= 1000)
+        return (ms / 1000).toFixed(1) + 's';
+    return ms + 'ms';
+}
+function formatStatus(code) {
+    if (code >= 200 && code < 300)
+        return fg('green', String(code));
+    if (code >= 400 && code < 500)
+        return fg('yellow', String(code));
+    if (code >= 500)
+        return fg('red', String(code));
+    return String(code);
+}
+function tokenBreakdown(r) {
+    const parts = [`in ${r.inputTokens}`, `out ${r.outputTokens}`];
+    if (r.cacheReadTokens > 0)
+        parts.push(`cache-read ${formatTokens(r.cacheReadTokens)}`);
+    if (r.cacheCreateTokens > 0)
+        parts.push(`cache-create ${formatTokens(r.cacheCreateTokens)}`);
+    if (r.thinkingTokens > 0)
+        parts.push(`thinking ${r.thinkingTokens}`);
+    return parts.join(' / ');
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Status tab — at-a-glance proxy + auth + config-source view.
+ *
+ * Read-mostly. On mount: probe /health for proxy reachability; load
+ * config-file metadata locally. On any key, return undefined (no
+ * mutations from this tab).
+ *
+ * Layout:
+ *
+ *   ┌─ Proxy ─────────────────────────────────────────┐
+ *   │  status:      running                           │
+ *   │  port:        3456                              │
+ *   │  oauth:       healthy (expires in 7h 41m)       │
+ *   │  requests:    247                               │
+ *   └─────────────────────────────────────────────────┘
+ *   ┌─ Config ────────────────────────────────────────┐
+ *   │  source:      ~/.dario/config.json              │
+ *   │  schema:      v1                                │
+ *   │  …per-knob effective values (read-only)         │
+ *   └─────────────────────────────────────────────────┘
+ */
+import type { Tab, TabContext } from '../tab.js';
+export interface StatusState {
+    loading: boolean;
+    /** Proxy /health response, or null if unreachable. */
+    health: {
+        status: string;
+        oauth: string;
+        expiresIn?: string;
+        requests?: number;
+    } | null;
+    /** Config-file load source: file | missing | invalid. */
+    configSource: 'file' | 'missing' | 'invalid' | null;
+    /** Last refresh timestamp (ms). */
+    lastRefreshAt: number;
+    /** Error from the last refresh attempt, if any. */
+    error: string | null;
+}
+export declare const StatusTab: Tab<StatusState>;
+/**
+ * Refresh the Status tab's data — probe /health, load config file
+ * metadata. Exported separately so the parent can re-invoke on key
+ * 'r' without re-running the full onMount flow.
+ */
+export declare function refreshStatus(ctx: TabContext): Promise<StatusState>;