@askalf/dario 3.38.6 → 4.0.0

package/dist/tui/tabs/status.js

@@ -0,0 +1,132 @@
+/**
+ * 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 { fg, dim, brand } from '../render.js';
+import { renderKvRow } from '../layout.js';
+export const StatusTab = {
+    id: 'status',
+    label: 'Status',
+    hotkey: 's',
+    initialState() {
+        return {
+            loading: true,
+            health: null,
+            configSource: null,
+            lastRefreshAt: 0,
+            error: null,
+        };
+    },
+    async onMount(_state, ctx) {
+        return refreshStatus(ctx);
+    },
+    onKey(state, key) {
+        // `r` triggers a manual refresh by signaling the parent to call
+        // onMount again. The parent watches for a sentinel state.
+        if (key.name === 'printable' && key.ch === 'r' && !key.ctrl) {
+            return { ...state, loading: true };
+        }
+        return undefined;
+    },
+    render(state, dim_) {
+        const lines = [];
+        const w = dim_.cols;
+        if (state.loading && !state.health) {
+            lines.push('');
+            lines.push('  ' + dim('Loading status…'));
+            return lines.join('\n');
+        }
+        // ── Proxy section ──────────────────────────────────────────
+        lines.push(' ' + brand('Proxy'));
+        if (state.health) {
+            lines.push('  ' + renderKvRow('Status', fg('green', state.health.status), w - 4));
+            lines.push('  ' + renderKvRow('OAuth', formatOauth(state.health.oauth, state.health.expiresIn), w - 4));
+            lines.push('  ' + renderKvRow('Requests', String(state.health.requests ?? 0), w - 4));
+        }
+        else {
+            lines.push('  ' + renderKvRow('Status', fg('red', 'unreachable — is `dario proxy` running?'), w - 4));
+            if (state.error) {
+                lines.push('  ' + renderKvRow('Error', dim(state.error), w - 4));
+            }
+        }
+        lines.push('');
+        // ── Config section ─────────────────────────────────────────
+        lines.push(' ' + brand('Config'));
+        const sourceLabel = state.configSource === 'file' ? '~/.dario/config.json'
+            : state.configSource === 'missing' ? dim('(no file — using defaults)')
+                : state.configSource === 'invalid' ? fg('yellow', '(file present but invalid — using defaults)')
+                    : dim('not loaded');
+        lines.push('  ' + renderKvRow('Source', sourceLabel, w - 4));
+        lines.push('');
+        // ── Footer hint ────────────────────────────────────────────
+        lines.push('');
+        lines.push(' ' + dim(`Last refresh: ${formatAgo(state.lastRefreshAt)}. Press ${fg('cyan', 'r')} to refresh.`));
+        return lines.join('\n');
+    },
+};
+/**
+ * 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 async function refreshStatus(ctx) {
+    const { loadConfig } = await import('../../config-file.js');
+    const fileResult = loadConfig();
+    let health = null;
+    let error = null;
+    try {
+        const h = await ctx.client.health();
+        health = h;
+    }
+    catch (e) {
+        error = e.message;
+    }
+    return {
+        loading: false,
+        health,
+        configSource: fileResult.source,
+        lastRefreshAt: Date.now(),
+        error,
+    };
+}
+function formatOauth(label, expiresIn) {
+    if (label === 'healthy') {
+        return fg('green', expiresIn ? `healthy (expires in ${expiresIn})` : 'healthy');
+    }
+    if (label === 'expired')
+        return fg('yellow', 'expired (refresh on next request)');
+    if (label === 'broken')
+        return fg('red', 'broken — run `dario login`');
+    if (label === 'none')
+        return dim('no credentials');
+    return label;
+}
+function formatAgo(ts) {
+    if (ts === 0)
+        return 'never';
+    const secs = Math.floor((Date.now() - ts) / 1000);
+    if (secs < 1)
+        return 'just now';
+    if (secs < 60)
+        return `${secs}s ago`;
+    if (secs < 3600)
+        return `${Math.floor(secs / 60)}m ago`;
+    return `${Math.floor(secs / 3600)}h ago`;
+}

package/dist/tui/tui-app.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Top-level TuiApp — composes the six tabs into a single App<S>.
+ *
+ * Responsibilities:
+ *   - Render the header + tab strip + active tab body + footer
+ *   - Route keys: Tab cycles, q quits, hotkeys jump, else delegate
+ *   - Build per-tab TabContext (client + setState + registerCleanup)
+ *   - Drive an onTick heartbeat (every 250ms) for tabs that poll
+ *   - Run per-tab cleanups on tab-switch or App shutdown
+ */
+import { type StatusState } from './tabs/status.js';
+import { type ConfigState } from './tabs/config.js';
+import { type AnalyticsState } from './tabs/analytics.js';
+import { type HitsState } from './tabs/hits.js';
+import { type AccountsState } from './tabs/accounts.js';
+import { type BackendsState } from './tabs/backends.js';
+/**
+ * Composite state shape — one slice per tab plus the activeTab index.
+ * Each slice is held with its own static type so tabs don't lose
+ * type-safety; the parent dispatcher does the type-erasure when
+ * routing setState calls.
+ */
+export interface TuiState {
+    activeTab: number;
+    exiting: boolean;
+    status: StatusState;
+    config: ConfigState;
+    analytics: AnalyticsState;
+    hits: HitsState;
+    accounts: AccountsState;
+    backends: BackendsState;
+}
+export interface TuiAppOpts {
+    /** Base URL of the running proxy. Defaults to http://127.0.0.1:3456. */
+    proxyUrl?: string;
+    /** API key for the proxy (if DARIO_API_KEY is set). */
+    apiKey?: string;
+    /** dario package version, displayed in the header. */
+    version: string;
+}
+export declare function startTuiApp(opts: TuiAppOpts): Promise<void>;

package/dist/tui/tui-app.js

@@ -0,0 +1,217 @@
+/**
+ * Top-level TuiApp — composes the six tabs into a single App<S>.
+ *
+ * Responsibilities:
+ *   - Render the header + tab strip + active tab body + footer
+ *   - Route keys: Tab cycles, q quits, hotkeys jump, else delegate
+ *   - Build per-tab TabContext (client + setState + registerCleanup)
+ *   - Drive an onTick heartbeat (every 250ms) for tabs that poll
+ *   - Run per-tab cleanups on tab-switch or App shutdown
+ */
+import { App } from './app.js';
+import { ProxyClient } from './proxy-client.js';
+import { fg, dim } from './render.js';
+import { renderFooter, renderHeader, renderTabStrip } from './layout.js';
+import { StatusTab } from './tabs/status.js';
+import { ConfigTab } from './tabs/config.js';
+import { AnalyticsTab } from './tabs/analytics.js';
+import { HitsTab } from './tabs/hits.js';
+import { AccountsTab } from './tabs/accounts.js';
+import { BackendsTab } from './tabs/backends.js';
+const TICK_MS = 250;
+const TABS = [
+    StatusTab,
+    ConfigTab,
+    AnalyticsTab,
+    HitsTab,
+    AccountsTab,
+    BackendsTab,
+];
+export function startTuiApp(opts) {
+    const proxyUrl = opts.proxyUrl ?? 'http://127.0.0.1:3456';
+    const client = new ProxyClient({ baseUrl: proxyUrl, apiKey: opts.apiKey });
+    // Per-tab cleanup queues. Each entry is the cleanup fns the tab
+    // registered during its current mount. When the user switches tabs,
+    // we run + clear the OLD tab's cleanups before mounting the new one.
+    const cleanupsByTab = new Map();
+    for (let i = 0; i < TABS.length; i++)
+        cleanupsByTab.set(i, []);
+    const initialState = {
+        activeTab: 0,
+        exiting: false,
+        status: StatusTab.initialState(),
+        config: ConfigTab.initialState(),
+        analytics: AnalyticsTab.initialState(),
+        hits: HitsTab.initialState(),
+        accounts: AccountsTab.initialState(),
+        backends: BackendsTab.initialState(),
+    };
+    // Forward-declared App ref so the onKey closure can reference it
+    // before construction. TS needs the explicit annotation since
+    // strict mode disallows referencing a let-binding inside its
+    // own initializer expression.
+    let app;
+    app = new App({
+        initialState,
+        render: (state, dim_) => renderTui(state, dim_, opts.version, proxyUrl),
+        onKey: (state, key) => onKey(state, key, app, client, cleanupsByTab),
+        afterFrame: () => { },
+    });
+    // Mount the initial tab. The first tab's onMount fires before the
+    // first redraw — that means the loading state shows briefly until
+    // the async data arrives. Acceptable for v4.0; could be optimized
+    // by pre-fetching before app.start().
+    void mountTab(app, client, cleanupsByTab, initialState.activeTab);
+    // Tick heartbeat. Calls the active tab's onTick (if any) every
+    // TICK_MS. Each tab decides whether to act.
+    const tickInterval = setInterval(() => {
+        const s = app.getState();
+        const tab = TABS[s.activeTab];
+        if (tab.onTick) {
+            const ctx = makeContext(app, client, cleanupsByTab, s.activeTab);
+            tab.onTick(stateOf(s, s.activeTab), ctx);
+        }
+    }, TICK_MS);
+    // Global cleanup — fires when app.start()'s returned promise resolves
+    // (i.e. when App.stop() runs).
+    return app.start().finally(() => {
+        clearInterval(tickInterval);
+        // Run all per-tab cleanups
+        for (const fns of cleanupsByTab.values()) {
+            for (const fn of fns) {
+                try {
+                    fn();
+                }
+                catch { /* ignore */ }
+            }
+        }
+    });
+}
+// ── Wiring ─────────────────────────────────────────────────────────
+function onKey(state, key, app, client, cleanupsByTab) {
+    // ── Global keys ────────────────────────────────────────────
+    // q quits — but only when NOT inside an edit field (the Config
+    // tab's editor uses 'q' as a literal character).
+    const tab = TABS[state.activeTab];
+    const inEdit = state.activeTab === 1 /* config */ && state.config.editBuffer !== null;
+    if (!inEdit) {
+        if (key.name === 'printable' && key.ch === 'q' && !key.ctrl) {
+            app.stop();
+            return { ...state, exiting: true };
+        }
+        // Tab cycles forward; Shift+Tab cycles back. Some terminals send
+        // Shift+Tab as ESC[Z (BackTab) — parseKeys reports as 'unknown'
+        // currently. Listed for v4.x.
+        if (key.name === 'tab') {
+            return switchTab(state, (state.activeTab + 1) % TABS.length, app, client, cleanupsByTab);
+        }
+        // Hotkey jump
+        if (key.name === 'printable' && !key.ctrl) {
+            for (let i = 0; i < TABS.length; i++) {
+                if (TABS[i].hotkey === key.ch) {
+                    return switchTab(state, i, app, client, cleanupsByTab);
+                }
+            }
+        }
+    }
+    // Delegate to the active tab's onKey
+    const tabSlice = stateOf(state, state.activeTab);
+    const nextSlice = tab.onKey?.(tabSlice, key);
+    if (nextSlice !== undefined && nextSlice !== tabSlice) {
+        return withTabState(state, state.activeTab, nextSlice);
+    }
+    return undefined;
+}
+function switchTab(state, newIdx, app, client, cleanupsByTab) {
+    if (newIdx === state.activeTab)
+        return state;
+    // Run OLD tab's cleanup queue + clear it
+    const oldCleanups = cleanupsByTab.get(state.activeTab) ?? [];
+    for (const fn of oldCleanups) {
+        try {
+            fn();
+        }
+        catch { /* ignore */ }
+    }
+    cleanupsByTab.set(state.activeTab, []);
+    // Call the old tab's onUnmount (synchronous-only)
+    const oldTab = TABS[state.activeTab];
+    oldTab.onUnmount?.(stateOf(state, state.activeTab));
+    // Mount the new tab (fire-and-forget; async state updates via setState)
+    void mountTab(app, client, cleanupsByTab, newIdx);
+    return { ...state, activeTab: newIdx };
+}
+async function mountTab(app, client, cleanupsByTab, idx) {
+    const tab = TABS[idx];
+    if (!tab.onMount)
+        return;
+    const ctx = makeContext(app, client, cleanupsByTab, idx);
+    const sliceBefore = stateOf(app.getState(), idx);
+    const result = await tab.onMount(sliceBefore, ctx);
+    if (result !== undefined) {
+        app.setState((s) => withTabState(s, idx, result));
+    }
+}
+function makeContext(app, client, cleanupsByTab, idx) {
+    return {
+        client,
+        setState: (updater) => {
+            app.setState((s) => {
+                const currentSlice = stateOf(s, idx);
+                const nextSlice = typeof updater === 'function'
+                    ? updater(currentSlice)
+                    : { ...currentSlice, ...updater };
+                return withTabState(s, idx, nextSlice);
+            });
+        },
+        registerCleanup: (fn) => {
+            cleanupsByTab.get(idx)?.push(fn);
+        },
+    };
+}
+/** Read the state slice for tab `idx`. */
+function stateOf(s, idx) {
+    const key = TABS[idx].id;
+    return s[key];
+}
+/** Return a new TuiState with the slice for tab `idx` replaced. */
+function withTabState(s, idx, sliceVal) {
+    const key = TABS[idx].id;
+    return { ...s, [key]: sliceVal };
+}
+// ── Rendering ───────────────────────────────────────────────────
+function renderTui(state, dim_, version, proxyUrl) {
+    const cols = dim_.cols;
+    const rows = dim_.rows;
+    const out = [];
+    // Row 1: header
+    out.push(renderHeader(cols, { version, status: proxyUrl }));
+    // Row 2: tab strip
+    const tabLabels = TABS.map(t => t.label);
+    out.push(renderTabStrip(cols, tabLabels, state.activeTab));
+    out.push(dim('─'.repeat(cols)));
+    // Body — passed (cols, rows-5) so the tab knows it has rows 4..rows-2
+    const bodyRows = rows - 5;
+    const tab = TABS[state.activeTab];
+    const slice = stateOf(state, state.activeTab);
+    const body = tab.render(slice, { cols, rows: bodyRows });
+    out.push(body);
+    // Footer — fixed key hints (tab-cycling stays universal; per-tab
+    // hints are inside each tab body to keep the global footer stable).
+    const footerHints = [
+        { key: 'Tab', label: 'next tab' },
+        { key: 'q', label: 'quit' },
+        { key: 'r', label: 'refresh' },
+    ];
+    // Pad body to fill rows before the footer so the footer's row stays
+    // at the bottom (close to it — slight underflow OK; row count
+    // depends on each tab's content).
+    const bodyLines = body.split('\n').length;
+    if (bodyLines < bodyRows) {
+        out.push(''.padEnd(bodyRows - bodyLines, '\n'));
+    }
+    out.push(renderFooter(cols, footerHints));
+    // Connect with newlines
+    void fg; // silence unused if neither tab uses it through this module
+    return out.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.38.6",
+  "version": "4.0.0",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {