@addai/node 0.4.0

package/dist/tui/run.js

@@ -0,0 +1,178 @@
+"use strict";
+// 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.
+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.FEED_ROWS = void 0;
+exports.shouldRenderTui = shouldRenderTui;
+exports.runDashboard = runDashboard;
+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 render_1 = require("./render");
+const console_capture_1 = require("./console-capture");
+const store_1 = require("../store");
+const request_pump_1 = require("../request-pump");
+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,
+    };
+    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.
+    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)
+            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');
+    }
+    function onKeypress(_s, key) {
+        void app.handleKey(key);
+    }
+    function attachInput() {
+        if (inputAttached)
+            return;
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('keypress', onKeypress);
+        inputAttached = true;
+    }
+    function detachInput() {
+        if (!inputAttached)
+            return;
+        process.stdin.off('keypress', onKeypress);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+        inputAttached = false;
+    }
+    function teardown() {
+        if (quitting)
+            return;
+        quitting = true;
+        clearInterval(pollTimer);
+        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();
+        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)
+            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(() => { });
+}

package/dist/tui/transcript.d.ts

@@ -0,0 +1,39 @@
+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;
+    name?: string;
+    input?: unknown;
+    content?: unknown;
+    isError?: boolean;
+    ts?: string | null;
+}
+export interface TranscriptState {
+    request: RequestRow;
+    messages: Message[];
+    scroll: number;
+    follow: boolean;
+    loading: boolean;
+    viewportRows: number;
+}
+interface RawEvent {
+    type: string;
+    payload?: Record<string, unknown> | null;
+    emitted_at?: string | null;
+}
+export declare function wrapText(s: string, width: number): string[];
+/**
+ * Turn the raw event feed (newest first, as the RPC returns it) into an
+ * ordered message list. Unknown and protocol-level events are dropped —
+ * a transcript is a conversation, not a wire log.
+ */
+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 createTranscriptScreen(deps: {
+    data: DataLayer;
+    host: AppHost;
+    request: RequestRow;
+}): Screen;
+export {};

package/dist/tui/transcript.js

@@ -0,0 +1,234 @@
+"use strict";
+// One request, in full: the conversation as it happened.
+//
+// While the run is live this auto-follows the tail. Scrolling up detaches
+// following (nobody wants the view yanked away mid-read); G re-attaches.
+//
+// The event stream is delta-shaped — a sentence arrives as a dozen
+// assistant_text events — so consecutive deltas of the same kind are
+// coalesced before anything is rendered.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapText = wrapText;
+exports.messagesFromEvents = messagesFromEvents;
+exports.messageLines = messageLines;
+exports.renderTranscript = renderTranscript;
+exports.createTranscriptScreen = createTranscriptScreen;
+const render_1 = require("./render");
+const ACTIVE = new Set(['pending', 'starting', 'running']);
+function wrapText(s, width) {
+    const out = [];
+    for (const paragraph of String(s ?? '').split('\n')) {
+        let line = '';
+        for (const word of paragraph.split(' ')) {
+            let w = word;
+            while (w.length > width) {
+                if (line) {
+                    out.push(line);
+                    line = '';
+                }
+                out.push(w.slice(0, width));
+                w = w.slice(width);
+            }
+            if (!line)
+                line = w;
+            else if (line.length + 1 + w.length <= width)
+                line += ` ${w}`;
+            else {
+                out.push(line);
+                line = w;
+            }
+        }
+        out.push(line);
+    }
+    return out;
+}
+function compact(value, max) {
+    if (value == null)
+        return '';
+    let s;
+    if (typeof value === 'string')
+        s = value;
+    else if (Array.isArray(value)) {
+        // tool_result content is [{type:'text', text:'…'}]
+        s = value
+            .map(v => (v && typeof v === 'object' && 'text' in v
+            ? String(v.text)
+            : JSON.stringify(v)))
+            .join(' ');
+    }
+    else
+        s = JSON.stringify(value);
+    return s.replace(/\s+/g, ' ').slice(0, max);
+}
+/**
+ * Turn the raw event feed (newest first, as the RPC returns it) into an
+ * ordered message list. Unknown and protocol-level events are dropped —
+ * a transcript is a conversation, not a wire log.
+ */
+function messagesFromEvents(events, prompt) {
+    const msgs = [];
+    if (prompt)
+        msgs.push({ role: 'user', text: prompt });
+    const ordered = [...(events ?? [])].reverse(); // oldest first
+    for (const ev of ordered) {
+        const p = (ev?.payload ?? {});
+        const last = msgs[msgs.length - 1];
+        if (ev.type === 'assistant_text' || ev.type === 'thinking') {
+            const role = ev.type === 'thinking' ? 'thinking' : 'assistant';
+            const delta = String(p.delta ?? '');
+            if (!delta)
+                continue;
+            if (last && last.role === role)
+                last.text = `${last.text ?? ''}${delta}`;
+            else
+                msgs.push({ role, text: delta, ts: ev.emitted_at ?? null });
+            continue;
+        }
+        if (ev.type === 'tool_use') {
+            msgs.push({
+                role: 'tool_use',
+                name: String(p.name ?? '?'),
+                input: p.input,
+                ts: ev.emitted_at ?? null,
+            });
+            continue;
+        }
+        if (ev.type === 'tool_result') {
+            msgs.push({
+                role: 'tool_result',
+                content: p.content,
+                isError: p.isError === true,
+                ts: ev.emitted_at ?? null,
+            });
+            continue;
+        }
+        // Codex reports shell work as item.started / item.completed.
+        if (ev.type.startsWith('claude:codex.item.')) {
+            const item = (p.raw?.item ?? {});
+            if (item.type !== 'command_execution')
+                continue;
+            if (ev.type.endsWith('started')) {
+                msgs.push({ role: 'tool_use', name: 'command', input: item.command, ts: ev.emitted_at ?? null });
+            }
+            else {
+                msgs.push({
+                    role: 'tool_result',
+                    content: item.aggregated_output,
+                    isError: typeof item.exit_code === 'number' && item.exit_code !== 0,
+                    ts: ev.emitted_at ?? null,
+                });
+            }
+            continue;
+        }
+        // everything else (claude:system, ready, session_end, turn_complete,
+        // rate-limit notices) is protocol noise
+    }
+    return msgs;
+}
+function messageLines(m, width) {
+    const label = 6;
+    const body = Math.max(10, width - label - 3);
+    const head = (tag, colour) => colour(tag.padEnd(label));
+    if (m.role === 'tool_use') {
+        return [`  ${head('tool', render_1.cyan)} ${(0, render_1.cyan)('⏺')} ${(0, render_1.bold)(m.name ?? '?')} ${(0, render_1.dim)(compact(m.input, Math.max(8, body - 12)))}`];
+    }
+    if (m.role === 'tool_result') {
+        const tag = m.isError ? (0, render_1.red)('error ') : (0, render_1.grey)('result');
+        return [`  ${tag} ${(0, render_1.dim)(compact(m.content, body))}`];
+    }
+    const colour = m.role === 'user' ? render_1.green : m.role === 'thinking' ? render_1.grey : render_1.dim;
+    const tag = m.role === 'user' ? 'you' : m.role === 'thinking' ? 'think' : 'agent';
+    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) {
+    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 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('');
+    if (st.loading && st.messages.length === 0) {
+        out.push((0, render_1.dim)('  loading transcript…'));
+    }
+    else if (st.messages.length === 0) {
+        out.push((0, render_1.dim)('  nothing recorded for this request'));
+    }
+    else {
+        const all = st.messages.flatMap(m => messageLines(m, width));
+        const rows = Math.max(1, st.viewportRows);
+        const start = st.follow
+            ? Math.max(0, all.length - rows)
+            : Math.min(st.scroll, Math.max(0, all.length - 1));
+        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));
+}
+function createTranscriptScreen(deps) {
+    const st = {
+        request: deps.request, messages: [], scroll: 0,
+        follow: true, loading: true,
+        viewportRows: Math.max(8, (process.stdout.rows ?? 30) - 10),
+    };
+    return {
+        id: `transcript:${deps.request.id}`,
+        title: 'Transcript',
+        render: (width) => renderTranscript(st, width),
+        pollMs: () => (ACTIVE.has(st.request.status) ? 1000 : 15_000),
+        async poll() {
+            const detail = await deps.data.detail(deps.request.id);
+            st.loading = false;
+            if (!detail) {
+                deps.host.redraw();
+                return;
+            }
+            if (detail.request)
+                st.request = detail.request;
+            st.messages = messagesFromEvents(detail.events ?? [], st.request.prompt);
+            deps.host.redraw();
+        },
+        onKey(key) {
+            const page = Math.max(1, st.viewportRows - 2);
+            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;
+            }
+        },
+    };
+}

package/dist/tui.d.ts

@@ -0,0 +1 @@
+export declare function runHarnessesTui(): Promise<void>;