@addai/node 0.4.0 → 0.5.1

package/dist/tui/run.js

@@ -2,7 +2,8 @@
 // Terminal wiring for the console UI: raw-mode keys in, frames out.
 //
 // Everything decision-shaped lives in app.ts and the screens; this file
-// owns only the things that need a real TTY.
+// owns only the things that need a real TTY — and it owns them once, for
+// every screen, so no screen has to run a terminal of its own.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -37,77 +38,54 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FEED_ROWS = void 0;
 exports.shouldRenderTui = shouldRenderTui;
 exports.runDashboard = runDashboard;
+exports.runHarnessesTui = runHarnessesTui;
 const readline = __importStar(require("readline"));
 const app_1 = require("./app");
 const data_1 = require("./data");
 const dashboard_1 = require("./dashboard");
-Object.defineProperty(exports, "FEED_ROWS", { enumerable: true, get: function () { return dashboard_1.FEED_ROWS; } });
 const requests_1 = require("./requests");
 const transcript_1 = require("./transcript");
 const harnesses_1 = require("./harnesses");
+const logs_1 = require("./logs");
 const render_1 = require("./render");
 const console_capture_1 = require("./console-capture");
 const store_1 = require("../store");
 const request_pump_1 = require("../request-pump");
+const paths_1 = require("../paths");
 function shouldRenderTui(env) {
     return env.isTTY && env.stdinTTY && !env.noTui;
 }
-async function runDashboard(opts) {
-    const pairing = (0, store_1.readPairing)();
-    const data = (0, data_1.createDataLayer)({ token: pairing?.daemonToken ?? '' });
-    // In daemon mode the pump is running in THIS process and logs straight to
-    // the stdout we are painting on. Capture it for as long as we own the
-    // screen — including while the harness screen is up — and replay on exit.
-    const logs = (0, console_capture_1.captureConsole)();
-    const state = {
-        self: null, stats: null, requests: [], sel: 0, spin: 0,
-        pid: opts.pid, startedAt: opts.startedAt,
-        inflight: 0, paired: (0, store_1.isPaired)(), viewerMode: opts.viewerMode,
-        offline: false, now: Date.now(), version: opts.version,
-        lastLog: null, logCount: 0,
-    };
+/** How often the poll scheduler looks for work. Screens set their own rate. */
+const TICK_MS = 250;
+/** Spinner cadence. Cheap now that frames are painted as a diff. */
+const SPIN_MS = 120;
+/**
+ * Own the terminal on behalf of a screen stack.
+ *
+ * `build` gets the host so it can wire navigation, and the suspend hook so a
+ * screen can hand the TTY to a vendor CLI. It returns the root screen.
+ */
+function createConsole(build, hooks = {}) {
+    const painter = (0, render_1.createPainter)(s => process.stdout.write(s));
     let quitting = false;
     let inputAttached = false;
-    // While the harness screen owns the terminal, this one must go completely
-    // silent. Its poll and spin timers keep firing otherwise and repaint the
-    // dashboard straight over the harness panel — the screens flicker against
-    // each other and the harness rows never survive a frame.
+    // Building the root screen redraws, and that happens before run() has
+    // opened the alt screen. Painting then would scribble a frame onto the
+    // user's real terminal — and worse, leave the painter believing that
+    // frame is already on screen, so the first alt-screen paint would be a
+    // no-op diff against a screen that is actually blank.
+    let started = false;
+    // While a child process owns the terminal, this app must go completely
+    // silent: its timers keep firing otherwise and repaint straight over the
+    // child's output.
     let suspended = false;
     const app = (0, app_1.createApp)({ id: 'boot', title: '+Ai Node', render: () => [] }, { onQuit: () => teardown(), onRedraw: () => draw() });
-    const openTranscript = (r) => app.push((0, transcript_1.createTranscriptScreen)({ data, host: app, request: r }));
-    app.replace((0, dashboard_1.createDashboardScreen)({
-        data, host: app, state,
-        openTranscript,
-        openRequests: () => app.push((0, requests_1.createRequestsScreen)({ data, host: app, openTranscript })),
-        openHarnesses: () => { void openHarnesses(); },
-    }));
-    // The harness screen owns the whole terminal (it hands the TTY to CLIs
-    // for login), so we detach entirely and rebuild our input when it exits.
-    async function openHarnesses() {
-        suspended = true;
-        detachInput();
-        (0, render_1.altOff)();
-        try {
-            await (0, harnesses_1.runHarnessesTui)({ embedded: true });
-        }
-        finally {
-            suspended = false;
-            (0, render_1.altOn)();
-            attachInput();
-            draw();
-        }
-    }
     function draw() {
-        if (quitting || suspended)
+        if (!started || quitting || suspended)
             return;
-        const latest = logs.last();
-        state.lastLog = latest ? latest.text.replace(/\s+/g, ' ') : null;
-        state.logCount = logs.count();
-        (0, render_1.home)();
-        process.stdout.write(app.frame((0, render_1.termWidth)()).join('\n') + '\n');
+        painter.paint(app.frame((0, render_1.termWidth)(), (0, render_1.termHeight)()));
     }
     function onKeypress(_s, key) {
         void app.handleKey(key);
@@ -131,48 +109,131 @@ async function runDashboard(opts) {
         process.stdin.pause();
         inputAttached = false;
     }
+    let pollTimer = null;
+    let spinTimer = null;
     function teardown() {
         if (quitting)
             return;
         quitting = true;
-        clearInterval(pollTimer);
-        clearInterval(spinTimer);
+        if (pollTimer)
+            clearInterval(pollTimer);
+        if (spinTimer)
+            clearInterval(spinTimer);
         detachInput();
         (0, render_1.altOff)();
-        // Give the operator back everything the daemon said while the UI had
-        // the screen — otherwise running under the dashboard swallows the log.
-        logs.restoreAndReplay();
+        hooks.onTeardown?.();
         process.exit(0);
     }
-    // Each screen declares its own cadence via pollMs(); this ticks often
-    // enough to honour the shortest one without polling on every tick.
-    let lastPoll = 0;
-    const pollTimer = setInterval(() => {
-        if (suspended)
-            return;
-        const screen = app.current();
-        const due = screen.pollMs?.() ?? 5000;
-        if (Date.now() - lastPoll < due)
-            return;
-        lastPoll = Date.now();
-        state.inflight = (0, request_pump_1.inflightCount)();
-        void screen.poll?.().catch(() => { });
-    }, 250);
-    // Redraw on a spin tick only while something is actually moving, so an
-    // idle node isn't repainting the terminal ten times a second.
-    const spinTimer = setInterval(() => {
-        if (suspended)
-            return;
-        state.spin++;
-        if (state.stats?.active || state.inflight > 0)
+    const suspend = async (fn) => {
+        suspended = true;
+        detachInput();
+        (0, render_1.altOff)();
+        try {
+            await fn();
+        }
+        finally {
+            suspended = false;
+            (0, render_1.altOn)();
+            attachInput();
+            // The child scribbled all over the screen; the diff from before it ran
+            // is meaningless now.
+            painter.invalidate();
             draw();
-    }, 120);
-    // Resizing must not leave half-width panels behind.
-    process.stdout.on('resize', draw);
-    (0, render_1.altOn)();
-    attachInput();
-    state.inflight = (0, request_pump_1.inflightCount)();
-    await app.current().poll?.();
-    draw();
-    await new Promise(() => { });
+        }
+    };
+    app.replace(build(app, suspend));
+    return {
+        host: app,
+        suspend,
+        async run() {
+            // Each screen declares its own cadence and carries its own clock, so a
+            // screen that has just been opened is polled at the next tick rather
+            // than waiting out the previous screen's interval.
+            pollTimer = setInterval(() => {
+                if (suspended)
+                    return;
+                const screen = app.duePoll(Date.now());
+                if (!screen)
+                    return;
+                void screen.poll?.().catch(() => { });
+            }, TICK_MS);
+            let n = 0;
+            spinTimer = setInterval(() => {
+                if (suspended)
+                    return;
+                n++;
+                let wants = false;
+                try {
+                    wants = app.current().tick?.(n) === true;
+                }
+                catch {
+                    wants = false;
+                }
+                if (wants)
+                    draw();
+            }, SPIN_MS);
+            // Resizing must not leave half-width panels behind.
+            process.stdout.on('resize', () => { painter.invalidate(); draw(); });
+            (0, render_1.altOn)();
+            attachInput();
+            started = true;
+            painter.invalidate();
+            draw();
+            await new Promise(() => { });
+        },
+    };
+}
+async function runDashboard(opts) {
+    const pairing = (0, store_1.readPairing)();
+    const data = (0, data_1.createDataLayer)({ token: pairing?.daemonToken ?? '' });
+    // In daemon mode the pump is running in THIS process and logs straight to
+    // the stdout we are painting on. Capture it for as long as we own the
+    // screen; the Logs screen reads the buffer and every line still reaches
+    // the daemon log file, so nothing is lost by watching.
+    const logs = (0, console_capture_1.captureConsole)({ logFile: paths_1.RUNTIME_LOG_FILE });
+    const state = {
+        self: null, stats: null, recent: [], sel: 0, spin: 0,
+        pid: opts.pid, startedAt: opts.startedAt,
+        inflight: 0, paired: (0, store_1.isPaired)(), viewerMode: opts.viewerMode,
+        offline: false, now: Date.now(), version: opts.version,
+        logCount: 0,
+    };
+    const ui = createConsole((host, suspend) => {
+        const openTranscript = (r) => host.push((0, transcript_1.createTranscriptScreen)({ data, host, request: r }));
+        return (0, dashboard_1.createDashboardScreen)({
+            data, host, state,
+            openTranscript,
+            openRequests: () => host.push((0, requests_1.createRequestsScreen)({ data, host, openTranscript })),
+            openHarnesses: () => host.push((0, harnesses_1.createHarnessesScreen)({ host, suspend })),
+            openLogs: () => host.push((0, logs_1.createLogsScreen)({
+                host,
+                logs,
+                emptyHint: opts.viewerMode
+                    ? 'the daemon runs in another process — its log is in ~/.ainode/daemon.log'
+                    : undefined,
+            })),
+        });
+    }, {
+        onTeardown: () => {
+            logs.restore();
+            if (logs.count()) {
+                console.log(`${logs.count()} daemon log lines this session — ${paths_1.RUNTIME_LOG_FILE}`);
+            }
+        },
+    });
+    // The daemon's own numbers don't come from an RPC.
+    setInterval(() => {
+        state.inflight = (0, request_pump_1.inflightCount)();
+        state.logCount = logs.count();
+    }, 1000).unref();
+    await ui.run();
+}
+/** `ainode harnesses` — straight to the harness screen. */
+async function runHarnessesTui() {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        await (0, harnesses_1.plainStatus)();
+        return;
+    }
+    const ui = createConsole((host, suspend) => (0, harnesses_1.createHarnessesScreen)({ host, suspend }));
+    await ui.run();
 }

package/dist/tui/transcript.d.ts

@@ -1,5 +1,5 @@
+import { type AppHost, type Screen } from './app';
 import type { DataLayer, RequestRow } from './data';
-import type { AppHost, Screen } from './app';
 export interface Message {
     role: 'user' | 'assistant' | 'thinking' | 'tool_use' | 'tool_result';
     text?: string;
@@ -15,6 +15,7 @@ export interface TranscriptState {
     scroll: number;
     follow: boolean;
     loading: boolean;
+    /** Rows the last render could fit — what a PgUp/PgDn moves by. */
     viewportRows: number;
 }
 interface RawEvent {
@@ -30,7 +31,7 @@ export declare function wrapText(s: string, width: number): string[];
  */
 export declare function messagesFromEvents(events: RawEvent[], prompt: string | null): Message[];
 export declare function messageLines(m: Message, width: number): string[];
-export declare function renderTranscript(st: TranscriptState, width: number): string[];
+export declare function renderTranscript(st: TranscriptState, width: number, height: number): string[];
 export declare function createTranscriptScreen(deps: {
     data: DataLayer;
     host: AppHost;

package/dist/tui/transcript.js

@@ -14,7 +14,8 @@ exports.messageLines = messageLines;
 exports.renderTranscript = renderTranscript;
 exports.createTranscriptScreen = createTranscriptScreen;
 const render_1 = require("./render");
-const ACTIVE = new Set(['pending', 'starting', 'running']);
+const request_row_1 = require("./request-row");
+const app_1 = require("./app");
 function wrapText(s, width) {
     const out = [];
     for (const paragraph of String(s ?? '').split('\n')) {
@@ -141,14 +142,18 @@ function messageLines(m, width) {
     const wrapped = wrapText(m.text ?? '', body);
     return wrapped.map((l, i) => `  ${i === 0 ? head(tag, colour) : ' '.repeat(label)} ${m.role === 'thinking' ? (0, render_1.grey)(l) : l}`);
 }
-function renderTranscript(st, width) {
+/** Lines the screen spends on things that are not transcript body. */
+const CHROME = 4;
+function renderTranscript(st, width, height) {
     const r = st.request;
     const started = new Date(r.picked_up_at ?? r.created_at).getTime();
     const dur = r.finished_at
         ? (0, render_1.fmtDuration)(new Date(r.finished_at).getTime() - started)
         : (0, render_1.fmtDuration)(Date.now() - started);
+    const rows = Math.max(1, height - CHROME);
+    st.viewportRows = rows;
     const out = [];
-    out.push(`  ${(0, render_1.cyan)('▸')} ${(0, render_1.bold)(r.entity_name ?? '—')} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(`${r.agent}/${r.mode}`)} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(r.status)} ${(0, render_1.dim)(dur)}`);
+    out.push(`  ${(0, render_1.cyan)('▸')} ${(0, render_1.bold)(r.entity_name ?? '—')} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(`${r.agent}/${r.mode}`)} ${(0, render_1.dim)('·')} ${(0, request_row_1.statusColour)(r.status)((0, request_row_1.statusLabel)(r.status))} ${(0, render_1.dim)(dur)}`);
     out.push('');
     if (st.loading && st.messages.length === 0) {
         out.push((0, render_1.dim)('  loading transcript…'));
@@ -158,28 +163,40 @@ function renderTranscript(st, width) {
     }
     else {
         const all = st.messages.flatMap(m => messageLines(m, width));
-        const rows = Math.max(1, st.viewportRows);
+        const maxScroll = Math.max(0, all.length - rows);
         const start = st.follow
-            ? Math.max(0, all.length - rows)
-            : Math.min(st.scroll, Math.max(0, all.length - 1));
+            ? maxScroll
+            : Math.min(st.scroll, maxScroll);
+        st.scroll = start;
         out.push(...all.slice(start, start + rows));
     }
-    out.push('');
-    const live = ACTIVE.has(r.status) && st.follow ? (0, render_1.cyan)('following') : '';
-    out.push((0, render_1.dim)('  ↑↓ PgUp PgDn scroll   G follow   q back   ') + live);
-    return out.map(l => (0, render_1.truncate)(l, width));
+    while (out.length < height - 1)
+        out.push('');
+    const live = request_row_1.ACTIVE.has(r.status) && st.follow ? `  ${(0, render_1.cyan)('following')}` : '';
+    out.push((0, app_1.footerHint)([
+        { keys: '↑↓ PgUp PgDn', label: 'scroll' },
+        { keys: 'G', label: 'follow' },
+        { keys: 'q', label: 'back' },
+    ]) + live);
+    return out.map(l => (0, render_1.truncate)(l, width)).slice(0, height);
 }
 function createTranscriptScreen(deps) {
     const st = {
         request: deps.request, messages: [], scroll: 0,
         follow: true, loading: true,
-        viewportRows: Math.max(8, (process.stdout.rows ?? 30) - 10),
+        viewportRows: 20,
     };
     return {
         id: `transcript:${deps.request.id}`,
         title: 'Transcript',
-        render: (width) => renderTranscript(st, width),
-        pollMs: () => (ACTIVE.has(st.request.status) ? 1000 : 15_000),
+        render: (width, height) => renderTranscript(st, width, height),
+        pollMs: () => (request_row_1.ACTIVE.has(st.request.status) ? 1000 : 15_000),
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'scroll a line' },
+            { keys: 'PgUp/PgDn', label: 'scroll a screenful' },
+            { keys: 'g', label: 'jump to the start' },
+            { keys: 'G', label: 'jump to the end and follow the tail' },
+        ],
         async poll() {
             const detail = await deps.data.detail(deps.request.id);
             st.loading = false;
@@ -187,8 +204,15 @@ function createTranscriptScreen(deps) {
                 deps.host.redraw();
                 return;
             }
-            if (detail.request)
-                st.request = detail.request;
+            // Merge, don't replace: the detail payload's row carries live status and
+            // timings but not the joined entity name, so replacing wholesale blanked
+            // the name out of the header the moment the transcript loaded.
+            if (detail.request) {
+                st.request = {
+                    ...st.request,
+                    ...Object.fromEntries(Object.entries(detail.request).filter(([, v]) => v !== null && v !== undefined)),
+                };
+            }
             st.messages = messagesFromEvents(detail.events ?? [], st.request.prompt);
             deps.host.redraw();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [

package/scripts/probe-tui.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// Drive the console UI in a real pty and dump the frames a user would see.
+//
+// Unit tests assert on the pure render functions; this drives the actual
+// binary — alt screen, raw keys, live data, the lot. Every defect in the
+// 2026-07-30 console pass was found with this and none of them were visible
+// from the code.
+//
+//   node scripts/probe-tui.mjs "w4000,shome,ka,w2500,sactivity"
+//
+// Script steps, comma separated:
+//   w<ms>     wait
+//   k<key>    send a key: a literal, or CR UP DOWN LEFT RIGHT ESC TAB
+//   s<label>  snapshot the screen under that label
+//
+// Frames are painted with cursor addressing, so the raw pty stream is
+// replayed through a tiny terminal model to reconstruct what is on screen.
+
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as url from 'node:url';
+
+const here = path.dirname(url.fileURLToPath(import.meta.url));
+const root = path.resolve(here, '..');
+const require = createRequire(import.meta.url);
+
+let pty;
+try {
+  pty = require('node-pty');
+} catch {
+  console.error('node-pty is not installed — run npm install first');
+  process.exit(1);
+}
+
+const COLS = Number(process.env.PROBE_COLS ?? 120);
+const ROWS = Number(process.env.PROBE_ROWS ?? 40);
+const steps = (process.argv[2] ?? 'w4000,shome').split(',').filter(Boolean);
+
+const KEYS = {
+  CR: '\r', ESC: '\x1b', TAB: '\t',
+  UP: '\x1b[A', DOWN: '\x1b[B', RIGHT: '\x1b[C', LEFT: '\x1b[D',
+  PGUP: '\x1b[5~', PGDN: '\x1b[6~',
+};
+
+/** Just enough terminal to reconstruct a screen from cursor-addressed writes. */
+function createScreen(rows, cols) {
+  let grid = Array.from({ length: rows }, () => '');
+  let row = 0;
+  let col = 0;
+
+  const put = text => {
+    if (!text) return;
+    const line = grid[row] ?? '';
+    grid[row] = (line.padEnd(col, ' ')).slice(0, col) + text;
+    col += text.length;
+  };
+
+  // A pty delivers bytes, not frames: an escape sequence is routinely split
+  // across two chunks. Anything that looks like the start of one is held
+  // back until the rest arrives, or it lands in the output as literal text.
+  let pending = '';
+
+  return {
+    write(raw) {
+      const chunk = pending + raw;
+      pending = '';
+      const dangling = chunk.match(/\x1b(\[[0-9;]*|\][^\x07]*|[()]?)?$/);
+      const body = dangling ? chunk.slice(0, dangling.index) : chunk;
+      if (dangling) pending = dangling[0];
+
+      // Split into escape sequences and printable runs.
+      const re = /\x1b\[([0-9;]*)([A-Za-z])|\x1b\][^\x07]*\x07|\x1b[()][A-Za-z0-9]|[^\x1b]+/g;
+      let m;
+      while ((m = re.exec(body)) !== null) {
+        const [seq, params, cmd] = m;
+        if (cmd === undefined) {
+          if (seq.startsWith('\x1b')) continue; // OSC / charset — ignore
+          for (const part of seq.split(/(\r\n|\n|\r)/)) {
+            if (part === '\n' || part === '\r\n') { row = Math.min(rows - 1, row + 1); col = 0; }
+            else if (part === '\r') { col = 0; }
+            else put(part);
+          }
+          continue;
+        }
+        const n = params.split(';').map(x => Number(x || 0));
+        if (cmd === 'H' || cmd === 'f') { row = Math.max(0, (n[0] || 1) - 1); col = Math.max(0, (n[1] || 1) - 1); }
+        else if (cmd === 'J') { if ((n[0] ?? 0) === 2) { grid = Array.from({ length: rows }, () => ''); row = 0; col = 0; } }
+        else if (cmd === 'K') { grid[row] = (grid[row] ?? '').slice(0, col); }
+        else if (cmd === 'A') { row = Math.max(0, row - (n[0] || 1)); }
+        else if (cmd === 'B') { row = Math.min(rows - 1, row + (n[0] || 1)); }
+        // m (colour), h/l (modes) do not move the cursor or change content
+      }
+    },
+    snapshot() {
+      return grid.map(l => l.replace(/\s+$/, '')).join('\n').replace(/\n{3,}$/, '\n');
+    },
+  };
+}
+
+const screen = createScreen(ROWS, COLS);
+const child = pty.spawn(process.execPath, ['dist/cli.js'], {
+  name: 'xterm-256color', cols: COLS, rows: ROWS, cwd: root,
+  env: { ...process.env, TERM: 'xterm-256color' },
+});
+child.onData(d => screen.write(d));
+
+const wait = ms => new Promise(r => setTimeout(r, ms));
+const strip = s => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+for (const step of steps) {
+  const kind = step[0];
+  const arg = step.slice(1);
+  if (kind === 'w') await wait(Number(arg));
+  else if (kind === 'k') child.write(KEYS[arg] ?? arg);
+  else if (kind === 's') {
+    process.stdout.write(`\n===== ${arg} =====\n${strip(screen.snapshot())}\n`);
+  }
+}
+
+child.kill();
+process.exit(0);