@addai/node 0.4.0

package/dist/tui/harnesses.js

@@ -0,0 +1,354 @@
+"use strict";
+// `entities-runtime harnesses` — interactive harness manager in the
+// Claude Code terminal idiom: alt-screen, rounded panels, dim chrome,
+// ❯ selection, braille spinner, ⏺ status dots. Hand-rolled ANSI — the
+// daemon deliberately has no TUI framework dependency.
+//
+// Local actions hand the real terminal to the harness CLI itself (there
+// is nothing to bridge when you're already at the machine): install
+// streams npm output into a panel; login leaves the alt screen, runs the
+// CLI's own login flow attached to your TTY, then re-probes on return.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHarnessesTui = runHarnessesTui;
+const child_process_1 = require("child_process");
+const readline = __importStar(require("readline"));
+const capabilities_1 = require("../capabilities");
+const win_1 = require("../win");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const harness_registry_1 = require("../harness-registry");
+const render_1 = require("./render");
+/* ── ansi helpers ────────────────────────────────────────────────────── */
+const ESC = '\x1b[';
+const dim = (s) => `${ESC}2m${s}${ESC}22m`;
+const bold = (s) => `${ESC}1m${s}${ESC}22m`;
+const fg = (n, s) => `${ESC}38;5;${n}m${s}${ESC}39m`;
+const green = (s) => fg(114, s);
+const yellow = (s) => fg(179, s);
+const grey = (s) => fg(244, s);
+const cyan = (s) => fg(80, s);
+const altOn = () => process.stdout.write(`${ESC}?1049h${ESC}?25l`);
+const altOff = () => process.stdout.write(`${ESC}?1049l${ESC}?25h`);
+const home = () => process.stdout.write(`${ESC}H${ESC}2J`);
+const SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const width = () => Math.min(process.stdout.columns || 100, 110);
+function panel(title, lines) {
+    const w = width() - 2;
+    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    const top = `${dim('╭─')} ${bold(title)} ${dim('─'.repeat(Math.max(1, w - strip(title).length - 4)) + '╮')}`;
+    const body = lines.map(raw => {
+        // Rows are wider than a narrow terminal: without a cut they run past
+        // the right border and the panel frame comes apart.
+        const l = (0, render_1.truncate)(raw, w - 2);
+        const pad = Math.max(0, w - 2 - strip(l).length);
+        return `${dim('│')} ${l}${' '.repeat(pad)} ${dim('│')}`;
+    });
+    const bottom = dim(`╰${'─'.repeat(w)}╯`);
+    return [top, ...body, bottom].join('\n');
+}
+function dot(p) {
+    if (!p?.available)
+        return grey('⏺');
+    return p.authed ? green('⏺') : yellow('⏺');
+}
+function actionFor(id, p) {
+    if (!p?.available)
+        return (0, harness_registry_1.isInstallable)(id) ? 'install' : 'how to install';
+    if (!p.authed)
+        return 'log in';
+    return harness_registry_1.HARNESSES[id].logout ? 'log out' : 'ok';
+}
+function row(id, p, selected) {
+    const spec = harness_registry_1.HARNESSES[id];
+    // Budget: the action hint on the right is the point of the row, so the
+    // wide informational columns give up space before it does. At 100 cols
+    // the old widths pushed the action past the border and it was cut.
+    const name = spec.label.padEnd(13);
+    const ver = (p?.version ? `v${p.version}` : '—').padEnd(11).slice(0, 11);
+    const who = (p?.authed
+        ? `${p.account ?? p.accountKind ?? 'logged in'}${p.plan ? ` · ${p.plan}` : ''}`
+        : p?.available ? 'not logged in' : 'not installed').padEnd(24).slice(0, 24);
+    const models = `${p?.models?.length ?? 0} models`.padEnd(9);
+    const efforts = spec.efforts.length ? spec.efforts.join('/') : '—';
+    const act = actionFor(id, p);
+    const actTxt = act === 'ok' ? green('✓') : act === 'log out' ? dim('↵ log out') : cyan(`↵ ${act}`);
+    const line = `${dot(p)}  ${name} ${dim(ver)} ${who} ${dim(models)} ${dim(efforts.padEnd(17).slice(0, 17))} ${actTxt}`;
+    return selected ? `${cyan('❯')} ${bold(line)}` : `  ${line}`;
+}
+function render(st) {
+    home();
+    const lines = [];
+    if (!st.caps) {
+        lines.push(`${cyan(SPIN[st.spin % SPIN.length])} probing installed harnesses…`);
+    }
+    else {
+        lines.push(dim('   harness       version     account                  models    efforts           action'));
+        harness_registry_1.HARNESS_IDS.forEach((id, i) => lines.push(row(id, st.caps[id], i === st.sel)));
+    }
+    if (st.busy)
+        lines.push('', `${cyan(SPIN[st.spin % SPIN.length])} ${st.busy}`);
+    if (st.log.length) {
+        lines.push('');
+        st.log.slice(-8).forEach(l => lines.push(dim(l.slice(0, width() - 8))));
+    }
+    if (st.note)
+        lines.push('', st.note);
+    process.stdout.write(panel('Harnesses', lines) + '\n');
+    process.stdout.write(dim('  ↑/↓ move · ↵ install / log in · r refresh · q quit\n'));
+}
+/* ── actions ─────────────────────────────────────────────────────────── */
+async function installSelected(st, id, redraw) {
+    const spec = harness_registry_1.HARNESSES[id];
+    if (!(0, harness_registry_1.isInstallable)(id)) {
+        st.note = yellow(`${spec.label}: ${spec.login.instructions}`);
+        return;
+    }
+    st.busy = `installing ${spec.label} (npm i -g ${spec.npmPackage})`;
+    st.log = [];
+    redraw();
+    const inv = (0, win_1.resolveCliInvocation)('npm', ['install', '-g', spec.npmPackage]);
+    await new Promise(resolve => {
+        const child = (0, child_process_1.spawn)(inv.file, inv.args, { env: process.env });
+        const onChunk = (b) => {
+            st.log.push(...b.toString('utf8').split('\n').filter(Boolean));
+            redraw();
+        };
+        child.stdout?.on('data', onChunk);
+        child.stderr?.on('data', onChunk);
+        child.on('exit', code => {
+            st.busy = null;
+            st.note = code === 0 ? green(`✓ ${spec.label} installed`) : fg(203, `✗ npm exited ${code}`);
+            resolve();
+        });
+        child.on('error', err => { st.busy = null; st.note = fg(203, `✗ ${err.message}`); resolve(); });
+    });
+}
+function logoutSelected(id) {
+    const spec = harness_registry_1.HARNESSES[id];
+    if (!spec.logout)
+        return `${spec.label} can only be logged out on the device`;
+    if (spec.logout.cmd) {
+        const bin = spec.findBinary();
+        if (!bin)
+            return `${spec.label} is not installed`;
+        const inv = (0, win_1.resolveCliInvocation)(bin, spec.logout.cmd);
+        const res = (0, child_process_1.spawnSync)(inv.file, inv.args, { stdio: 'ignore', env: process.env, timeout: 60_000 });
+        if (res.status !== 0)
+            return `logout exited with code ${res.status ?? '?'}`;
+    }
+    for (const rel of spec.logout.files ?? []) {
+        try {
+            fs.rmSync(path.join(os.homedir(), rel), { force: true });
+        }
+        catch { /* best effort */ }
+    }
+    for (const [rel, varName] of spec.logout.envStrip ?? []) {
+        const envPath = path.join(os.homedir(), rel);
+        try {
+            const body = fs.readFileSync(envPath, 'utf8');
+            fs.writeFileSync(envPath, body.split('\n').filter(l => !l.startsWith(`${varName}=`)).join('\n'), { mode: 0o600 });
+        }
+        catch { /* nothing to strip */ }
+    }
+    return null;
+}
+function loginSelected(id) {
+    const spec = harness_registry_1.HARNESSES[id];
+    const bin = spec.findBinary();
+    if (!bin)
+        return `${spec.label} is not installed`;
+    // Hand the real terminal to the CLI — leave the alt screen first.
+    altOff();
+    console.log(cyan(`\n— ${spec.label} login —`));
+    console.log(dim(spec.login.instructions) + '\n');
+    const args = spec.login.strategy === 'pty-url-code' ? (spec.login.loginArgs ?? []) : [];
+    const inv = (0, win_1.resolveCliInvocation)(bin, args);
+    const res = (0, child_process_1.spawnSync)(inv.file, inv.args, { stdio: 'inherit', env: process.env });
+    altOn();
+    return res.status === 0 ? null : `login exited with code ${res.status ?? '?'}`;
+}
+/* ── entry ───────────────────────────────────────────────────────────── */
+async function plainStatus() {
+    const caps = await (0, capabilities_1.probeCapabilities)();
+    for (const id of harness_registry_1.HARNESS_IDS) {
+        const p = caps[id];
+        const state = !p?.available ? 'not installed' : p.authed ? `authed (${p.account ?? p.accountKind ?? '?'})` : 'not logged in';
+        console.log(`${id.padEnd(8)} ${(p?.version ?? '—').padEnd(12)} ${state}`);
+    }
+}
+/**
+ * Run the harness manager.
+ *
+ * The returned promise resolves when the USER LEAVES the screen — not when
+ * the first capability probe finishes. Resolving early is what made the
+ * embedded case flicker: the dashboard re-attached its own keypress handler
+ * and repainted while this screen was still live, and the two fought over
+ * the terminal.
+ *
+ * `embedded` distinguishes `ainode harnesses` (q exits the process) from
+ * the dashboard's `h` (q hands control back to the caller). Ctrl-C always
+ * ends the process.
+ */
+async function runHarnessesTui(opts = {}) {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        await plainStatus();
+        return;
+    }
+    const st = { caps: null, sel: 0, spin: 0, busy: null, log: [], note: null, confirmLogout: null };
+    const redraw = () => render(st);
+    altOn();
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let done = null;
+    const spinTimer = setInterval(() => { st.spin++; if (st.busy || !st.caps)
+        redraw(); }, 90);
+    const detach = () => {
+        clearInterval(spinTimer);
+        process.stdin.off('keypress', onKeypress);
+    };
+    const quit = (hard) => {
+        detach();
+        if (opts.embedded && !hard) {
+            done?.();
+            return;
+        }
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        altOff();
+        process.exit(0);
+    };
+    const reprobe = async () => {
+        st.caps = null;
+        redraw();
+        st.caps = await (0, capabilities_1.probeCapabilities)();
+        redraw();
+    };
+    let acting = false;
+    function onKeypress(_str, key) {
+        void (async () => {
+            if (!key || acting)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                quit(true);
+                return;
+            }
+            if (key.name === 'q') {
+                quit(false);
+                return;
+            }
+            if (!st.caps)
+                return;
+            if (st.confirmLogout) {
+                const target = st.confirmLogout;
+                st.confirmLogout = null;
+                if (key.name === 'y') {
+                    acting = true;
+                    try {
+                        const err = logoutSelected(target);
+                        st.note = err ? fg(203, `✗ ${err}`) : green(`✓ ${harness_registry_1.HARNESSES[target].label} logged out`);
+                        await reprobe();
+                    }
+                    finally {
+                        acting = false;
+                    }
+                }
+                else {
+                    st.note = dim('logout cancelled');
+                    redraw();
+                }
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                st.sel = (st.sel + harness_registry_1.HARNESS_IDS.length - 1) % harness_registry_1.HARNESS_IDS.length;
+                redraw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                st.sel = (st.sel + 1) % harness_registry_1.HARNESS_IDS.length;
+                redraw();
+                return;
+            }
+            if (key.name === 'r') {
+                await reprobe();
+                return;
+            }
+            if (key.name !== 'return')
+                return;
+            const id = harness_registry_1.HARNESS_IDS[st.sel];
+            const p = st.caps[id];
+            acting = true;
+            try {
+                if (!p?.available) {
+                    await installSelected(st, id, redraw);
+                    await reprobe();
+                }
+                else if (!p.authed) {
+                    const err = loginSelected(id);
+                    st.note = err ? fg(203, `✗ ${err}`) : green('✓ login flow finished — verifying…');
+                    await reprobe();
+                    const now = st.caps?.[id];
+                    if (now?.authed)
+                        st.note = green(`✓ ${harness_registry_1.HARNESSES[id].label} logged in as ${now.account ?? now.accountKind ?? '?'}`);
+                    else if (!err)
+                        st.note = yellow(`${harness_registry_1.HARNESSES[id].label} still reports unauthenticated`);
+                    redraw();
+                }
+                else if (harness_registry_1.HARNESSES[id].logout) {
+                    st.confirmLogout = id;
+                    st.note = yellow(`log out of ${harness_registry_1.HARNESSES[id].label}? press y to confirm`);
+                    redraw();
+                }
+                else {
+                    st.note = green(`${harness_registry_1.HARNESSES[id].label} is installed and logged in.`);
+                    redraw();
+                }
+            }
+            finally {
+                acting = false;
+            }
+        })();
+    }
+    // The exit promise is created BEFORE the first probe, not after it.
+    // Probing five CLIs takes seconds; if `q` arrives during that window and
+    // `done` isn't wired yet, quit() detaches the key listener and resolves
+    // nothing — the screen wedges with no way out.
+    const exited = new Promise(resolve => { done = resolve; });
+    process.stdin.on('keypress', onKeypress);
+    void reprobe();
+    await exited;
+}

package/dist/tui/render.d.ts

@@ -0,0 +1,21 @@
+export declare const SPIN: string[];
+export declare function stripAnsi(s: string): string;
+export declare function visibleWidth(s: string): number;
+/** Cut to `max` VISIBLE columns, ellipsis included in the budget. */
+export declare function truncate(s: string, max: number): string;
+export declare function padEndVisible(s: string, width: number): string;
+export declare const dim: (s: string) => string;
+export declare const bold: (s: string) => string;
+export declare const green: (s: string) => string;
+export declare const yellow: (s: string) => string;
+export declare const grey: (s: string) => string;
+export declare const cyan: (s: string) => string;
+export declare const red: (s: string) => string;
+export declare function termWidth(): number;
+/** A rounded panel. Every returned line has exactly `width` visible columns. */
+export declare function panel(title: string, lines: string[], width: number): string[];
+export declare function fmtRelative(iso: string | null | undefined, now?: number): string;
+export declare function fmtDuration(ms: number | null): string;
+export declare const altOn: () => void;
+export declare const altOff: () => void;
+export declare const home: () => void;

package/dist/tui/render.js

@@ -0,0 +1,116 @@
+"use strict";
+// ANSI primitives for the +Ai Node console UI. Hand-rolled on purpose:
+// the daemon ships two dependencies and a TUI framework is not going to
+// be the third.
+//
+// Everything here is pure except the three cursor/screen writers at the
+// bottom, which is what lets the screens be unit-tested without a TTY.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.home = exports.altOff = exports.altOn = exports.red = exports.cyan = exports.grey = exports.yellow = exports.green = exports.bold = exports.dim = exports.SPIN = void 0;
+exports.stripAnsi = stripAnsi;
+exports.visibleWidth = visibleWidth;
+exports.truncate = truncate;
+exports.padEndVisible = padEndVisible;
+exports.termWidth = termWidth;
+exports.panel = panel;
+exports.fmtRelative = fmtRelative;
+exports.fmtDuration = fmtDuration;
+const E = '\x1b[';
+exports.SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/** Not global: a /g regex carries lastIndex between calls and would make
+ *  repeated .test() calls alternate true/false. */
+const ANSI_RE = /\x1b\[[0-9;]*m/;
+const ANSI_RE_G = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE_G, '');
+}
+function visibleWidth(s) {
+    return stripAnsi(s).length;
+}
+/** Cut to `max` VISIBLE columns, ellipsis included in the budget. */
+function truncate(s, max) {
+    if (max <= 0)
+        return '';
+    if (visibleWidth(s) <= max)
+        return s;
+    const coloured = ANSI_RE.test(s);
+    let out = '';
+    let seen = 0;
+    const budget = max - 1;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\x1b') {
+            const m = ANSI_RE.exec(s.slice(i));
+            if (m && m.index === 0) {
+                out += m[0];
+                i += m[0].length - 1;
+                continue;
+            }
+        }
+        if (seen >= budget)
+            break;
+        out += s[i];
+        seen++;
+    }
+    // The reset only matters when we cut mid-colour; adding it unconditionally
+    // would make truncate('abcdefgh', 4) !== 'abc…' for plain text.
+    return coloured ? `${out}${E}0m…` : `${out}…`;
+}
+function padEndVisible(s, width) {
+    const pad = Math.max(0, width - visibleWidth(s));
+    return s + ' '.repeat(pad);
+}
+const wrapCode = (on, off) => (s) => `${E}${on}${s}${E}${off}`;
+exports.dim = wrapCode('2m', '22m');
+exports.bold = wrapCode('1m', '22m');
+const fg = (n) => (s) => `${E}38;5;${n}m${s}${E}39m`;
+exports.green = fg(114);
+exports.yellow = fg(179);
+exports.grey = fg(244);
+exports.cyan = fg(80);
+exports.red = fg(203);
+function termWidth() {
+    return Math.min(process.stdout.columns || 100, 110);
+}
+/** A rounded panel. Every returned line has exactly `width` visible columns. */
+function panel(title, lines, width) {
+    const inner = width - 4;
+    // "╭─ " + title + " " + rule + "╮"
+    const ruleLen = Math.max(1, width - visibleWidth(title) - 5);
+    const top = `${(0, exports.dim)('╭─')} ${(0, exports.bold)(title)} ${(0, exports.dim)('─'.repeat(ruleLen))}${(0, exports.dim)('╮')}`;
+    const body = lines.map(l => `${(0, exports.dim)('│')} ${padEndVisible(truncate(l, inner), inner)} ${(0, exports.dim)('│')}`);
+    const bottom = (0, exports.dim)(`╰${'─'.repeat(width - 2)}╯`);
+    return [padEndVisible(truncate(top, width), width), ...body, bottom];
+}
+function fmtRelative(iso, now = Date.now()) {
+    if (!iso)
+        return 'never';
+    const s = Math.floor((now - new Date(iso).getTime()) / 1000);
+    if (s < 60)
+        return s <= 1 ? 'just now' : `${s}s ago`;
+    const min = Math.floor(s / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    return `${Math.floor(hr / 24)}d ago`;
+}
+function fmtDuration(ms) {
+    if (ms == null)
+        return '—';
+    if (ms < 1000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m${String(s % 60).padStart(2, '0')}s`;
+    return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, '0')}m`;
+}
+const altOn = () => { process.stdout.write(`${E}?1049h${E}?25l`); };
+exports.altOn = altOn;
+const altOff = () => { process.stdout.write(`${E}?1049l${E}?25h`); };
+exports.altOff = altOff;
+const home = () => { process.stdout.write(`${E}H${E}2J`); };
+exports.home = home;

package/dist/tui/requests.d.ts

@@ -0,0 +1,18 @@
+import type { DataLayer, RequestRow } from './data';
+import type { AppHost, Screen } from './app';
+export interface RequestsState {
+    rows: RequestRow[];
+    sel: number;
+    filter: string;
+    filtering: boolean;
+    loading: boolean;
+    exhausted: boolean;
+    now: number;
+}
+export declare function filterRows(rows: RequestRow[], filter: string): RequestRow[];
+export declare function renderRequests(st: RequestsState, width: number): string[];
+export declare function createRequestsScreen(deps: {
+    data: DataLayer;
+    host: AppHost;
+    openTranscript(r: RequestRow): void;
+}): Screen;

package/dist/tui/requests.js

@@ -0,0 +1,127 @@
+"use strict";
+// Full request history for this node: cursor-paged, filterable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterRows = filterRows;
+exports.renderRequests = renderRequests;
+exports.createRequestsScreen = createRequestsScreen;
+const render_1 = require("./render");
+const dashboard_1 = require("./dashboard");
+const PAGE = 50;
+function filterRows(rows, filter) {
+    const f = filter.trim().toLowerCase();
+    if (!f)
+        return rows;
+    return rows.filter(r => (r.entity_name ?? '').toLowerCase().includes(f) ||
+        (r.status ?? '').toLowerCase().includes(f) ||
+        (r.agent ?? '').toLowerCase().includes(f) ||
+        (r.error_code ?? '').toLowerCase().includes(f));
+}
+function renderRequests(st, width) {
+    const shown = filterRows(st.rows, st.filter);
+    const out = [];
+    out.push(`  ${(0, render_1.bold)('ALL REQUESTS')}  ${(0, render_1.dim)(`${shown.length} shown`)}`);
+    out.push('');
+    if (shown.length === 0) {
+        out.push((0, render_1.dim)(st.filter ? '  no requests match that filter' : '  no requests yet'));
+    }
+    else {
+        shown.forEach((r, i) => out.push((0, dashboard_1.requestLine)(r, st.now, i === st.sel, width)));
+    }
+    out.push('');
+    if (st.loading)
+        out.push((0, render_1.dim)('  loading more…'));
+    else if (st.exhausted)
+        out.push((0, render_1.dim)('  end of history'));
+    else
+        out.push((0, render_1.dim)('  ↓ at the bottom loads more'));
+    out.push(st.filtering
+        ? `  ${(0, render_1.cyan)('/')}${st.filter}${(0, render_1.cyan)('▏')}`
+        : (0, render_1.dim)('  ↑↓ move   ⏎ transcript   / filter   q back'));
+    return out.map(l => (0, render_1.truncate)(l, width));
+}
+function createRequestsScreen(deps) {
+    const st = {
+        rows: [], sel: 0, filter: '', filtering: false,
+        loading: false, exhausted: false, now: Date.now(),
+    };
+    async function loadMore() {
+        if (st.loading || st.exhausted)
+            return;
+        st.loading = true;
+        deps.host.redraw();
+        try {
+            const before = st.rows.length ? st.rows[st.rows.length - 1].created_at : null;
+            const page = await deps.data.requests({ limit: PAGE, before });
+            if (page.length < PAGE)
+                st.exhausted = true;
+            // The cursor is exclusive (created_at < before), but identical
+            // timestamps are possible — drop any id we already hold.
+            const seen = new Set(st.rows.map(r => r.id));
+            st.rows = [...st.rows, ...page.filter(r => !seen.has(r.id))];
+            st.now = Date.now();
+        }
+        finally {
+            st.loading = false;
+            deps.host.redraw();
+        }
+    }
+    return {
+        id: 'requests',
+        title: 'All requests',
+        render: (width) => renderRequests(st, width),
+        pollMs: () => 5000,
+        capturesKeys: () => st.filtering,
+        async poll() {
+            st.now = Date.now();
+            if (st.rows.length === 0)
+                await loadMore();
+            deps.host.redraw();
+        },
+        async onKey(key) {
+            if (st.filtering) {
+                if (key.name === 'return' || key.name === 'escape') {
+                    st.filtering = false;
+                    deps.host.redraw();
+                    return;
+                }
+                if (key.name === 'backspace') {
+                    st.filter = st.filter.slice(0, -1);
+                    deps.host.redraw();
+                    return;
+                }
+                // `sequence` carries the literal character; `name` is absent for
+                // punctuation and uppercase letters arrive shifted.
+                const ch = key.sequence ?? key.name ?? '';
+                if (ch.length === 1 && ch >= ' ') {
+                    st.filter += ch;
+                    deps.host.redraw();
+                }
+                return;
+            }
+            const shown = filterRows(st.rows, st.filter);
+            if (key.name === 'up' || key.name === 'k') {
+                st.sel = Math.max(0, st.sel - 1);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                st.sel = Math.min(Math.max(0, shown.length - 1), st.sel + 1);
+                if (st.sel >= shown.length - 1)
+                    await loadMore();
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === '/' || key.sequence === '/') {
+                st.filtering = true;
+                st.filter = '';
+                st.sel = 0;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'return' && shown[st.sel]) {
+                deps.openTranscript(shown[st.sel]);
+                return;
+            }
+        },
+    };
+}

package/dist/tui/run.d.ts

@@ -0,0 +1,13 @@
+import { FEED_ROWS } from './dashboard';
+export declare function shouldRenderTui(env: {
+    isTTY: boolean;
+    stdinTTY: boolean;
+    noTui: boolean;
+}): boolean;
+export declare function runDashboard(opts: {
+    viewerMode: boolean;
+    pid: number | null;
+    startedAt: number | null;
+    version: string;
+}): Promise<void>;
+export { FEED_ROWS };