@askalf/dario 3.38.6 → 4.0.0

package/dist/tui/tab.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Common interface every tab implements.
+ *
+ * A tab is a self-contained state machine with:
+ *   - its own slice of state (typed locally; opaque to the parent)
+ *   - a render function: state + viewport → string
+ *   - a key handler: state + key → next state or undefined (no change)
+ *   - optional lifecycle hooks for mount / unmount / periodic tick
+ *
+ * The TuiApp composes a fixed set of tabs; it doesn't dynamically
+ * register them at runtime. That keeps the type system happy (each
+ * tab's state is statically known to the parent) while still letting
+ * each tab evolve independently.
+ *
+ * Tabs that need to fetch data from the proxy receive a
+ * `TabContext` with the ProxyClient. Tabs that don't (e.g. Status,
+ * which reads local state only) can ignore it.
+ */
+import type { Key } from './input.js';
+import type { ProxyClient } from './proxy-client.js';
+export interface TabContext<S = unknown> {
+    /** The proxy HTTP client. Tabs use it to fetch /analytics, subscribe to /analytics/stream, etc. */
+    client: ProxyClient;
+    /**
+     * Update the active tab's state slice. Tabs use this from async
+     * callbacks (HTTP responses, SSE messages, timers) — the synchronous
+     * render/onKey path returns the next state directly. The parent
+     * applies the updater to whatever tab is currently active.
+     *
+     * Loosely-typed across tab implementations; each tab passes its
+     * own S as a generic, the parent's dispatcher takes care of the
+     * type-erasure.
+     */
+    setState: (updater: Partial<S> | ((prev: S) => S)) => void;
+    /**
+     * Register a cleanup function that runs on tab unmount (user switches
+     * away) or App shutdown. Tabs use this to close SSE subscriptions,
+     * clear intervals, drop event listeners — anything stateful set up
+     * in onMount that won't garbage-collect on its own.
+     */
+    registerCleanup: (fn: () => void) => void;
+}
+/**
+ * A renderable tab. S is the tab's local state shape. The parent
+ * TuiApp holds a record of all tab states and dispatches based on
+ * the active tab id.
+ */
+export interface Tab<S> {
+    /** Short id, must be unique. Used as the state-record key. */
+    id: string;
+    /** Human-readable label rendered in the tab strip. */
+    label: string;
+    /** Single-letter hotkey to jump to this tab. */
+    hotkey?: string;
+    /** Build the initial state. Called once on TuiApp construction. */
+    initialState(): S;
+    /**
+     * Render the tab's body region into a single string. Caller passes
+     * the dimensions of the body region (NOT the full screen — header,
+     * footer, and tab strip are drawn by the parent).
+     */
+    render(state: S, dim: {
+        cols: number;
+        rows: number;
+    }): string;
+    /**
+     * Handle a keypress. Return the next state (or undefined for no
+     * change). Global keys (Tab, q, Ctrl+C, hotkeys) are intercepted
+     * by the parent before reaching this; the tab only sees keys the
+     * parent didn't claim.
+     */
+    onKey?(state: S, key: Key): S | undefined;
+    /**
+     * Run once when this tab becomes active. May fire async work that
+     * calls `ctx.setState(...)` to update the slice once the data lands.
+     * The synchronous return value (if any) is applied before render.
+     */
+    onMount?(state: S, ctx: TabContext<S>): S | undefined | Promise<S | undefined>;
+    /** Run once when this tab loses focus (user switched tabs). */
+    onUnmount?(state: S): void;
+    /**
+     * Called by the parent's heartbeat (every 100ms by default). Tabs
+     * that need periodic refresh (Analytics polling, Hits stale-check)
+     * consult their state and decide whether to act. Don't do
+     * expensive work synchronously here; kick off async + call
+     * ctx.setState when it lands.
+     */
+    onTick?(state: S, ctx: TabContext<S>): void;
+}

package/dist/tui/tab.js

@@ -0,0 +1,19 @@
+/**
+ * Common interface every tab implements.
+ *
+ * A tab is a self-contained state machine with:
+ *   - its own slice of state (typed locally; opaque to the parent)
+ *   - a render function: state + viewport → string
+ *   - a key handler: state + key → next state or undefined (no change)
+ *   - optional lifecycle hooks for mount / unmount / periodic tick
+ *
+ * The TuiApp composes a fixed set of tabs; it doesn't dynamically
+ * register them at runtime. That keeps the type system happy (each
+ * tab's state is statically known to the parent) while still letting
+ * each tab evolve independently.
+ *
+ * Tabs that need to fetch data from the proxy receive a
+ * `TabContext` with the ProxyClient. Tabs that don't (e.g. Status,
+ * which reads local state only) can ignore it.
+ */
+export {};

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

@@ -0,0 +1,32 @@
+/**
+ * Accounts tab — list of OAuth subscription accounts in the pool.
+ *
+ * Read-mostly. Mutations (add/remove) require the CLI — the tab
+ * shows the relevant command in the footer.
+ *
+ * Layout:
+ *
+ *   ┌─ Accounts ──────────────────────────────────────┐
+ *   │  alias            expires    util5h   util7d    │
+ *   │  ─────            ───────    ──────   ──────    │
+ *   │  default          7h 41m       12%      4%      │
+ *   │  alt              expired       0%      0%      │
+ *   │  …                                              │
+ *   └─────────────────────────────────────────────────┘
+ *   To add: `dario accounts add <alias>`
+ *   To remove: `dario accounts remove <alias>`
+ */
+import type { Tab } from '../tab.js';
+export interface AccountsState {
+    loading: boolean;
+    accounts: Array<{
+        alias: string;
+        expiresAt: number;
+        /** Optional rate-limit fields populated when /accounts endpoint exists. */
+        util5h?: number;
+        util7d?: number;
+    }>;
+    error: string | null;
+}
+export declare const AccountsTab: Tab<AccountsState>;
+export declare function refreshAccounts(): Promise<AccountsState>;

package/dist/tui/tabs/accounts.js

@@ -0,0 +1,110 @@
+/**
+ * Accounts tab — list of OAuth subscription accounts in the pool.
+ *
+ * Read-mostly. Mutations (add/remove) require the CLI — the tab
+ * shows the relevant command in the footer.
+ *
+ * Layout:
+ *
+ *   ┌─ Accounts ──────────────────────────────────────┐
+ *   │  alias            expires    util5h   util7d    │
+ *   │  ─────            ───────    ──────   ──────    │
+ *   │  default          7h 41m       12%      4%      │
+ *   │  alt              expired       0%      0%      │
+ *   │  …                                              │
+ *   └─────────────────────────────────────────────────┘
+ *   To add: `dario accounts add <alias>`
+ *   To remove: `dario accounts remove <alias>`
+ */
+import { fg, dim, brand, pad } from '../render.js';
+import { renderKvRow } from '../layout.js';
+export const AccountsTab = {
+    id: 'accounts',
+    label: 'Accounts',
+    hotkey: 'a',
+    initialState() {
+        return { loading: true, accounts: [], error: null };
+    },
+    async onMount(_state, _ctx) {
+        return refreshAccounts();
+    },
+    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('Accounts'));
+        if (state.loading && state.accounts.length === 0) {
+            lines.push('');
+            lines.push('  ' + dim('Loading accounts…'));
+            return lines.join('\n');
+        }
+        if (state.accounts.length === 0) {
+            lines.push('');
+            lines.push('  ' + dim('No accounts in the pool.'));
+            lines.push('  ' + 'Add one: ' + fg('cyan', 'dario accounts add <alias>'));
+            return lines.join('\n');
+        }
+        // Header row
+        lines.push('  ' + dim(pad('alias', 20) + pad('expires', 16) + pad('source', 24)));
+        lines.push('  ' + dim('─'.repeat(Math.min(w - 4, 60))));
+        for (const acc of state.accounts) {
+            const aliasCol = pad(acc.alias, 20);
+            const expiresCol = pad(formatExpiry(acc.expiresAt), 16);
+            const sourceCol = '~/.dario/accounts/' + acc.alias + '.json';
+            lines.push('  ' + aliasCol + expiresCol + dim(sourceCol));
+        }
+        lines.push('');
+        lines.push(' ' + dim('Mutations via CLI:'));
+        lines.push('   ' + fg('cyan', 'dario accounts add <alias>'));
+        lines.push('   ' + fg('cyan', 'dario accounts remove <alias>'));
+        // Refresh hint
+        lines.push('');
+        lines.push(' ' + renderKvRow('', '', w - 2)); // spacer
+        lines.push(' ' + dim(`Press ${fg('cyan', 'r')} to refresh.`));
+        return lines.join('\n');
+    },
+};
+export async function refreshAccounts() {
+    try {
+        const { listAccountAliases, loadAllAccounts } = await import('../../accounts.js');
+        const aliases = await listAccountAliases();
+        if (aliases.length === 0) {
+            // Single-account / login.json path — show a synthetic "default"
+            // entry sourced from ~/.dario/credentials.json or keychain.
+            return { loading: false, accounts: [], error: null };
+        }
+        const all = await loadAllAccounts();
+        return {
+            loading: false,
+            accounts: all.map(a => ({
+                alias: a.alias,
+                expiresAt: a.expiresAt,
+            })),
+            error: null,
+        };
+    }
+    catch (e) {
+        return { loading: false, accounts: [], error: e.message };
+    }
+}
+function formatExpiry(expiresAt) {
+    if (expiresAt === 0)
+        return dim('—');
+    const remainingMs = expiresAt - Date.now();
+    if (remainingMs < 0)
+        return fg('yellow', 'expired');
+    const hours = Math.floor(remainingMs / 3_600_000);
+    const minutes = Math.floor((remainingMs % 3_600_000) / 60_000);
+    if (hours > 24) {
+        const days = Math.floor(hours / 24);
+        return fg('green', `${days}d ${hours % 24}h`);
+    }
+    if (hours > 0)
+        return fg('green', `${hours}h ${minutes}m`);
+    return fg('green', `${minutes}m`);
+}

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