@addai/node 0.4.0 → 0.5.1

package/dist/tui/harnesses.js

@@ -1,13 +1,16 @@
 "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.
+// Which agent CLIs this box has, and who they are logged in as.
 //
-// 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.
+// This used to be a second, parallel TUI with its own ANSI helpers, its own
+// panel, its own key loop and its own alt screen; entering it from the
+// dashboard suspended the whole app and the two fought over the terminal.
+// It is now a screen on the stack like any other, so it inherits the diff
+// painter, the footer grammar and the `?` help for free.
+//
+// One thing genuinely does need the raw terminal: a harness login runs the
+// vendor's own CLI flow, which draws its own prompts. That still leaves the
+// alt screen and hands the TTY over — but as a scoped suspend, not as a
+// parallel application.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -42,48 +45,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runHarnessesTui = runHarnessesTui;
+exports.actionFor = actionFor;
+exports.formatVersion = formatVersion;
+exports.accountLabel = accountLabel;
+exports.harnessColumns = harnessColumns;
+exports.harnessRow = harnessRow;
+exports.renderHarnesses = renderHarnesses;
+exports.logoutSelected = logoutSelected;
+exports.createHarnessesScreen = createHarnessesScreen;
+exports.plainStatus = plainStatus;
 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 capabilities_1 = require("../capabilities");
+const win_1 = require("../win");
 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');
-}
+const app_1 = require("./app");
 function dot(p) {
     if (!p?.available)
-        return grey('⏺');
-    return p.authed ? green('⏺') : yellow('⏺');
+        return (0, render_1.grey)('⏺');
+    return p.authed ? (0, render_1.green)('⏺') : (0, render_1.yellow)('⏺');
 }
 function actionFor(id, p) {
     if (!p?.available)
@@ -92,49 +75,105 @@ function actionFor(id, p) {
         return 'log in';
     return harness_registry_1.HARNESSES[id].logout ? 'log out' : 'ok';
 }
-function row(id, p, selected) {
+/**
+ * Harness CLIs report their version in whatever shape they feel like:
+ * `2.1.220 (Claude Code)`, `codex-cli 0.139.0`, `0.52.0`. Prefixing all of
+ * those with a `v` produced `vcodex-cli 0.139.0`. Pull out the version
+ * itself and leave the branding to the label column.
+ */
+function formatVersion(v) {
+    if (!v)
+        return '—';
+    const m = v.match(/\d+\.\d+(\.\d+)?\S*/);
+    return m ? `v${m[0]}` : v;
+}
+function accountLabel(p) {
+    if (!p?.available)
+        return 'Not installed';
+    if (!p.authed)
+        return 'Not logged in';
+    const who = p.account ?? p.accountKind ?? 'Logged in';
+    return p.plan ? `${who} · ${p.plan}` : who;
+}
+/**
+ * Column widths.
+ *
+ * The account and the effort ladder vary most, so they take the spare width;
+ * version and action are fixed at what their values actually need. The old
+ * fixed widths cut `codex-cli` down to `vcodex-cli` and
+ * `low/medium/high/xhigh` to `low/medium/high/x`.
+ */
+function harnessColumns(width) {
+    // dot, name, version, account, models, efforts, action
+    return (0, render_1.layoutColumns)([
+        { min: 1 },
+        { min: 12 },
+        { min: 9, grow: 1 },
+        { min: 16, grow: 2 },
+        { min: 8 },
+        // claude's ladder is low/medium/high/xhigh/max — 25 columns of it.
+        { min: 14, grow: 3 },
+        { min: 14 },
+    ], Math.max(40, width - 4));
+}
+function harnessRow(id, p, selected, width) {
     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 w = harnessColumns(width);
     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}`;
+    // The verb is Title Case in the row the same way every other label is; the
+    // value actionFor returns stays lowercase because the key handler reads it.
+    const verb = act.charAt(0).toUpperCase() + act.slice(1);
+    const action = act === 'ok' ? (0, render_1.green)('✓ Ready') : act === 'log out' ? (0, render_1.dim)(`⏎ ${verb}`) : (0, render_1.cyan)(`⏎ ${verb}`);
+    const line = (0, render_1.tableRow)([
+        dot(p),
+        selected ? (0, render_1.bold)(spec.label) : spec.label,
+        (0, render_1.dim)(formatVersion(p?.version)),
+        accountLabel(p),
+        (0, render_1.dim)(`${p?.models?.length ?? 0} models`),
+        (0, render_1.dim)(spec.efforts.length ? spec.efforts.join('/') : '—'),
+        action,
+    ], w);
+    return selected ? `${(0, render_1.cyan)('❯')} ${line}` : `  ${line}`;
 }
-function render(st) {
-    home();
-    const lines = [];
+function renderHarnesses(st, width, height) {
+    const out = [];
+    const authed = st.caps ? harness_registry_1.HARNESS_IDS.filter(id => st.caps?.[id]?.authed).length : 0;
+    out.push((0, app_1.heading)('Harnesses', st.caps ? `${authed}/${harness_registry_1.HARNESS_IDS.length} ready` : 'Probing…'));
+    out.push('');
     if (!st.caps) {
-        lines.push(`${cyan(SPIN[st.spin % SPIN.length])} probing installed harnesses…`);
+        out.push(`  ${(0, render_1.cyan)(render_1.SPIN[st.spin % render_1.SPIN.length])} ${(0, render_1.dim)('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)));
+        const w = harnessColumns(width);
+        out.push((0, render_1.dim)('  ' + (0, render_1.tableRow)(['', 'Harness', 'Version', 'Account', 'Models', 'Efforts', ''], w)));
+        harness_registry_1.HARNESS_IDS.forEach((id, i) => out.push(harnessRow(id, st.caps?.[id], i === st.sel, width)));
     }
     if (st.busy)
-        lines.push('', `${cyan(SPIN[st.spin % SPIN.length])} ${st.busy}`);
+        out.push('', `  ${(0, render_1.cyan)(render_1.SPIN[st.spin % render_1.SPIN.length])} ${st.busy}`);
     if (st.log.length) {
-        lines.push('');
-        st.log.slice(-8).forEach(l => lines.push(dim(l.slice(0, width() - 8))));
+        out.push('');
+        // Whatever room is left after the chrome, so an install's output fills
+        // the screen rather than a fixed eight lines.
+        const room = Math.max(3, height - out.length - 3);
+        st.log.slice(-room).forEach(l => out.push((0, render_1.dim)(`    ${l}`)));
     }
     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'));
+        out.push('', `  ${st.note}`);
+    while (out.length < height - 1)
+        out.push('');
+    out.push((0, app_1.footerHint)([
+        { keys: '↑↓', label: 'move' },
+        { keys: '⏎', label: 'install / log in / log out' },
+        { keys: 'r', label: 'refresh' },
+        { keys: 'q', label: 'back' },
+    ]));
+    return out.map(l => (0, render_1.truncate)(l, width)).slice(0, height);
 }
 /* ── 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}`);
+        st.note = (0, render_1.yellow)(`${spec.label}: ${spec.login.instructions}`);
         return;
     }
     st.busy = `installing ${spec.label} (npm i -g ${spec.npmPackage})`;
@@ -151,10 +190,10 @@ async function installSelected(st, id, redraw) {
         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}`);
+            st.note = code === 0 ? (0, render_1.green)(`✓ ${spec.label} installed`) : (0, render_1.red)(`✗ npm exited ${code}`);
             resolve();
         });
-        child.on('error', err => { st.busy = null; st.note = fg(203, `✗ ${err.message}`); resolve(); });
+        child.on('error', err => { st.busy = null; st.note = (0, render_1.red)(`✗ ${err.message}`); resolve(); });
     });
 }
 function logoutSelected(id) {
@@ -186,93 +225,70 @@ function logoutSelected(id) {
     }
     return null;
 }
+/** Runs with the real terminal handed over — see `suspend` below. */
 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');
+    console.log((0, render_1.cyan)(`\n— ${spec.label} login —`));
+    console.log((0, render_1.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);
+/* ── screen ──────────────────────────────────────────────────────────── */
+function createHarnessesScreen(deps) {
+    const st = {
+        caps: null, sel: 0, spin: 0, busy: null, confirmLogout: null, log: [], note: null,
     };
+    const probe = deps.probe ?? (() => (0, capabilities_1.probeCapabilities)());
+    const redraw = () => deps.host.redraw();
+    let acting = false;
     const reprobe = async () => {
         st.caps = null;
         redraw();
-        st.caps = await (0, capabilities_1.probeCapabilities)();
+        st.caps = await probe();
         redraw();
     };
-    let acting = false;
-    function onKeypress(_str, key) {
-        void (async () => {
-            if (!key || acting)
+    return {
+        id: 'harnesses',
+        title: 'Harnesses',
+        render: (width, height) => renderHarnesses(st, width, height),
+        // Probing spawns five CLIs; do it on open and then only on request.
+        pollMs: () => 120_000,
+        poll: reprobe,
+        tick(n) {
+            st.spin = n;
+            // The only moving parts are the probe and install spinners.
+            return st.busy !== null || st.caps === null;
+        },
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'move between harnesses' },
+            { keys: '⏎', label: 'install, log in, or arm a log out' },
+            { keys: 'y', label: 'confirm a log out' },
+            { keys: 'r', label: 'probe again' },
+        ],
+        async onKey(key) {
+            if (acting || !key)
                 return;
-            if (key.ctrl && key.name === 'c') {
-                quit(true);
+            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 === 'q') {
-                quit(false);
+            if (key.name === 'down' || key.name === 'j') {
+                st.sel = (st.sel + 1) % harness_registry_1.HARNESS_IDS.length;
+                redraw();
                 return;
             }
             if (!st.caps)
                 return;
+            if (key.name === 'r') {
+                await reprobe();
+                return;
+            }
             if (st.confirmLogout) {
                 const target = st.confirmLogout;
                 st.confirmLogout = null;
@@ -280,7 +296,7 @@ async function runHarnessesTui(opts = {}) {
                     acting = true;
                     try {
                         const err = logoutSelected(target);
-                        st.note = err ? fg(203, `✗ ${err}`) : green(`✓ ${harness_registry_1.HARNESSES[target].label} logged out`);
+                        st.note = err ? (0, render_1.red)(`✗ ${err}`) : (0, render_1.green)(`✓ ${harness_registry_1.HARNESSES[target].label} logged out`);
                         await reprobe();
                     }
                     finally {
@@ -288,25 +304,11 @@ async function runHarnessesTui(opts = {}) {
                     }
                 }
                 else {
-                    st.note = dim('logout cancelled');
+                    st.note = (0, render_1.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];
@@ -316,39 +318,45 @@ async function runHarnessesTui(opts = {}) {
                 if (!p?.available) {
                     await installSelected(st, id, redraw);
                     await reprobe();
+                    return;
                 }
-                else if (!p.authed) {
-                    const err = loginSelected(id);
-                    st.note = err ? fg(203, `✗ ${err}`) : green('✓ login flow finished — verifying…');
+                if (!p.authed) {
+                    let err = null;
+                    // The vendor CLI draws its own prompts, so it needs the real
+                    // terminal — and it must have it back before we repaint.
+                    await deps.suspend(() => { err = loginSelected(id); });
+                    st.note = err ? (0, render_1.red)(`✗ ${err}`) : (0, render_1.green)('✓ login flow finished — verifying…');
+                    redraw();
                     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 ?? '?'}`);
+                        st.note = (0, render_1.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`);
+                        st.note = (0, render_1.yellow)(`${harness_registry_1.HARNESSES[id].label} still reports unauthenticated`);
                     redraw();
+                    return;
                 }
-                else if (harness_registry_1.HARNESSES[id].logout) {
+                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.`);
+                    st.note = (0, render_1.yellow)(`log out of ${harness_registry_1.HARNESSES[id].label}? press y to confirm`);
                     redraw();
+                    return;
                 }
+                st.note = (0, render_1.green)(`${harness_registry_1.HARNESSES[id].label} is installed and logged in.`);
+                redraw();
             }
             finally {
                 acting = false;
             }
-        })();
+        },
+    };
+}
+/** `ainode harnesses` on a pipe: no screen, just the facts. */
+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}`);
     }
-    // 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/logs.d.ts

@@ -0,0 +1,18 @@
+import { type AppHost, type Screen } from './app';
+import type { CapturedLog, ConsoleCapture } from './console-capture';
+export interface LogsState {
+    scroll: number;
+    follow: boolean;
+    filter: string;
+    filtering: boolean;
+    viewportRows: number;
+}
+export declare function logLine(l: CapturedLog, width: number): string;
+export declare function filterLogs(lines: CapturedLog[], filter: string): CapturedLog[];
+export declare function renderLogs(st: LogsState, lines: CapturedLog[], width: number, height: number, emptyHint?: string): string[];
+export declare function createLogsScreen(deps: {
+    host: AppHost;
+    logs: ConsoleCapture;
+    /** Shown instead of "nothing yet" when this process isn't the daemon. */
+    emptyHint?: string;
+}): Screen;

package/dist/tui/logs.js

@@ -0,0 +1,157 @@
+"use strict";
+// What the daemon is saying.
+//
+// The console UI has to take stdout away from the daemon to paint at all, so
+// without this screen the pump's own account of itself — backoffs, wake
+// detection, session chatter — is invisible for as long as the UI is open.
+// Here it is, tailing live, with the same scrollback grammar as the
+// transcript screen.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLine = logLine;
+exports.filterLogs = filterLogs;
+exports.renderLogs = renderLogs;
+exports.createLogsScreen = createLogsScreen;
+const render_1 = require("./render");
+const app_1 = require("./app");
+/** Lines the screen spends on things that are not log lines. */
+const CHROME = 4;
+function stamp(at) {
+    const d = new Date(at);
+    const p = (n) => String(n).padStart(2, '0');
+    return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+function logLine(l, width) {
+    const colour = l.level === 'error' ? render_1.red : l.level === 'warn' ? render_1.yellow : render_1.dim;
+    const text = l.text.replace(/\s+/g, ' ');
+    const prefix = `  ${(0, render_1.grey)(stamp(l.at))} `;
+    return (0, render_1.truncate)(prefix + colour(text), width);
+}
+function filterLogs(lines, filter) {
+    const f = filter.trim().toLowerCase();
+    if (!f)
+        return lines;
+    return lines.filter(l => l.text.toLowerCase().includes(f));
+}
+function renderLogs(st, lines, width, height, emptyHint) {
+    const shown = filterLogs(lines, st.filter);
+    const rows = Math.max(1, height - CHROME);
+    st.viewportRows = rows;
+    const out = [];
+    const scope = st.filter
+        ? `${shown.length} matching “${st.filter}”`
+        : `${shown.length} lines this session`;
+    out.push((0, app_1.heading)('Logs', scope));
+    out.push('');
+    if (shown.length === 0) {
+        if (st.filter)
+            out.push((0, render_1.dim)('  Nothing matches that filter'));
+        else
+            out.push((0, render_1.dim)(`  ${emptyHint ?? 'The daemon has said nothing yet'}`));
+    }
+    else {
+        const maxScroll = Math.max(0, shown.length - rows);
+        const start = st.follow ? maxScroll : Math.min(st.scroll, maxScroll);
+        st.scroll = start;
+        shown.slice(start, start + rows).forEach(l => out.push(logLine(l, width)));
+    }
+    while (out.length < height - 1)
+        out.push('');
+    const tail = st.follow ? `  ${(0, render_1.dim)('tailing')}` : '';
+    out.push(st.filtering
+        ? `  /${st.filter}▏`
+        : (0, app_1.footerHint)([
+            { keys: '↑↓ PgUp PgDn', label: 'scroll' },
+            { keys: 'G', label: 'tail' },
+            { keys: '/', label: 'filter' },
+            { keys: 'q', label: 'back' },
+        ]) + tail);
+    return out.map(l => (0, render_1.truncate)(l, width)).slice(0, height);
+}
+function createLogsScreen(deps) {
+    const st = { scroll: 0, follow: true, filter: '', filtering: false, viewportRows: 20 };
+    return {
+        id: 'logs',
+        title: 'Logs',
+        render: (width, height) => renderLogs(st, deps.logs.lines(), width, height, deps.emptyHint),
+        // Nothing to fetch — new lines arrive by callback. The poll only exists
+        // so a tailing view repaints while the daemon talks.
+        pollMs: () => 1000,
+        capturesKeys: () => st.filtering,
+        async poll() { if (st.follow)
+            deps.host.redraw(); },
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'scroll a line — stops tailing' },
+            { keys: 'PgUp/PgDn', label: 'scroll a screenful' },
+            { keys: 'g / G', label: 'first line / tail the newest' },
+            { keys: '/', label: 'filter lines by text' },
+        ],
+        onKey(key) {
+            if (st.filtering) {
+                if (key.name === 'return') {
+                    st.filtering = false;
+                    deps.host.redraw();
+                    return;
+                }
+                if (key.name === 'escape') {
+                    st.filtering = false;
+                    st.filter = '';
+                    deps.host.redraw();
+                    return;
+                }
+                if (key.name === 'backspace') {
+                    st.filter = st.filter.slice(0, -1);
+                    deps.host.redraw();
+                    return;
+                }
+                const ch = key.sequence ?? key.name ?? '';
+                if (ch.length === 1 && ch >= ' ') {
+                    st.filter += ch;
+                    deps.host.redraw();
+                }
+                return;
+            }
+            const page = Math.max(1, st.viewportRows - 1);
+            if (key.name === 'up' || key.name === 'k') {
+                st.follow = false;
+                st.scroll = Math.max(0, st.scroll - 1);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                st.follow = false;
+                st.scroll += 1;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'pageup') {
+                st.follow = false;
+                st.scroll = Math.max(0, st.scroll - page);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'pagedown') {
+                st.follow = false;
+                st.scroll += page;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'g' && !key.shift) {
+                st.follow = false;
+                st.scroll = 0;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'g' && key.shift) {
+                st.follow = true;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === '/' || key.sequence === '/') {
+                st.filtering = true;
+                st.filter = '';
+                deps.host.redraw();
+                return;
+            }
+        },
+    };
+}