@addai/node 0.4.0

package/dist/tui/console-capture.js

@@ -0,0 +1,62 @@
+"use strict";
+// While the console UI owns the terminal, the daemon must not write to it.
+//
+// `ainode` with no args runs the daemon IN THIS PROCESS and then paints a
+// full-screen UI over the same stdout. The daemon logs continuously —
+// request-pump backoffs, sleep/wake detection, session-runner chatter — and
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureConsole = captureConsole;
+const MAX_LINES = 500;
+function captureConsole() {
+    const ring = [];
+    const original = {
+        log: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+    };
+    const format = (args) => args.map(a => {
+        if (typeof a === 'string')
+            return a;
+        if (a instanceof Error)
+            return a.stack ?? a.message;
+        try {
+            return JSON.stringify(a);
+        }
+        catch {
+            return String(a);
+        }
+    }).join(' ');
+    const push = (level) => (...args) => {
+        ring.push({ level, text: format(args), at: Date.now() });
+        if (ring.length > MAX_LINES)
+            ring.shift();
+    };
+    console.log = push('log');
+    console.warn = push('warn');
+    console.error = push('error');
+    return {
+        lines: () => [...ring],
+        last: () => (ring.length ? ring[ring.length - 1] : null),
+        count: () => ring.length,
+        restoreAndReplay() {
+            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);
+            }
+        },
+    };
+}

package/dist/tui/dashboard.d.ts

@@ -0,0 +1,42 @@
+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[];
+    sel: number;
+    spin: number;
+    pid: number | null;
+    startedAt: number | null;
+    inflight: number;
+    paired: boolean;
+    viewerMode: boolean;
+    offline: boolean;
+    now: number;
+    version: string;
+    /** Newest line the daemon logged while the UI owned the screen. */
+    lastLog: string | null;
+    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. */
+export declare const MENU: Array<{
+    key: string;
+    label: string;
+    hint: string;
+    shortcut: string;
+}>;
+export declare function renderDashboard(st: DashboardState, width: number): string[];
+export declare function createDashboardScreen(deps: {
+    data: DataLayer;
+    host: AppHost;
+    state: DashboardState;
+    openTranscript(r: RequestRow): void;
+    openRequests(): void;
+    openHarnesses(): void;
+}): Screen;

package/dist/tui/dashboard.js

@@ -0,0 +1,205 @@
+"use strict";
+// Home screen: is this node alive, what has it been doing, what is it
+// doing right now.
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MENU = exports.FEED_ROWS = void 0;
+exports.shortVia = shortVia;
+exports.requestLine = requestLine;
+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}`;
+}
+function headerLines(st) {
+    if (!st.paired) {
+        return [
+            (0, render_1.yellow)('not paired'),
+            (0, render_1.dim)('run `ainode` and follow the prompt to vault.add.ai/entity/connect/<CODE>'),
+        ];
+    }
+    const self = st.self;
+    const name = self?.name ?? self?.hostname ?? 'this node';
+    const state = self?.effective_status === 'online'
+        ? (0, render_1.green)('online')
+        : (0, render_1.yellow)(self?.effective_status ?? 'unknown');
+    const paired = self?.created_at ? `paired ${(0, render_1.fmtRelative)(self.created_at, st.now)}` : '';
+    const first = `${(0, render_1.bold)(name)} ${(0, render_1.dim)('·')} ${state} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(paired)}`;
+    const up = st.startedAt ? (0, render_1.fmtDuration)(st.now - st.startedAt) : '—';
+    const daemon = st.viewerMode
+        ? `${(0, render_1.cyan)('⏺')} viewer ${(0, render_1.dim)('· another ainode owns this node')}  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}`
+        : `${(0, render_1.green)('⏺')} running  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)(`up ${up}`)}  ${(0, render_1.dim)(`${st.inflight} in flight`)}`;
+    const chip = st.offline ? `  ${(0, render_1.yellow)('⚠ offline · retrying')}` : '';
+    return [first, daemon + chip];
+}
+function statsLines(st) {
+    const s = st.stats;
+    if (!s)
+        return [(0, render_1.dim)('stats unavailable')];
+    const agents = Object.entries(s.by_agent)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, v]) => `${k} ${v}`)
+        .join(' · ');
+    const cancels = s.canceled_24h ? (0, render_1.dim)(`  ${s.canceled_24h} cancelled`) : '';
+    // The ✓/✗/avg figures are a rolling 24h window while "Today" is the
+    // calendar day, so they are labelled — otherwise ✓3 next to Today 2
+    // looks like an arithmetic bug.
+    return [
+        `${(0, render_1.bold)(`Today ${s.today}`)}   ${(0, render_1.dim)('·')}   ${(0, render_1.dim)('24h')} ${(0, render_1.green)(`✓ ${s.succeeded_24h}`)}  ${s.failed_24h ? (0, render_1.red)(`✗ ${s.failed_24h}`) : (0, render_1.dim)('✗ 0')}${cancels}   ${(0, render_1.dim)(`avg ${(0, render_1.fmtDuration)(s.avg_duration_ms)}`)}   ${(0, render_1.dim)(agents)}`,
+        (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)}`);
+        });
+    }
+    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('');
+    out.push((0, render_1.dim)('  ↑↓ move   ⏎ open   r refresh   q quit'));
+    return out.map(l => (0, render_1.truncate)(l, width));
+}
+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()]);
+        if (self)
+            st.self = self;
+        if (stats)
+            st.stats = stats;
+        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),
+        poll: refresh,
+        async onKey(key) {
+            if (key.name === 'up' || key.name === 'k') {
+                st.sel = Math.max(0, st.sel - 1);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                st.sel = Math.min(exports.MENU.length - 1, st.sel + 1);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'a') {
+                deps.openRequests();
+                return;
+            }
+            if (key.name === 'h') {
+                deps.openHarnesses();
+                return;
+            }
+            if (key.name === 'r') {
+                await refresh();
+                return;
+            }
+            if (key.name === 'return') {
+                if (exports.MENU[st.sel]?.key === 'harnesses')
+                    deps.openHarnesses();
+                else
+                    deps.openRequests();
+            }
+        },
+    };
+}

package/dist/tui/data.d.ts

@@ -0,0 +1,57 @@
+export interface RequestRow {
+    id: string;
+    entity_name: string | null;
+    agent: string;
+    mode: string;
+    model: string | null;
+    issued_via: string | null;
+    status: string;
+    prompt: string | null;
+    created_at: string;
+    picked_up_at: string | null;
+    finished_at: string | null;
+    last_activity_at: string | null;
+    retry_count: number | null;
+    error_code: string | null;
+    error_message: string | null;
+}
+export interface NodeStats {
+    today: number;
+    week: number;
+    month: number;
+    total: number;
+    active: number;
+    succeeded_24h: number;
+    failed_24h: number;
+    canceled_24h: number;
+    avg_duration_ms: number;
+    by_agent: Record<string, number>;
+}
+export interface NodeSelf {
+    id: string;
+    name: string;
+    hostname: string | null;
+    platform: string | null;
+    status: string;
+    effective_status: string;
+    last_seen_at: string | null;
+    created_at: string;
+}
+export interface DataLayer {
+    self(): Promise<NodeSelf | null>;
+    stats(): Promise<NodeStats | null>;
+    requests(opts?: {
+        limit?: number;
+        before?: string | null;
+    }): Promise<RequestRow[]>;
+    detail(id: string): Promise<unknown>;
+    lastError(): string | null;
+    offline(): boolean;
+}
+type Rpc = (name: string, args: Record<string, unknown>) => Promise<unknown>;
+export declare function createDataLayer(deps: {
+    token: string;
+    rpc?: Rpc;
+    breakerOpen?: () => boolean;
+}): DataLayer;
+export {};

package/dist/tui/data.js

@@ -0,0 +1,62 @@
+"use strict";
+// The only place the console UI talks to Supabase.
+//
+// Screens read cached values and never await a network call while
+// rendering. Three rules: one in-flight request per rpc (a slow tick can
+// never stack), the last good value survives a failure, and an open
+// circuit breaker means we don't even try.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataLayer = createDataLayer;
+const supabase_client_1 = require("../supabase-client");
+function createDataLayer(deps) {
+    const call = deps.rpc ?? supabase_client_1.rpc;
+    const breakerOpen = deps.breakerOpen ?? supabase_client_1.rpcBreakerOpen;
+    const cache = new Map();
+    const inflight = new Map();
+    let lastError = null;
+    let offline = false;
+    async function fetch(key, name, args) {
+        if (breakerOpen()) {
+            offline = true;
+            return cache.get(key) ?? null;
+        }
+        const existing = inflight.get(key);
+        if (existing)
+            return existing;
+        const p = (async () => {
+            try {
+                const res = await call(name, { p_token: deps.token, ...args });
+                cache.set(key, res);
+                offline = false;
+                lastError = null;
+                return res;
+            }
+            catch (err) {
+                offline = true;
+                lastError = err.message;
+                return cache.get(key) ?? null;
+            }
+            finally {
+                inflight.delete(key);
+            }
+        })();
+        inflight.set(key, p);
+        return p;
+    }
+    return {
+        self: () => fetch('self', 'runtime_self', {}),
+        stats: () => fetch('stats', 'runtime_self_stats', {}),
+        async requests(opts = {}) {
+            const limit = opts.limit ?? 20;
+            const before = opts.before ?? null;
+            const key = `requests:${limit}:${before ?? 'head'}`;
+            const rows = await fetch(key, 'runtime_self_recent_requests', {
+                p_limit: limit, p_before: before,
+            });
+            return Array.isArray(rows) ? rows : [];
+        },
+        detail: (id) => fetch(`detail:${id}`, 'runtime_self_request_detail', { p_request_id: id }),
+        lastError: () => lastError,
+        offline: () => offline,
+    };
+}

package/dist/tui/harnesses.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export declare function runHarnessesTui(opts?: {
+    embedded?: boolean;
+}): Promise<void>;