@addai/node 0.7.0 → 0.8.0

package/dist/tui/dashboard.d.ts

@@ -7,7 +7,15 @@ export interface DashboardState {
     /** 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[];
+    /** Cursor position in the menu. */
     sel: number;
+    /** Id of the selected live run, or null when the cursor is in the menu.
+     *  Pinned by id rather than by index because the band reorders under the
+     *  cursor: a new run is prepended the moment it starts, and an index would
+     *  quietly leave you pointing at a different run than the one you chose. */
+    nowSelId: string | null;
+    /** Live rows the last render could fit — what bounds the cursor. */
+    nowRows: number;
     spin: number;
     pid: number | null;
     startedAt: number | null;
@@ -35,6 +43,19 @@ export declare const MENU: Array<{
 /** 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[];
+/** The live rows the band actually draws — the only ones the cursor can reach.
+ *  Everything past the cap lives on the Activity screen. A short terminal
+ *  draws fewer than MAX_NOW_ROWS, and the cursor must not run off into rows
+ *  that are not on screen, so the last render's row count is what bounds it. */
+export declare function selectableNow(st: DashboardState): RequestRow[];
+/**
+ * Where the cursor is in the NOW band, or -1 for "in the menu".
+ *
+ * Derived from the pinned id on every read, so a run that finishes while
+ * selected drops the cursor back to the menu rather than silently moving it
+ * onto whichever run took that row.
+ */
+export declare function nowIndex(st: DashboardState): number;
 /**
  * The node's own state, as a label.
  *

package/dist/tui/dashboard.js

@@ -8,6 +8,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_NOW_ROWS = exports.MENU = void 0;
 exports.liveRequests = liveRequests;
+exports.selectableNow = selectableNow;
+exports.nowIndex = nowIndex;
 exports.stateLabel = stateLabel;
 exports.autostartLine = autostartLine;
 exports.fmtCount = fmtCount;
@@ -29,6 +31,26 @@ exports.MAX_NOW_ROWS = 6;
 function liveRequests(rows) {
     return rows.filter(r => request_row_1.ACTIVE.has(r.status));
 }
+/** The live rows the band actually draws — the only ones the cursor can reach.
+ *  Everything past the cap lives on the Activity screen. A short terminal
+ *  draws fewer than MAX_NOW_ROWS, and the cursor must not run off into rows
+ *  that are not on screen, so the last render's row count is what bounds it. */
+function selectableNow(st) {
+    const cap = Math.max(1, Math.min(exports.MAX_NOW_ROWS, st.nowRows || exports.MAX_NOW_ROWS));
+    return liveRequests(st.recent).slice(0, cap);
+}
+/**
+ * Where the cursor is in the NOW band, or -1 for "in the menu".
+ *
+ * Derived from the pinned id on every read, so a run that finishes while
+ * selected drops the cursor back to the menu rather than silently moving it
+ * onto whichever run took that row.
+ */
+function nowIndex(st) {
+    if (!st.nowSelId)
+        return -1;
+    return selectableNow(st).findIndex(r => r.id === st.nowSelId);
+}
 /**
  * The node's own state, as a label.
  *
@@ -128,7 +150,10 @@ function lastFinished(rows) {
 }
 function nowLines(st, width, rows) {
     const live = liveRequests(st.recent);
-    const out = [`  ${(0, render_1.bold)('Now')}`];
+    const heading = live.length
+        ? `  ${(0, render_1.bold)('Now')}  ${(0, render_1.dim)('↑ to select · ⏎ to watch')}`
+        : `  ${(0, render_1.bold)('Now')}`;
+    const out = [heading];
     if (live.length === 0) {
         const last = lastFinished(st.recent);
         out.push(last
@@ -138,7 +163,9 @@ function nowLines(st, width, rows) {
     }
     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)));
+    st.nowRows = shown.length;
+    const cursor = nowIndex(st);
+    shown.forEach((r, i) => out.push((0, request_row_1.requestLine)(r, st.now, i === cursor, width, st.spin)));
     if (live.length > shown.length) {
         out.push((0, render_1.dim)(`     +${live.length - shown.length} more running`));
     }
@@ -153,8 +180,11 @@ function renderDashboard(st, width, height) {
     // 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;
+    // One cursor on screen at a time: while it is up in the NOW band the menu
+    // shows no selection, or the eye reads two.
+    const inNow = nowIndex(st) >= 0;
     const menu = exports.MENU.map((m, i) => {
-        const selected = i === st.sel;
+        const selected = !inNow && 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` : '';
@@ -162,7 +192,7 @@ function renderDashboard(st, width, height) {
     });
     const foot = (0, app_1.footerHint)([
         { keys: '↑↓', label: 'move' },
-        { keys: '⏎', label: 'open' },
+        { keys: '⏎', label: inNow ? 'watch this run' : 'open' },
         { keys: 's', label: st.autostart?.enabled ? 'startup off' : 'startup on' },
         { keys: 'r', label: 'refresh' },
         { keys: '?', label: 'keys' },
@@ -202,6 +232,11 @@ function createDashboardScreen(deps) {
         if (recent.length)
             st.recent = recent;
         st.offline = deps.data.offline();
+        // A selected run that has finished is no longer in the band. nowIndex
+        // already reads that as "cursor is in the menu"; drop the id too so the
+        // state doesn't keep pointing at a run nobody can see.
+        if (st.nowSelId && !selectableNow(st).some(r => r.id === st.nowSelId))
+            st.nowSelId = null;
         // Reads a file (and, on Windows, a cached schtasks query) — cheap enough
         // to ride the same poll, so the header can't disagree with reality after
         // someone changes it from Studio or the CLI.
@@ -242,6 +277,43 @@ function createDashboardScreen(deps) {
         // line — a note that never clears becomes furniture.
         setTimeout(() => { st.autostartNote = null; deps.host.redraw(); }, 8000).unref?.();
     };
+    /**
+     * One cursor over two stacked lists: the NOW band sits above the menu, so
+     * ↑ off the top of the menu lands on the LAST live row (the one nearest the
+     * menu) and ↓ off the bottom of the band returns to the first menu item.
+     * Reading the screen top to bottom, the cursor moves the way the eye does.
+     */
+    const moveUp = () => {
+        const live = selectableNow(st);
+        const i = nowIndex(st);
+        if (i < 0) {
+            // In the menu. Step up inside it first; only leave from the top row.
+            if (st.sel > 0) {
+                st.sel -= 1;
+                return;
+            }
+            if (live.length)
+                st.nowSelId = live[live.length - 1].id;
+            return;
+        }
+        if (i > 0)
+            st.nowSelId = live[i - 1].id;
+    };
+    const moveDown = () => {
+        const live = selectableNow(st);
+        const i = nowIndex(st);
+        if (i < 0) {
+            st.sel = Math.min(exports.MENU.length - 1, st.sel + 1);
+            return;
+        }
+        // Past the last live row is the menu, entered at its first item.
+        if (i >= live.length - 1) {
+            st.nowSelId = null;
+            st.sel = 0;
+            return;
+        }
+        st.nowSelId = live[i + 1].id;
+    };
     return {
         id: 'dashboard',
         title: '+Ai Node',
@@ -258,8 +330,8 @@ function createDashboardScreen(deps) {
             return true;
         },
         keys: () => [
-            { keys: '↑↓ / jk', label: 'move between destinations' },
-            { keys: '⏎', label: 'open the selected destination' },
+            { keys: '↑↓ / jk', label: 'move — up from the menu into the live runs' },
+            { keys: '⏎', label: 'open the destination, or watch the selected run' },
             { keys: 'a', label: 'activity — full request history' },
             { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
             { keys: 'l', label: 'logs — daemon output' },
@@ -268,12 +340,12 @@ function createDashboardScreen(deps) {
         ],
         async onKey(key) {
             if (key.name === 'up' || key.name === 'k') {
-                st.sel = Math.max(0, st.sel - 1);
+                moveUp();
                 deps.host.redraw();
                 return;
             }
             if (key.name === 'down' || key.name === 'j') {
-                st.sel = Math.min(exports.MENU.length - 1, st.sel + 1);
+                moveDown();
                 deps.host.redraw();
                 return;
             }
@@ -298,6 +370,12 @@ function createDashboardScreen(deps) {
                 return;
             }
             if (key.name === 'return') {
+                // A selected run wins over the menu: the cursor is visibly on it.
+                const live = selectableNow(st)[nowIndex(st)];
+                if (live) {
+                    deps.openTranscript(live);
+                    return;
+                }
                 const target = exports.MENU[st.sel]?.key;
                 if (target === 'harnesses')
                     deps.openHarnesses();

package/dist/tui/run.js

@@ -192,7 +192,7 @@ async function runDashboard(opts) {
     // 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,
+        self: null, stats: null, recent: [], sel: 0, nowSelId: null, nowRows: 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "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": [