@addai/node 0.30.9 → 0.30.10

package/dist/cli.js

@@ -202,6 +202,10 @@ async function main() {
             pid: runtime.pid,
             startedAt: Date.now(),
             version: index_1.VERSION,
+            // The daemon is running in this process, so the dashboard needs a way to
+            // stop it properly when the user actually asks — and, just as important,
+            // a way to tell that case apart from the terminal disappearing.
+            stop: runtime.stop,
         });
         return;
     }

package/dist/index.js

@@ -376,7 +376,7 @@ async function sweepStaleSessionDirs() {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const path = require('path');
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { RUNTIME_SESSIONS_DIR } = require('./paths');
+    const { RUNTIME_SESSIONS_DIR, RUNTIME_LOG_FILE } = require('./paths');
     if (!fs.existsSync(RUNTIME_SESSIONS_DIR))
         return;
     const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
@@ -404,30 +404,63 @@ async function sweepStaleSessionDirs() {
         catch { /* unreadable dir — fall back to its own mtime */ }
         return newest;
     };
-    let removed = 0;
+    // Deleting a session dir un-homes any chat still resuming a session keyed to
+    // it, so the names have to be recoverable — a bare count made that class of
+    // breakage invisible. But a node that has been up for months sweeps hundreds
+    // at once, and one console line each buried the dashboard under a screenful
+    // of scrollback on every single start. So: the full list goes to the daemon
+    // log, and the terminal gets a sample and the totals.
+    const SHOWN = 5;
+    const swept = [];
+    const failures = [];
     let kept = 0;
     for (const name of fs.readdirSync(RUNTIME_SESSIONS_DIR)) {
         const p = path.join(RUNTIME_SESSIONS_DIR, name);
+        let st;
         try {
-            const st = fs.statSync(p);
-            if (!st.isDirectory())
-                continue;
-            if (effectiveMtimeMs(p, st.mtimeMs) < cutoff) {
-                // Deleting a session dir un-homes any chat still resuming a session
-                // keyed to it, so say which ones went — the old count-only line made
-                // that class of breakage invisible.
-                console.log(`[startup] sweeping stale session dir: ${p}`);
-                fs.rmSync(p, { recursive: true, force: true });
-                removed++;
-            }
-            else {
-                kept++;
-            }
+            st = fs.statSync(p);
+        }
+        catch {
+            continue; /* unreadable entry */
+        }
+        if (!st.isDirectory())
+            continue;
+        if (effectiveMtimeMs(p, st.mtimeMs) >= cutoff) {
+            kept++;
+            continue;
+        }
+        try {
+            fs.rmSync(p, { recursive: true, force: true });
+            swept.push(p);
+        }
+        catch (err) {
+            // A dir we cannot delete comes back every start. It used to be announced
+            // as swept each time, forever, with the real error swallowed — so the
+            // one line that would explain a home disk filling up never appeared.
+            failures.push(`${p}: ${err.message}`);
         }
-        catch { /* skip unreadable entry */ }
     }
-    if (removed > 0) {
-        console.log(`[startup] swept ${removed} session dir(s) unused for 7d; ${kept} kept`);
+    if (swept.length === 0 && failures.length === 0)
+        return;
+    // Append before logging: the console line points at this file, so it had
+    // better already say what happened by the time anyone opens it.
+    try {
+        const stamp = new Date().toISOString();
+        const body = [
+            ...swept.map(p => `${stamp} [startup] swept stale session dir: ${p}`),
+            ...failures.map(l => `${stamp} [startup] could NOT sweep session dir ${l}`),
+        ].join('\n');
+        fs.appendFileSync(RUNTIME_LOG_FILE, `${body}\n`);
+    }
+    catch { /* the sweep still happened; losing the record is not fatal */ }
+    if (swept.length > 0) {
+        const sample = swept.slice(0, SHOWN).map(p => path.basename(p));
+        const more = swept.length > SHOWN ? `, +${swept.length - SHOWN} more` : '';
+        console.log(`[startup] swept ${swept.length} session dir(s) unused for 7d; ${kept} kept`);
+        console.log(`[startup]   ${sample.join(', ')}${more} — full list in ${RUNTIME_LOG_FILE}`);
+    }
+    if (failures.length > 0) {
+        console.error(`[startup] ${failures.length} stale session dir(s) could not be deleted — first: ${failures[0]}`);
     }
 }
 /** How long a remote restart waits for live turns to finish before handing

package/dist/tui/run.d.ts

@@ -3,11 +3,38 @@ export declare function shouldRenderTui(env: {
     stdinTTY: boolean;
     noTui: boolean;
 }): boolean;
+/** Why the console gave the terminal back. Only `quit` is the user asking
+ *  to stop; the rest are the terminal being taken away underneath us. */
+export type LeaveReason = 'quit' | 'SIGHUP' | 'SIGTTIN' | 'SIGTTOU' | 'stdin-error';
+/** What giving the terminal back should cost. */
+export type LeaveAction = 
+/** Close the screen and go — nothing of ours is running here. */
+'exit'
+/** Drain the in-process daemon first, then go. */
+ | 'shutdown'
+/** Close the screen and keep the daemon running headless. */
+ | 'detach';
+/**
+ * The rule that decides whether this node survives the night.
+ *
+ * `ainode` runs the daemon in the SAME process as the dashboard, and every
+ * teardown used to end in process.exit(0). So a terminal that went away while
+ * nobody was watching — a closed window, an ssh drop, a stray read from a
+ * background process group — stopped the node, and it stayed stopped until
+ * someone re-ran `ainode` the next morning. Only `quit` is a person asking.
+ *
+ * Pure and exported so the rule is checkable without a TTY.
+ */
+export declare function leaveAction(reason: LeaveReason, ownsDaemon: boolean): LeaveAction;
 export declare function runDashboard(opts: {
     viewerMode: boolean;
     pid: number | null;
     startedAt: number | null;
     version: string;
+    /** The in-process daemon's graceful shutdown, when this process owns one.
+     *  Its presence is also how the screen knows quitting means stopping the
+     *  node rather than closing a window onto someone else's. */
+    stop?: () => Promise<void>;
 }): Promise<void>;
 /** `ainode harnesses` — straight to the harness screen. */
 export declare function runHarnessesTui(): Promise<void>;

package/dist/tui/run.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldRenderTui = shouldRenderTui;
+exports.leaveAction = leaveAction;
 exports.runDashboard = runDashboard;
 exports.runHarnessesTui = runHarnessesTui;
 const readline = __importStar(require("readline"));
@@ -62,6 +63,22 @@ function shouldRenderTui(env) {
 const TICK_MS = 250;
 /** Spinner cadence. Cheap now that frames are painted as a diff. */
 const SPIN_MS = 120;
+/**
+ * The rule that decides whether this node survives the night.
+ *
+ * `ainode` runs the daemon in the SAME process as the dashboard, and every
+ * teardown used to end in process.exit(0). So a terminal that went away while
+ * nobody was watching — a closed window, an ssh drop, a stray read from a
+ * background process group — stopped the node, and it stayed stopped until
+ * someone re-ran `ainode` the next morning. Only `quit` is a person asking.
+ *
+ * Pure and exported so the rule is checkable without a TTY.
+ */
+function leaveAction(reason, ownsDaemon) {
+    if (!ownsDaemon)
+        return 'exit';
+    return reason === 'quit' ? 'shutdown' : 'detach';
+}
 /**
  * Own the terminal on behalf of a screen stack.
  *
@@ -69,7 +86,13 @@ const SPIN_MS = 120;
  * 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));
+    // A terminal that has gone away makes every write fail with EIO/EPIPE. In
+    // daemon mode the node is running in this very process, so a dead screen
+    // must never be the thing that takes it down.
+    const painter = (0, render_1.createPainter)(s => { try {
+        process.stdout.write(s);
+    }
+    catch { /* screen gone */ } });
     let quitting = false;
     let inputAttached = false;
     // Building the root screen redraws, and that happens before run() has
@@ -82,7 +105,7 @@ function createConsole(build, hooks = {}) {
     // 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 app = (0, app_1.createApp)({ id: 'boot', title: '+Ai Node', render: () => [] }, { onQuit: () => teardown('quit'), onRedraw: () => draw() });
     function draw() {
         if (!started || quitting || suspended)
             return;
@@ -92,7 +115,7 @@ function createConsole(build, hooks = {}) {
         void app.handleKey(key);
     }
     function onStdinError() {
-        teardown();
+        teardown('stdin-error');
     }
     function attachInput() {
         if (inputAttached)
@@ -116,14 +139,24 @@ function createConsole(build, hooks = {}) {
             return;
         process.stdin.off('keypress', onKeypress);
         process.stdin.off('error', onStdinError);
-        if (process.stdin.isTTY)
-            process.stdin.setRawMode(false);
-        process.stdin.pause();
+        // Putting a terminal back that no longer exists throws — and this runs
+        // from the very signal handler that means it no longer exists. Unguarded,
+        // that throw skips the rest of teardown, so onLeave never gets to say the
+        // node is still up and the reason is lost.
+        try {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+        }
+        catch { /* gone */ }
+        try {
+            process.stdin.pause();
+        }
+        catch { /* gone */ }
         inputAttached = false;
     }
     let pollTimer = null;
     let spinTimer = null;
-    function teardown() {
+    function teardown(reason) {
         if (quitting)
             return;
         quitting = true;
@@ -132,9 +165,14 @@ function createConsole(build, hooks = {}) {
         if (spinTimer)
             clearInterval(spinTimer);
         detachInput();
-        (0, render_1.altOff)();
-        hooks.onTeardown?.();
-        process.exit(0);
+        try {
+            (0, render_1.altOff)();
+        }
+        catch { /* the terminal is already gone */ }
+        if (hooks.onLeave)
+            hooks.onLeave(reason);
+        else
+            process.exit(0);
     }
     const suspend = async (fn) => {
         suspended = true;
@@ -157,12 +195,21 @@ function createConsole(build, hooks = {}) {
     // background process group earns SIGTTIN, and the default action is to STOP
     // the process — which is what "zsh: suspended (tty input)" is. Stopped mid-
     // draw it still holds the terminal in raw mode, so the session it was
-    // sharing degrades too. Stop reading and leave instead; the daemon is a
-    // separate process and keeps running either way.
-    process.on('SIGTTIN', teardown);
-    process.on('SIGTTOU', teardown);
+    // sharing degrades too. Stop reading and leave instead.
+    //
+    // Leaving is NOT exiting: under `ainode` the daemon IS this process, so what
+    // the screen does when it loses its terminal decides whether the node
+    // survives the night. onLeave settles that — see runDashboard.
+    process.on('SIGTTIN', () => teardown('SIGTTIN'));
+    process.on('SIGTTOU', () => teardown('SIGTTOU'));
     // The terminal went away without the read failing first.
-    process.on('SIGHUP', teardown);
+    process.on('SIGHUP', () => teardown('SIGHUP'));
+    // An async write to a dead terminal surfaces as an 'error' event, and an
+    // 'error' with no listener is a throw. Same reasoning as the write guard.
+    process.stdout.on('error', () => { });
+    // Same for stdin, which keeps its listener past detachInput's removal so a
+    // late EIO on a torn-down terminal has somewhere to land.
+    process.stdin.on('error', () => { });
     app.replace(build(app, suspend));
     return {
         host: app,
@@ -205,6 +252,9 @@ function createConsole(build, hooks = {}) {
         },
     };
 }
+/** How long a deliberate quit waits for the daemon to drain before it stops
+ *  being a courtesy and starts being a hung terminal. */
+const QUIT_DRAIN_CEILING_MS = 20_000;
 async function runDashboard(opts) {
     const pairing = (0, store_1.readPairing)();
     const data = (0, data_1.createDataLayer)({ token: pairing?.daemonToken ?? '' });
@@ -240,11 +290,38 @@ async function runDashboard(opts) {
             })),
         });
     }, {
-        onTeardown: () => {
+        // The screen and the daemon used to share one fate: every teardown ended
+        // in process.exit(0), so a terminal that went away overnight — SIGHUP from
+        // a closed window, an ssh drop, a stray background read — took the node
+        // down with it and left it dead until someone re-ran `ainode` in the
+        // morning. Losing a screen is not a reason to stop working.
+        onLeave: (reason) => {
+            const stop = opts.stop;
+            const action = leaveAction(reason, !opts.viewerMode && Boolean(stop));
+            if (action === 'detach') {
+                // The terminal is gone, the daemon is not. Keep capturing rather than
+                // restoring: the real console writes to an fd that no longer exists,
+                // whereas the capture keeps appending to the daemon log — which is now
+                // the only place anyone can watch this node from.
+                console.log(`[tui] terminal gone (${reason}) — dashboard closed; the node is still running (pid ${process.pid})`);
+                console.log(`[tui] follow it with: tail -f ${paths_1.RUNTIME_LOG_FILE}`);
+                return;
+            }
             logs.restore();
             if (logs.count()) {
                 console.log(`${logs.count()} daemon log lines this session — ${paths_1.RUNTIME_LOG_FILE}`);
             }
+            if (action === 'exit' || !stop) {
+                process.exit(0);
+                return;
+            }
+            // Asked for, so drain properly: in-flight turns get to post their final
+            // status and the server is told we are going, rather than discovering it
+            // 90s later through a missed heartbeat. The ceiling is there because a
+            // wedged drain must not become a terminal that never comes back.
+            console.log('stopping the node…');
+            setTimeout(() => process.exit(0), QUIT_DRAIN_CEILING_MS).unref?.();
+            void stop().finally(() => process.exit(0));
         },
     });
     // The daemon's own numbers don't come from an RPC.

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "@addai/node",
-  "version": "0.30.9",
-  "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": [
-    "addai",
-    "entity-studio",
-    "claude",
-    "codex",
-    "kimi",
-    "gemini",
-    "agent",
-    "daemon",
-    "supabase",
-    "mcp"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
-  },
-  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
-  "bugs": {
-    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
-  },
-  "type": "commonjs",
-  "main": "dist/index.js",
-  "bin": {
-    "ainode": "dist/cli.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "assets"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
-    "start": "node dist/cli.js",
-    "dev": "tsc -p tsconfig.json && node dist/cli.js",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
-    "postinstall": "node scripts/fix-pty-helper.js",
-    "prepublishOnly": "npm run build"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@addai/node-flows": "^1.0.0",
-    "node-pty": "^1.1.0",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.6.0"
-  }
-}
+{
+  "name": "@addai/node",
+  "version": "0.30.10",
+  "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": [
+    "addai",
+    "entity-studio",
+    "claude",
+    "codex",
+    "kimi",
+    "gemini",
+    "agent",
+    "daemon",
+    "supabase",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
+  },
+  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "ainode": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
+    "start": "node dist/cli.js",
+    "dev": "tsc -p tsconfig.json && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "postinstall": "node scripts/fix-pty-helper.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@addai/node-flows": "^1.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.0"
+  }
+}