@addai/node 0.11.0 → 0.11.2

package/dist/cli.js

@@ -54,6 +54,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const lockfile_1 = require("./lockfile");
 const index_1 = require("./index");
+const pair_destination_1 = require("./pair-destination");
 const store_1 = require("./store");
 const unpair_1 = require("./unpair");
 const run_1 = require("./tui/run");
@@ -140,6 +141,15 @@ async function main() {
             stdinTTY: Boolean(process.stdin.isTTY),
             noTui: process.env.AINODE_NO_TUI === '1',
         });
+        // A code on the command line is an instruction to pair THIS machine.
+        // Anything that quietly does something else instead is worse than an
+        // error, so deal with it before the attach-to-a-running-daemon path below.
+        const given = (0, pair_destination_1.pairCodeFromArgv)(args);
+        if (given && (0, store_1.isPaired)()) {
+            console.log('This machine is already paired to +Ai — the code is not needed.');
+            console.log('Run `ainode unpair --yes` first if you want to pair it somewhere else.');
+            return;
+        }
         // A daemon may already own this node. Rather than refusing, attach
         // read-only so "is it running?" is answerable from any terminal.
         //
@@ -148,8 +158,14 @@ async function main() {
         // later `ainode` into the viewer and returned before start() — so a node
         // could never come back from a crash without someone deleting the file
         // by hand. Same liveness check acquireLockfile() uses.
+        //
+        // And only when there is something to watch. Attaching to a daemon that
+        // is NOT paired makes `ainode` a closed loop: the screen it shows says
+        // "run `ainode` to pair again", and running it lands straight back here.
+        // A machine in that state — a daemon left over from before an unpair —
+        // could never be paired again from its own terminal.
         const existing = (0, lockfile_1.readLockfile)();
-        if ((0, lockfile_1.lockfileAlive)(existing) && existing && tui) {
+        if (!given && (0, store_1.isPaired)() && (0, lockfile_1.lockfileAlive)(existing) && existing && tui) {
             await (0, run_1.runDashboard)({
                 viewerMode: true,
                 pid: existing.pid,
@@ -158,7 +174,24 @@ async function main() {
             });
             return;
         }
-        const runtime = await (0, index_1.start)(args);
+        let runtime;
+        try {
+            runtime = await (0, index_1.start)(args);
+        }
+        catch (err) {
+            const msg = err?.message ?? String(err);
+            if (/already running/.test(msg)) {
+                // Reached when another process holds the lock — commonly one left
+                // over from before an unpair. Naming the pid is the difference
+                // between a dead end and a ten-second fix.
+                console.error(msg);
+                const pid = /pid (\d+)/.exec(msg)?.[1];
+                // A pid is a diagnosis; a command is a fix.
+                console.error(pid ? `Stop it with \`kill ${pid}\`, then run this again.` : 'Stop it, then run this again.');
+                process.exit(1);
+            }
+            throw err;
+        }
         if (!tui) {
             console.log(`ainode v${index_1.VERSION} running (pid ${runtime.pid}, port ${runtime.port})`);
             await new Promise(() => { });

package/dist/tui/data.js

@@ -15,8 +15,19 @@ function createDataLayer(deps) {
     const inflight = new Map();
     let lastError = null;
     let offline = false;
+    /* One failed call is not an outage.
+       RPCs time out at 4s, which a laptop on a busy connection exceeds now and
+       then without anything being wrong — the request pump already treats a
+       single failure as noise and logs "recovered after 1 consecutive failures".
+       The dashboard did not: one blip flipped it to "Offline · retrying" and it
+       stayed there until the next success, so the screen contradicted itself,
+       reporting the node Online in the header and offline directly underneath.
+       Two in a row is a signal; one is weather. */
+    let consecutiveFailures = 0;
+    const OFFLINE_AFTER = 2;
     async function fetch(key, name, args) {
         if (breakerOpen()) {
+            // The breaker only opens after repeated failures, so this one is real.
             offline = true;
             return cache.get(key) ?? null;
         }
@@ -27,12 +38,15 @@ function createDataLayer(deps) {
             try {
                 const res = await call(name, { p_token: deps.token, ...args });
                 cache.set(key, res);
+                consecutiveFailures = 0;
                 offline = false;
                 lastError = null;
                 return res;
             }
             catch (err) {
-                offline = true;
+                consecutiveFailures += 1;
+                if (consecutiveFailures >= OFFLINE_AFTER)
+                    offline = true;
                 lastError = err.message;
                 return cache.get(key) ?? null;
             }

package/package.json

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