@askalf/dario 3.38.6 → 4.0.1

package/dist/tui/render.d.ts

@@ -0,0 +1,178 @@
+/**
+ * TUI rendering primitives — pure ANSI escape sequence helpers.
+ *
+ * Every function in this module is a pure string-returning helper. No
+ * side effects, no console writes. The App's render() loop accumulates
+ * these strings into a single buffer, then flushes once to stdout. This
+ * keeps render testable (assert string equality against fixtures) and
+ * keeps flicker minimal (single write call per frame).
+ *
+ * Color set: a deliberate 16-color subset of the ANSI palette plus a
+ * handful of 256-color brand accents. Reasoning: 16-color is universal,
+ * the brand greens (#00ff88-ish) are used sparingly for the dario
+ * accent and degrade gracefully on terminals that can't render them.
+ *
+ * What this module deliberately does NOT do:
+ *   - Track cursor position (callers pass row/col explicitly)
+ *   - Diff frames (full-screen redraw per frame is fast enough at
+ *     ~3000 cells; complexity not worth it)
+ *   - Handle terminal capabilities probing (use ANSI + assume modern)
+ */
+/**
+ * Move the cursor to (row, col). 1-indexed, matching the ANSI spec —
+ * row=1 is the top line, col=1 is the leftmost column.
+ */
+export declare function moveTo(row: number, col: number): string;
+/** Hide the blinking cursor (TUI doesn't need it). */
+export declare const hideCursor = "\u001B[?25l";
+/** Restore the cursor. ALWAYS run on exit to leave the terminal sane. */
+export declare const showCursor = "\u001B[?25h";
+/** Enter the alternate screen buffer — TUI lives here so quit restores prior shell content. */
+export declare const enterAltScreen = "\u001B[?1049h";
+/** Leave the alternate screen buffer. Pair with enterAltScreen on exit. */
+export declare const leaveAltScreen = "\u001B[?1049l";
+/** Clear the entire screen and move cursor to home. */
+export declare const clearScreen = "\u001B[2J\u001B[H";
+/** Clear from cursor to end of line. */
+export declare const clearLineRight = "\u001B[K";
+/** Reset all SGR (color + style) attributes. */
+export declare const reset = "\u001B[0m";
+/**
+ * Foreground color names mapped to ANSI codes. `default` resets to
+ * the terminal's default foreground.
+ */
+export declare const FG: {
+    readonly default: 39;
+    readonly black: 30;
+    readonly red: 31;
+    readonly green: 32;
+    readonly yellow: 33;
+    readonly blue: 34;
+    readonly magenta: 35;
+    readonly cyan: 36;
+    readonly white: 37;
+    readonly brightBlack: 90;
+    readonly brightRed: 91;
+    readonly brightGreen: 92;
+    readonly brightYellow: 93;
+    readonly brightBlue: 94;
+    readonly brightMagenta: 95;
+    readonly brightCyan: 96;
+    readonly brightWhite: 97;
+};
+/** Background color names mapped to ANSI codes. */
+export declare const BG: {
+    readonly default: 49;
+    readonly black: 40;
+    readonly red: 41;
+    readonly green: 42;
+    readonly yellow: 43;
+    readonly blue: 44;
+    readonly magenta: 45;
+    readonly cyan: 46;
+    readonly white: 47;
+    readonly brightBlack: 100;
+    readonly brightRed: 101;
+    readonly brightGreen: 102;
+    readonly brightYellow: 103;
+    readonly brightBlue: 104;
+    readonly brightMagenta: 105;
+    readonly brightCyan: 106;
+    readonly brightWhite: 107;
+};
+export type FgColor = keyof typeof FG;
+export type BgColor = keyof typeof BG;
+/**
+ * Wrap text in foreground-color SGR codes. Resets to default fg at
+ * the end so subsequent uncolored text isn't accidentally colored.
+ *
+ * Example: `fg('green', 'OK')` → `\x1b[32mOK\x1b[39m`
+ */
+export declare function fg(color: FgColor, text: string): string;
+export declare function bg(color: BgColor, text: string): string;
+export declare function bold(text: string): string;
+export declare function dim(text: string): string;
+export declare function inverse(text: string): string;
+export declare function underline(text: string): string;
+/**
+ * Brand accent — the askalf green (#00ff88-ish) via the 256-color
+ * palette index 48. Falls back gracefully on terminals that don't
+ * render 256-color (they show as bright green).
+ */
+export declare function brand(text: string): string;
+/**
+ * Visible-width of a string. ANSI escape sequences and zero-width
+ * sequences contribute 0. Tabs count as 1 (terminals vary; better
+ * to under- than over-estimate). Multi-byte characters (CJK, emoji)
+ * are NOT special-cased in v4.0 — the TUI's content is ASCII-dominant
+ * (model names, numbers, labels). A future revision can add a
+ * `string-width`-style lookup if non-ASCII becomes common.
+ */
+export declare function visibleWidth(s: string): number;
+/**
+ * Truncate `text` to at most `maxWidth` visible chars, appending `…`
+ * if anything was clipped. ANSI sequences within the truncated portion
+ * are preserved verbatim; truncation only counts visible characters.
+ *
+ * Example: truncate('hello world', 8) → 'hello w…'
+ */
+export declare function truncate(text: string, maxWidth: number, ellipsis?: string): string;
+/** Pad `text` (right-aligned by default 'left' fills right side) to `width`. */
+export declare function pad(text: string, width: number, align?: 'left' | 'right' | 'center'): string;
+/**
+ * Render a horizontal progress bar.
+ *
+ *   value:   0..1 (clamped)
+ *   width:   total cell count of the bar
+ *
+ * Uses the full-block ▓ / shade ░ characters; passes through as plain
+ * ASCII on terminals that don't render the box-drawing set (they look
+ * like `?` but the layout still works).
+ */
+export declare function progressBar(value: number, width: number, opts?: {
+    filled?: string;
+    empty?: string;
+}): string;
+/**
+ * Box-drawing characters for borders. Set picked to render well on
+ * most terminals (Unicode box-drawing). Override via `customChars` if
+ * a terminal renders these badly — but the default targets the
+ * 99%-of-users case.
+ */
+export declare const BOX: {
+    readonly topLeft: "┌";
+    readonly topRight: "┐";
+    readonly bottomLeft: "└";
+    readonly bottomRight: "┘";
+    readonly horizontal: "─";
+    readonly vertical: "│";
+    readonly cross: "┼";
+    readonly tLeft: "├";
+    readonly tRight: "┤";
+    readonly tTop: "┬";
+    readonly tBottom: "┴";
+};
+/**
+ * Render a box at (row, col) with the given width and height. Returns
+ * the full ANSI string (positioned writes + box characters). The
+ * interior is NOT cleared — callers paint inside the box separately.
+ */
+export declare function drawBox(row: number, col: number, width: number, height: number): string;
+/**
+ * Frame builder. The App's render() collects strings into one of these
+ * then calls `flush(stdout)` for a single write. Single-write rendering
+ * eliminates flicker on most terminals.
+ */
+export declare class Frame {
+    private chunks;
+    /** Append a string. No positioning — caller is responsible. */
+    write(s: string): void;
+    /** Append a positioned write at (row, col). */
+    writeAt(row: number, col: number, s: string): void;
+    /** Return the accumulated frame as a single string. */
+    toString(): string;
+    /** Number of accumulated chunks (debugging aid). */
+    get length(): number;
+    /** Drop everything. Reuses the array allocation. */
+    clear(): void;
+}

package/dist/tui/render.js

@@ -0,0 +1,246 @@
+/**
+ * TUI rendering primitives — pure ANSI escape sequence helpers.
+ *
+ * Every function in this module is a pure string-returning helper. No
+ * side effects, no console writes. The App's render() loop accumulates
+ * these strings into a single buffer, then flushes once to stdout. This
+ * keeps render testable (assert string equality against fixtures) and
+ * keeps flicker minimal (single write call per frame).
+ *
+ * Color set: a deliberate 16-color subset of the ANSI palette plus a
+ * handful of 256-color brand accents. Reasoning: 16-color is universal,
+ * the brand greens (#00ff88-ish) are used sparingly for the dario
+ * accent and degrade gracefully on terminals that can't render them.
+ *
+ * What this module deliberately does NOT do:
+ *   - Track cursor position (callers pass row/col explicitly)
+ *   - Diff frames (full-screen redraw per frame is fast enough at
+ *     ~3000 cells; complexity not worth it)
+ *   - Handle terminal capabilities probing (use ANSI + assume modern)
+ */
+// ── Escape sequences ────────────────────────────────────────────────
+/** Control Sequence Introducer. */
+const ESC = '\x1b[';
+/**
+ * Move the cursor to (row, col). 1-indexed, matching the ANSI spec —
+ * row=1 is the top line, col=1 is the leftmost column.
+ */
+export function moveTo(row, col) {
+    return `${ESC}${row};${col}H`;
+}
+/** Hide the blinking cursor (TUI doesn't need it). */
+export const hideCursor = `${ESC}?25l`;
+/** Restore the cursor. ALWAYS run on exit to leave the terminal sane. */
+export const showCursor = `${ESC}?25h`;
+/** Enter the alternate screen buffer — TUI lives here so quit restores prior shell content. */
+export const enterAltScreen = `${ESC}?1049h`;
+/** Leave the alternate screen buffer. Pair with enterAltScreen on exit. */
+export const leaveAltScreen = `${ESC}?1049l`;
+/** Clear the entire screen and move cursor to home. */
+export const clearScreen = `${ESC}2J${ESC}H`;
+/** Clear from cursor to end of line. */
+export const clearLineRight = `${ESC}K`;
+/** Reset all SGR (color + style) attributes. */
+export const reset = `${ESC}0m`;
+// ── Colors (16-color ANSI + brand accent) ──────────────────────────
+/**
+ * Foreground color names mapped to ANSI codes. `default` resets to
+ * the terminal's default foreground.
+ */
+export const FG = {
+    default: 39,
+    black: 30, red: 31, green: 32, yellow: 33,
+    blue: 34, magenta: 35, cyan: 36, white: 37,
+    brightBlack: 90, brightRed: 91, brightGreen: 92, brightYellow: 93,
+    brightBlue: 94, brightMagenta: 95, brightCyan: 96, brightWhite: 97,
+};
+/** Background color names mapped to ANSI codes. */
+export const BG = {
+    default: 49,
+    black: 40, red: 41, green: 42, yellow: 43,
+    blue: 44, magenta: 45, cyan: 46, white: 47,
+    brightBlack: 100, brightRed: 101, brightGreen: 102, brightYellow: 103,
+    brightBlue: 104, brightMagenta: 105, brightCyan: 106, brightWhite: 107,
+};
+/**
+ * Wrap text in foreground-color SGR codes. Resets to default fg at
+ * the end so subsequent uncolored text isn't accidentally colored.
+ *
+ * Example: `fg('green', 'OK')` → `\x1b[32mOK\x1b[39m`
+ */
+export function fg(color, text) {
+    return `${ESC}${FG[color]}m${text}${ESC}${FG.default}m`;
+}
+export function bg(color, text) {
+    return `${ESC}${BG[color]}m${text}${ESC}${BG.default}m`;
+}
+export function bold(text) {
+    return `${ESC}1m${text}${ESC}22m`;
+}
+export function dim(text) {
+    return `${ESC}2m${text}${ESC}22m`;
+}
+export function inverse(text) {
+    return `${ESC}7m${text}${ESC}27m`;
+}
+export function underline(text) {
+    return `${ESC}4m${text}${ESC}24m`;
+}
+/**
+ * Brand accent — the askalf green (#00ff88-ish) via the 256-color
+ * palette index 48. Falls back gracefully on terminals that don't
+ * render 256-color (they show as bright green).
+ */
+export function brand(text) {
+    return `${ESC}38;5;48m${text}${ESC}${FG.default}m`;
+}
+// ── String helpers ─────────────────────────────────────────────────
+/**
+ * Visible-width of a string. ANSI escape sequences and zero-width
+ * sequences contribute 0. Tabs count as 1 (terminals vary; better
+ * to under- than over-estimate). Multi-byte characters (CJK, emoji)
+ * are NOT special-cased in v4.0 — the TUI's content is ASCII-dominant
+ * (model names, numbers, labels). A future revision can add a
+ * `string-width`-style lookup if non-ASCII becomes common.
+ */
+export function visibleWidth(s) {
+    // Strip ANSI escape sequences (CSI + everything up to terminating byte).
+    const stripped = s.replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, '');
+    return stripped.length;
+}
+/**
+ * Truncate `text` to at most `maxWidth` visible chars, appending `…`
+ * if anything was clipped. ANSI sequences within the truncated portion
+ * are preserved verbatim; truncation only counts visible characters.
+ *
+ * Example: truncate('hello world', 8) → 'hello w…'
+ */
+export function truncate(text, maxWidth, ellipsis = '…') {
+    if (maxWidth <= 0)
+        return '';
+    if (visibleWidth(text) <= maxWidth)
+        return text;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (maxWidth <= ellipsisWidth)
+        return ellipsis.slice(0, maxWidth);
+    // Walk the string, counting visible chars, stop when we'd exceed
+    // maxWidth - ellipsisWidth so we have room to append.
+    const target = maxWidth - ellipsisWidth;
+    let out = '';
+    let visible = 0;
+    let i = 0;
+    while (i < text.length && visible < target) {
+        if (text[i] === '\x1b' && text[i + 1] === '[') {
+            // Copy the full escape sequence
+            const m = text.slice(i).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        out += text[i];
+        visible++;
+        i++;
+    }
+    return out + ellipsis;
+}
+/** Pad `text` (right-aligned by default 'left' fills right side) to `width`. */
+export function pad(text, width, align = 'left') {
+    const w = visibleWidth(text);
+    if (w >= width)
+        return truncate(text, width);
+    const gap = width - w;
+    if (align === 'right')
+        return ' '.repeat(gap) + text;
+    if (align === 'center') {
+        const left = Math.floor(gap / 2);
+        const right = gap - left;
+        return ' '.repeat(left) + text + ' '.repeat(right);
+    }
+    return text + ' '.repeat(gap);
+}
+/**
+ * Render a horizontal progress bar.
+ *
+ *   value:   0..1 (clamped)
+ *   width:   total cell count of the bar
+ *
+ * Uses the full-block ▓ / shade ░ characters; passes through as plain
+ * ASCII on terminals that don't render the box-drawing set (they look
+ * like `?` but the layout still works).
+ */
+export function progressBar(value, width, opts = {}) {
+    const filled = opts.filled ?? '█';
+    const empty = opts.empty ?? '░';
+    const clamped = Math.max(0, Math.min(1, value));
+    const cells = Math.round(clamped * width);
+    return filled.repeat(cells) + empty.repeat(width - cells);
+}
+/**
+ * Box-drawing characters for borders. Set picked to render well on
+ * most terminals (Unicode box-drawing). Override via `customChars` if
+ * a terminal renders these badly — but the default targets the
+ * 99%-of-users case.
+ */
+export const BOX = {
+    topLeft: '┌', topRight: '┐',
+    bottomLeft: '└', bottomRight: '┘',
+    horizontal: '─', vertical: '│',
+    cross: '┼', tLeft: '├', tRight: '┤',
+    tTop: '┬', tBottom: '┴',
+};
+/**
+ * Render a box at (row, col) with the given width and height. Returns
+ * the full ANSI string (positioned writes + box characters). The
+ * interior is NOT cleared — callers paint inside the box separately.
+ */
+export function drawBox(row, col, width, height) {
+    if (width < 2 || height < 2)
+        return '';
+    const out = [];
+    // Top border
+    out.push(moveTo(row, col));
+    out.push(BOX.topLeft + BOX.horizontal.repeat(width - 2) + BOX.topRight);
+    // Sides
+    for (let r = 1; r < height - 1; r++) {
+        out.push(moveTo(row + r, col));
+        out.push(BOX.vertical);
+        out.push(moveTo(row + r, col + width - 1));
+        out.push(BOX.vertical);
+    }
+    // Bottom border
+    out.push(moveTo(row + height - 1, col));
+    out.push(BOX.bottomLeft + BOX.horizontal.repeat(width - 2) + BOX.bottomRight);
+    return out.join('');
+}
+// ── Frame buffer ───────────────────────────────────────────────────
+/**
+ * Frame builder. The App's render() collects strings into one of these
+ * then calls `flush(stdout)` for a single write. Single-write rendering
+ * eliminates flicker on most terminals.
+ */
+export class Frame {
+    chunks = [];
+    /** Append a string. No positioning — caller is responsible. */
+    write(s) {
+        this.chunks.push(s);
+    }
+    /** Append a positioned write at (row, col). */
+    writeAt(row, col, s) {
+        this.chunks.push(moveTo(row, col));
+        this.chunks.push(s);
+    }
+    /** Return the accumulated frame as a single string. */
+    toString() {
+        return this.chunks.join('');
+    }
+    /** Number of accumulated chunks (debugging aid). */
+    get length() {
+        return this.chunks.length;
+    }
+    /** Drop everything. Reuses the array allocation. */
+    clear() {
+        this.chunks.length = 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`);
+}