@addai/node 0.4.0 → 0.5.0

package/dist/tui/console-capture.js

@@ -7,20 +7,65 @@
 // every one of those lines lands in the middle of a frame, so the screen
 // appears to flicker between the UI and log output.
 //
-// Capturing rather than silencing: the lines are kept in a ring buffer, the
-// newest is surfaced in the UI, and the whole buffer is replayed to the real
-// stdout on exit, so running the daemon under the dashboard loses nothing
-// you would have seen without it.
+// Capturing rather than silencing: the lines are kept in a ring buffer that
+// the Logs screen reads, and appended to the daemon log file as they arrive.
+// Nothing is lost by running the daemon under the console — and because the
+// file is written live, nothing has to be dumped into your shell on the way
+// out either.
+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.captureConsole = captureConsole;
-const MAX_LINES = 500;
-function captureConsole() {
+const fs = __importStar(require("fs"));
+const MAX_LINES = 2000;
+function captureConsole(opts = {}) {
     const ring = [];
+    const listeners = [];
     const original = {
         log: console.log.bind(console),
         warn: console.warn.bind(console),
         error: console.error.bind(console),
     };
+    let sink = null;
+    if (opts.logFile) {
+        try {
+            sink = fs.openSync(opts.logFile, 'a');
+        }
+        catch {
+            sink = null;
+        }
+    }
     const format = (args) => args.map(a => {
         if (typeof a === 'string')
             return a;
@@ -34,9 +79,22 @@ function captureConsole() {
         }
     }).join(' ');
     const push = (level) => (...args) => {
-        ring.push({ level, text: format(args), at: Date.now() });
+        const line = { level, text: format(args), at: Date.now() };
+        ring.push(line);
         if (ring.length > MAX_LINES)
             ring.shift();
+        if (sink !== null) {
+            try {
+                fs.writeSync(sink, `${line.text}\n`);
+            }
+            catch { /* disk full, keep the UI alive */ }
+        }
+        for (const fn of listeners) {
+            try {
+                fn(line);
+            }
+            catch { /* a listener must never break logging */ }
+        }
     };
     console.log = push('log');
     console.warn = push('warn');
@@ -45,18 +103,18 @@ function captureConsole() {
         lines: () => [...ring],
         last: () => (ring.length ? ring[ring.length - 1] : null),
         count: () => ring.length,
-        restoreAndReplay() {
+        onLine(fn) { listeners.push(fn); },
+        restore() {
             console.log = original.log;
             console.warn = original.warn;
             console.error = original.error;
-            for (const l of ring) {
-                if (l.level === 'error')
-                    original.error(l.text);
-                else if (l.level === 'warn')
-                    original.warn(l.text);
-                else
-                    original.log(l.text);
+            if (sink !== null) {
+                try {
+                    fs.closeSync(sink);
+                }
+                catch { /* already gone */ }
             }
+            sink = null;
         },
     };
 }

package/dist/tui/dashboard.d.ts

@@ -1,9 +1,11 @@
+import { type AppHost, type Screen } from './app';
 import type { DataLayer, NodeSelf, NodeStats, RequestRow } from './data';
-import type { AppHost, Screen } from './app';
 export interface DashboardState {
     self: NodeSelf | null;
     stats: NodeStats | null;
-    requests: RequestRow[];
+    /** Recent requests, newest first — the NOW band reads the live ones off
+     *  the top and the idle line reads the most recent finish. */
+    recent: RequestRow[];
     sel: number;
     spin: number;
     pid: number | null;
@@ -14,24 +16,21 @@ export interface DashboardState {
     offline: boolean;
     now: number;
     version: string;
-    /** Newest line the daemon logged while the UI owned the screen. */
-    lastLog: string | null;
+    /** How many daemon log lines have been captured this session. */
     logCount: number;
 }
-export declare const FEED_ROWS = 12;
-/** Trigger sources are DB-shaped ('self_improve_distil'); the column is
- *  nine columns wide and "self_impr" tells you nothing. */
-export declare function shortVia(via: string | null | undefined): string;
-export declare function requestLine(r: RequestRow, now: number, selected: boolean, width: number): string;
-/** The landing screen's menu. Activity and Harnesses are places you go,
- *  not things that crowd the overview. */
+/** The landing screen's menu. */
 export declare const MENU: Array<{
     key: string;
     label: string;
     hint: string;
     shortcut: string;
 }>;
-export declare function renderDashboard(st: DashboardState, width: number): string[];
+/** Live rows the NOW band shows before it starts counting the rest. */
+export declare const MAX_NOW_ROWS = 6;
+export declare function liveRequests(rows: RequestRow[]): RequestRow[];
+export declare function nowLines(st: DashboardState, width: number, rows: number): string[];
+export declare function renderDashboard(st: DashboardState, width: number, height: number): string[];
 export declare function createDashboardScreen(deps: {
     data: DataLayer;
     host: AppHost;
@@ -39,4 +38,5 @@ export declare function createDashboardScreen(deps: {
     openTranscript(r: RequestRow): void;
     openRequests(): void;
     openHarnesses(): void;
+    openLogs(): void;
 }): Screen;

package/dist/tui/dashboard.js

@@ -1,87 +1,29 @@
 "use strict";
-// Home screen: is this node alive, what has it been doing, what is it
-// doing right now.
+// The cockpit: is this node alive, what is it doing right now, and what has
+// it done today.
 //
-// Status vocabulary comes from the DB, where terminal success is
-// 'completed' and 'canceled' is a deliberate user action — shown apart
-// from failures so a healthy node isn't slandered by its own cancels.
+// The landing screen answers "is the box earning its keep" without a
+// keystroke. Everything that needs scrolling — history, harnesses, logs — is
+// a place you go, not something that crowds the overview.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MENU = exports.FEED_ROWS = void 0;
-exports.shortVia = shortVia;
-exports.requestLine = requestLine;
+exports.MAX_NOW_ROWS = exports.MENU = void 0;
+exports.liveRequests = liveRequests;
+exports.nowLines = nowLines;
 exports.renderDashboard = renderDashboard;
 exports.createDashboardScreen = createDashboardScreen;
 const render_1 = require("./render");
-exports.FEED_ROWS = 12;
-const ACTIVE = new Set(['pending', 'starting', 'running']);
-const CANCELLED = new Set(['canceled', 'cancelled']);
-/** Trigger sources are DB-shaped ('self_improve_distil'); the column is
- *  nine columns wide and "self_impr" tells you nothing. */
-function shortVia(via) {
-    if (!via)
-        return '—';
-    const map = {
-        self_improve_distil: 'distil',
-        self_improve: 'improve',
-        entity_chat: 'chat',
-        chat: 'chat',
-        schedule: 'schedule',
-        flow: 'flow',
-        api: 'api',
-        studio: 'studio',
-    };
-    return map[via] ?? via;
-}
-function statusLabel(status) {
-    if (status === 'completed')
-        return 'DONE';
-    if (CANCELLED.has(status))
-        return 'CANCEL';
-    return status.toUpperCase();
-}
-function statusCell(status) {
-    const label = statusLabel(status).padEnd(8).slice(0, 8);
-    if (ACTIVE.has(status))
-        return (0, render_1.cyan)(label);
-    if (status === 'completed')
-        return (0, render_1.green)(label);
-    if (CANCELLED.has(status))
-        return (0, render_1.grey)(label);
-    return (0, render_1.red)(label);
-}
-function dot(status) {
-    if (ACTIVE.has(status))
-        return (0, render_1.cyan)('⏺');
-    if (status === 'completed')
-        return (0, render_1.green)('⏺');
-    if (CANCELLED.has(status))
-        return (0, render_1.grey)('⏺');
-    return (0, render_1.red)('⏺');
-}
-function durationOf(r, now) {
-    const start = r.picked_up_at ?? r.created_at;
-    if (!start)
-        return null;
-    const end = r.finished_at ? new Date(r.finished_at).getTime() : now;
-    return Math.max(0, end - new Date(start).getTime());
-}
-function requestLine(r, now, selected, width) {
-    const entity = (0, render_1.padEndVisible)((0, render_1.truncate)(r.entity_name ?? '—', 12), 12);
-    const agent = `${r.agent}/${r.mode}`.padEnd(12).slice(0, 12);
-    const model = (r.model ?? '—').replace(/^claude-/, '').padEnd(7).slice(0, 7);
-    const via = shortVia(r.issued_via).padEnd(9).slice(0, 9);
-    const dur = (0, render_1.fmtDuration)(durationOf(r, now)).padStart(7);
-    // A run that failed once and then succeeded on retry still carries the
-    // old error_code. Showing it on a DONE row reads as "this broke" when
-    // the work actually landed — so the code is only for rows that ended badly.
-    const ended_badly = r.status !== 'completed' && !ACTIVE.has(r.status);
-    const tail = r.error_code && ended_badly
-        ? (0, render_1.red)(`[${r.error_code}]`)
-        : (r.prompt ?? '').replace(/\s+/g, ' ');
-    const prefix = `${dot(r.status)} ${statusCell(r.status)} ${entity} ${(0, render_1.dim)(agent)} ${(0, render_1.dim)(model)} ${(0, render_1.dim)(via)} ${dur}  `;
-    const room = Math.max(8, width - 2 - (0, render_1.visibleWidth)(prefix));
-    const line = `${prefix}${(0, render_1.truncate)(tail, room)}`;
-    return selected ? `${(0, render_1.cyan)('❯')} ${line}` : `  ${line}`;
+const request_row_1 = require("./request-row");
+const app_1 = require("./app");
+/** The landing screen's menu. */
+exports.MENU = [
+    { key: 'activity', label: 'Activity', hint: 'every request this node has handled', shortcut: 'a' },
+    { key: 'harnesses', label: 'Harnesses', hint: 'install / log in agent CLIs', shortcut: 'h' },
+    { key: 'logs', label: 'Logs', hint: 'what the daemon is saying', shortcut: 'l' },
+];
+/** Live rows the NOW band shows before it starts counting the rest. */
+exports.MAX_NOW_ROWS = 6;
+function liveRequests(rows) {
+    return rows.filter(r => request_row_1.ACTIVE.has(r.status));
 }
 function headerLines(st) {
     if (!st.paired) {
@@ -121,56 +63,110 @@ function statsLines(st) {
         (0, render_1.dim)(`Week ${s.week}   Month ${s.month}   Total ${s.total}`),
     ];
 }
-/** The landing screen's menu. Activity and Harnesses are places you go,
- *  not things that crowd the overview. */
-exports.MENU = [
-    { key: 'activity', label: 'Activity', hint: 'requests this node has handled', shortcut: 'a' },
-    { key: 'harnesses', label: 'Harnesses', hint: 'install / log in agent CLIs', shortcut: 'h' },
-];
-function renderDashboard(st, width) {
-    const out = [];
-    out.push(...(0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`ainode v${st.version}`)}`, headerLines(st), width));
-    out.push('');
-    if (st.paired) {
-        out.push(...statsLines(st).map(l => `  ${l}`));
-        out.push('');
-        exports.MENU.forEach((m, i) => {
-            const selected = i === st.sel;
-            const label = selected ? (0, render_1.bold)(m.label.padEnd(12)) : m.label.padEnd(12);
-            const marker = selected ? (0, render_1.cyan)('❯') : ' ';
-            out.push(`${marker} ${label} ${(0, render_1.dim)(m.hint)}   ${(0, render_1.dim)(m.shortcut)}`);
-        });
+/** The most recent request that actually finished, for the idle line. */
+function lastFinished(rows) {
+    return rows.find(r => r.finished_at) ?? null;
+}
+function nowLines(st, width, rows) {
+    const live = liveRequests(st.recent);
+    const out = [`  ${(0, render_1.bold)('NOW')}`];
+    if (live.length === 0) {
+        const last = lastFinished(st.recent);
+        out.push(last
+            ? (0, render_1.dim)(`  idle — last run finished ${(0, render_1.fmtRelative)(last.finished_at, st.now)}`)
+            : (0, render_1.dim)('  idle'));
+        return out;
     }
-    out.push('');
-    if (st.lastLog) {
-        out.push((0, render_1.dim)(`  log  ${st.lastLog}`));
-        if (st.logCount > 1)
-            out.push((0, render_1.dim)(`       ${st.logCount} lines captured — printed on exit`));
+    out.push((0, request_row_1.requestHeader)(width));
+    const shown = live.slice(0, Math.max(1, rows));
+    shown.forEach(r => out.push((0, request_row_1.requestLine)(r, st.now, false, width, st.spin)));
+    if (live.length > shown.length) {
+        out.push((0, render_1.dim)(`     +${live.length - shown.length} more running`));
+    }
+    return out;
+}
+function renderDashboard(st, width, height) {
+    const head = (0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`ainode v${st.version}`)}`, headerLines(st), width);
+    if (!st.paired) {
+        return [...head, '', (0, app_1.footerHint)([{ keys: 'q', label: 'quit' }])].slice(0, height);
     }
-    out.push('');
-    out.push((0, render_1.dim)('  ↑↓ move   ⏎ open   r refresh   q quit'));
-    return out.map(l => (0, render_1.truncate)(l, width));
+    const stats = statsLines(st).map(l => `  ${l}`);
+    // The shortcut letters line up in a column of their own, so the eye can
+    // find them without reading the hints.
+    const hintWidth = Math.max(...exports.MENU.map(m => m.hint.length)) + 2;
+    const menu = exports.MENU.map((m, i) => {
+        const selected = i === st.sel;
+        const label = selected ? (0, render_1.bold)(m.label.padEnd(11)) : m.label.padEnd(11);
+        const cursor = selected ? (0, render_1.cyan)('❯') : ' ';
+        const badge = m.key === 'logs' && st.logCount ? `${st.logCount} lines` : '';
+        return `${cursor} ${label} ${(0, render_1.dim)(m.hint.padEnd(hintWidth))}${(0, render_1.dim)(badge.padEnd(10))}${(0, render_1.dim)(m.shortcut)}`;
+    });
+    const foot = (0, app_1.footerHint)([
+        { keys: '↑↓', label: 'move' },
+        { keys: '⏎', label: 'open' },
+        { keys: 'r', label: 'refresh' },
+        { keys: '?', label: 'keys' },
+        { keys: 'q', label: 'quit' },
+    ]);
+    // Everything but the NOW band is fixed height, so the band takes what is
+    // left: heading + header row + rows + the "+N more" line.
+    const fixed = head.length + 1 + stats.length + 1 + 3 + 1 + menu.length + 1 + 1;
+    const room = Math.min(exports.MAX_NOW_ROWS, Math.max(1, height - fixed));
+    return [
+        ...head,
+        '',
+        ...stats,
+        '',
+        ...nowLines(st, width, room),
+        '',
+        ...menu,
+        '',
+        foot,
+    ].map(l => (0, render_1.truncate)(l, width)).slice(0, height);
 }
 function createDashboardScreen(deps) {
     const st = deps.state;
-    // The landing screen shows identity and numbers only, so it fetches two
-    // rows of counters — not the request feed. Activity pages that in itself.
     const refresh = async () => {
         st.now = Date.now();
-        const [self, stats] = await Promise.all([deps.data.self(), deps.data.stats()]);
+        const [self, stats, recent] = await Promise.all([
+            deps.data.self(),
+            deps.data.stats(),
+            // Enough rows to hold every plausible concurrent run plus something
+            // finished for the idle line, and small enough to poll every 2s.
+            deps.data.requests({ limit: 20 }),
+        ]);
         if (self)
             st.self = self;
         if (stats)
             st.stats = stats;
+        if (recent.length)
+            st.recent = recent;
         st.offline = deps.data.offline();
         deps.host.redraw();
     };
     return {
         id: 'dashboard',
         title: '+Ai Node',
-        render: (width) => renderDashboard(st, width),
-        pollMs: () => (st.stats && st.stats.active > 0 ? 2000 : 5000),
+        render: (width, height) => renderDashboard(st, width, height),
+        // Poll hard while something is moving; an idle node doesn't need traffic.
+        pollMs: () => (liveRequests(st.recent).length > 0 || st.inflight > 0 ? 2000 : 5000),
         poll: refresh,
+        tick(n) {
+            st.spin = n;
+            // Only the NOW band animates, and only when something is in it.
+            if (liveRequests(st.recent).length === 0)
+                return false;
+            st.now = Date.now();
+            return true;
+        },
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'move between destinations' },
+            { keys: '⏎', label: 'open the selected destination' },
+            { keys: 'a', label: 'activity — full request history' },
+            { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
+            { keys: 'l', label: 'logs — daemon output' },
+            { keys: 'r', label: 'refresh now' },
+        ],
         async onKey(key) {
             if (key.name === 'up' || key.name === 'k') {
                 st.sel = Math.max(0, st.sel - 1);
@@ -190,13 +186,20 @@ function createDashboardScreen(deps) {
                 deps.openHarnesses();
                 return;
             }
+            if (key.name === 'l') {
+                deps.openLogs();
+                return;
+            }
             if (key.name === 'r') {
                 await refresh();
                 return;
             }
             if (key.name === 'return') {
-                if (exports.MENU[st.sel]?.key === 'harnesses')
+                const target = exports.MENU[st.sel]?.key;
+                if (target === 'harnesses')
                     deps.openHarnesses();
+                else if (target === 'logs')
+                    deps.openLogs();
                 else
                     deps.openRequests();
             }

package/dist/tui/harnesses.d.ts

@@ -1,16 +1,53 @@
+import { type HarnessId } from '../harness-registry';
+import { type AppHost, type Screen } from './app';
+export type Probe = {
+    available?: boolean;
+    authed?: boolean;
+    version?: string;
+    account?: string;
+    plan?: string;
+    accountKind?: string;
+    models?: string[];
+};
+export type Caps = Record<string, Probe>;
+export interface HarnessesState {
+    caps: Caps | null;
+    sel: number;
+    spin: number;
+    /** Spinner label while an action runs; null when idle. */
+    busy: string | null;
+    /** Enter on an authed row arms this; y fires it. */
+    confirmLogout: HarnessId | null;
+    /** Tail of an install's npm output. */
+    log: string[];
+    note: string | null;
+}
+export declare function actionFor(id: HarnessId, p: Probe | undefined): string;
 /**
- * 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.
+ * 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.
+ */
+export declare function formatVersion(v: string | undefined): string;
+export declare function accountLabel(p: Probe | undefined): string;
+/**
+ * Column widths.
  *
- * `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.
+ * 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`.
  */
-export declare function runHarnessesTui(opts?: {
-    embedded?: boolean;
-}): Promise<void>;
+export declare function harnessColumns(width: number): number[];
+export declare function harnessRow(id: HarnessId, p: Probe | undefined, selected: boolean, width: number): string;
+export declare function renderHarnesses(st: HarnessesState, width: number, height: number): string[];
+export declare function logoutSelected(id: HarnessId): string | null;
+export declare function createHarnessesScreen(deps: {
+    host: AppHost;
+    /** Hand the raw terminal to a vendor CLI, then take it back. */
+    suspend(fn: () => void | Promise<void>): Promise<void>;
+    probe?: () => Promise<Caps>;
+}): Screen;
+/** `ainode harnesses` on a pipe: no screen, just the facts. */
+export declare function plainStatus(): Promise<void>;