@addai/node 0.9.0 → 0.11.0

package/dist/cli.js

@@ -4,6 +4,7 @@
 //
 //   ainode                run this node: daemon + live dashboard
 //   ainode entities       the same, pairing into +Ai Entities rather than Vault
+//   ainode entities CODE  pair straight away with a code the page minted
 //   ainode harnesses      interactive harness manager (install / login)
 //   ainode startup …      start this node when the machine starts
 //   ainode unpair --yes   disconnect from +Ai, cancel in-flight work
@@ -54,7 +55,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const lockfile_1 = require("./lockfile");
 const index_1 = require("./index");
 const store_1 = require("./store");
-const supabase_client_1 = require("./supabase-client");
+const unpair_1 = require("./unpair");
 const run_1 = require("./tui/run");
 const autostart = __importStar(require("./autostart"));
 const args = process.argv.slice(2);
@@ -73,21 +74,16 @@ async function cmdUnpair() {
     }
     const confirm = args.includes('--yes') || args.includes('-y');
     if (!confirm) {
-        console.log('This will disconnect the runtime from +Ai and cancel any in-flight requests.');
+        console.log('This disconnects the node from +Ai and cancels any in-flight requests.');
+        console.log((0, unpair_1.describeDisconnect)(0));
         console.log('Re-run with --yes to confirm.');
         return;
     }
-    try {
-        const r = await (0, supabase_client_1.rpc)('runtime_self_unpair', { p_token: token() });
-        if (r?.cancelled_requests) {
-            console.log(`Cancelled ${r.cancelled_requests} in-flight request(s).`);
-        }
-    }
-    catch (err) {
-        console.error(`server unpair failed (continuing with local cleanup): ${err.message}`);
-    }
-    (0, store_1.clearPairing)();
-    console.log('Unpaired. Run `ainode` to pair again.');
+    const r = await (0, unpair_1.disconnectNode)();
+    console.log((0, unpair_1.summariseDisconnect)(r));
+    if (!r.ok)
+        process.exit(1);
+    console.log('Run `ainode` to pair again.');
 }
 function cmdStartup() {
     const sub = args[1] ?? 'status';
@@ -199,6 +195,7 @@ async function main() {
 usage:
   ainode                    run this +Ai Node — daemon + live dashboard
   ainode entities           the same, but pair into +Ai Entities
+  ainode entities <CODE>    pair with a code from the page — no browser
   ainode harnesses          install / log in agent harnesses (interactive)
   ainode startup enable     start this node whenever you log in
   ainode startup disable    stop starting at login
@@ -210,8 +207,8 @@ Piped or headless output falls back to plain log lines. Set AINODE_NO_TUI=1
 to force that on a terminal. \`ainode run --ensure\` starts a node only if one
 isn't already running — what the Windows startup task uses.
 
-Pair the node by running it with no args and following the prompt
-to vault.add.ai/entity/connect/<CODE>.
+Pairing opens your browser to confirm the machine; nothing to type. Over SSH
+or on a headless box it prints a code and a link instead.
 `);
             return;
     }

package/dist/pair-destination.d.ts

@@ -18,3 +18,13 @@ export interface BrowserEnv {
 }
 /** Would opening a browser here actually show the user anything? */
 export declare function canOpenBrowser({ isTTY, platform, env }: BrowserEnv): boolean;
+/**
+ * The pairing code someone pasted into the command, if there is one.
+ *
+ * `npx -y @addai/node@latest entities WXYZ4` is the flow where the page mints
+ * the code and the browser never opens. Everything else here — no argument, a
+ * flag, something that is not code-shaped — falls through to the normal flow.
+ * Refusing to guess matters: a mistyped code that we accepted anyway would
+ * sit in the finalize loop for fifteen minutes before admitting it.
+ */
+export declare function pairCodeFromArgv(argv: string[]): string | null;

package/dist/pair-destination.js

@@ -15,6 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pairDestination = pairDestination;
 exports.canOpenBrowser = canOpenBrowser;
+exports.pairCodeFromArgv = pairCodeFromArgv;
 const config_1 = require("./config");
 const destination = (product, url) => ({
     product,
@@ -57,3 +58,30 @@ function canOpenBrowser({ isTTY, platform, env }) {
         return false;
     return true;
 }
+/** Pairing codes are five characters of A–Z and 0–9. */
+const CODE_SHAPE = /^[A-Z0-9]{5}$/;
+/**
+ * The pairing code someone pasted into the command, if there is one.
+ *
+ * `npx -y @addai/node@latest entities WXYZ4` is the flow where the page mints
+ * the code and the browser never opens. Everything else here — no argument, a
+ * flag, something that is not code-shaped — falls through to the normal flow.
+ * Refusing to guess matters: a mistyped code that we accepted anyway would
+ * sit in the finalize loop for fifteen minutes before admitting it.
+ */
+function pairCodeFromArgv(argv) {
+    for (const raw of argv) {
+        if (raw.startsWith('-'))
+            continue;
+        // Skip the subcommand itself.
+        if (['entities', 'run', 'start'].includes(raw))
+            continue;
+        const cleaned = raw.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+        if (CODE_SHAPE.test(cleaned))
+            return cleaned;
+        // A non-flag argument that is not a code is a mistake, not a code we
+        // should keep hunting for behind it.
+        return null;
+    }
+    return null;
+}

package/dist/pairing.js

@@ -82,7 +82,11 @@ async function awaitPairing(code) {
     const deadline = Date.now() + config_1.PAIR_TIMEOUT_MS;
     while (Date.now() < deadline) {
         try {
-            const rows = await (0, supabase_client_1.rpc)('runtime_pair_finalize', { p_code: code });
+            const rows = await (0, supabase_client_1.rpc)('runtime_pair_finalize', 
+            // The machine is the authority on what it is called. A code minted by
+            // the browser carries no hostname, so without this every node paired
+            // from the page arrives called "Untitled runtime".
+            { p_code: code, p_hostname: os.hostname(), p_platform: platform() });
             // PostgREST returns a `setof record` as an array of objects.
             const row = Array.isArray(rows) ? rows[0] : rows;
             if (row?.daemon_token) {
@@ -131,6 +135,16 @@ async function awaitPairing(code) {
 async function runPairing(argv) {
     const dest = (0, pair_destination_1.pairDestination)(argv);
     const hostname = os.hostname();
+    // A code handed to us on the command line was minted by a page the user was
+    // already looking at, and claimed by them as it was made. There is nothing
+    // to ask and nobody to send anywhere: finalize it and get on with running.
+    const given = (0, pair_destination_1.pairCodeFromArgv)(argv);
+    if (given) {
+        process.stdout.write(`\n  Connecting ${hostname} to ${dest.product}…\n`);
+        const result = await awaitPairing(given);
+        process.stdout.write(`  ✓ Connected as ${hostname}\n\n`);
+        return result;
+    }
     const interactive = (0, pair_destination_1.canOpenBrowser)({
         isTTY: Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY),
         platform: process.platform,

package/dist/tui/dashboard.d.ts

@@ -22,6 +22,8 @@ export interface DashboardState {
     inflight: number;
     paired: boolean;
     viewerMode: boolean;
+    /** First press of 'd' asks; the second one does it. */
+    disconnectArmed?: boolean;
     offline: boolean;
     now: number;
     version: string;

package/dist/tui/dashboard.js

@@ -19,6 +19,8 @@ exports.createDashboardScreen = createDashboardScreen;
 const render_1 = require("./render");
 const request_row_1 = require("./request-row");
 const app_1 = require("./app");
+const unpair_1 = require("../unpair");
+const store_1 = require("../store");
 const autostart_1 = require("../autostart");
 /** The landing screen's menu. */
 exports.MENU = [
@@ -71,7 +73,7 @@ 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>'),
+            (0, render_1.dim)('run `ainode` to pair again — it opens your browser to finish up'),
         ];
     }
     const self = st.self;
@@ -174,7 +176,13 @@ function nowLines(st, width, rows) {
 function renderDashboard(st, width, height) {
     const head = (0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`@addai/node v${st.version}`)}`, headerLines(st), width);
     if (!st.paired) {
-        return [...head, '', (0, app_1.footerHint)([{ keys: 'q', label: 'quit' }])].slice(0, height);
+        // The note has to survive the transition into this screen. Disconnecting
+        // flips `paired` to false, and without this the sentence saying how it
+        // went — including "+Ai could not be told" — was rendered for a frame and
+        // then replaced by a screen that had no room for it. The outcome of the
+        // one destructive action in here must not be the thing you cannot read.
+        const note = st.autostartNote ? ['', `  ${st.autostartNote}`] : [];
+        return [...head, ...note, '', (0, app_1.footerHint)([{ keys: 'q', label: 'quit' }])].slice(0, height);
     }
     const stats = statsLines(st).map(l => `  ${l}`);
     // The shortcut letters line up in a column of their own, so the eye can
@@ -198,6 +206,10 @@ function renderDashboard(st, width, height) {
         { keys: '?', label: 'keys' },
         { keys: 'q', label: 'quit' },
     ]);
+    // 'd' is deliberately absent from this row. The footer is the set of things
+    // it is safe to press to find out what they do, and disconnect is not one
+    // of them; it lives in the `?` list, where you go when you are looking for
+    // something specific.
     // Everything but the NOW band is fixed height, so the band takes what is
     // left: heading + header row + rows + the "+N more" line.
     const fixed = head.length + 1 + stats.length + 1 + 3 + 1 + menu.length + 1 + 1;
@@ -277,6 +289,40 @@ function createDashboardScreen(deps) {
         // line — a note that never clears becomes furniture.
         setTimeout(() => { st.autostartNote = null; deps.host.redraw(); }, 8000).unref?.();
     };
+    /* ── disconnect ────────────────────────────────────────────────────────
+       The one key in here that takes work away from people, so it is armed
+       rather than instant: the first press asks, naming what it will cancel,
+       and the second does it. Any other key disarms, which means a stray 'd'
+       costs nothing.
+  
+       Afterwards the daemon has no token and cannot do anything useful, so the
+       console closes with it — except in viewer mode, where the daemon is a
+       different process this console does not own and can only report on. */
+    const disconnect = async () => {
+        if (!st.disconnectArmed) {
+            st.disconnectArmed = true;
+            st.autostartNote = `Disconnect this node? ${(0, unpair_1.describeDisconnect)(st.inflight)} Press d again to confirm.`;
+            deps.host.redraw();
+            return;
+        }
+        st.disconnectArmed = false;
+        st.autostartNote = 'Disconnecting…';
+        deps.host.redraw();
+        await new Promise(r => setTimeout(r, 0));
+        const r = await (0, unpair_1.disconnectNode)();
+        st.paired = (0, store_1.isPaired)();
+        st.autostartNote = (0, unpair_1.summariseDisconnect)(r);
+        deps.host.redraw();
+        if (!r.ok)
+            return;
+        if (st.viewerMode) {
+            st.autostartNote = `${(0, unpair_1.summariseDisconnect)(r)} The daemon (pid ${st.pid ?? '?'}) is still running — stop it to finish.`;
+            deps.host.redraw();
+            return;
+        }
+        // Let the sentence land before the screen goes away.
+        setTimeout(() => deps.host.quit(), 1600).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
@@ -337,6 +383,7 @@ function createDashboardScreen(deps) {
             { keys: 'l', label: 'logs — daemon output' },
             { keys: 's', label: 'start this node at login (on / off)' },
             { keys: 'r', label: 'refresh now' },
+            { keys: 'd', label: 'disconnect this node from +Ai' },
         ],
         async onKey(key) {
             if (key.name === 'up' || key.name === 'k') {
@@ -369,6 +416,17 @@ function createDashboardScreen(deps) {
                 await refresh();
                 return;
             }
+            if (key.name === 'd') {
+                await disconnect();
+                return;
+            }
+            // Anything else disarms a pending disconnect: an armed destructive
+            // action must not survive the user walking away and coming back.
+            if (st.disconnectArmed) {
+                st.disconnectArmed = false;
+                st.autostartNote = null;
+                deps.host.redraw();
+            }
             if (key.name === 'return') {
                 // A selected run wins over the menu: the cursor is visibly on it.
                 const live = selectableNow(st)[nowIndex(st)];

package/dist/unpair.d.ts

@@ -0,0 +1,20 @@
+export interface DisconnectResult {
+    ok: boolean;
+    cancelled: number;
+    /** The local pairing was cleared but +Ai was not told. */
+    serverFailed?: boolean;
+    error?: string;
+}
+/** The question to ask before doing it. */
+export declare function describeDisconnect(inflight: number): string;
+/** What to say once it is done. */
+export declare function summariseDisconnect(r: DisconnectResult): string;
+/**
+ * Tell +Ai, then forget the pairing locally.
+ *
+ * Local cleanup happens even when the server call fails. A node whose token
+ * the user has decided to abandon should not keep using it because the network
+ * was down at the wrong moment — and the alternative, refusing to disconnect,
+ * strands them on a machine they may be trying to hand back.
+ */
+export declare function disconnectNode(): Promise<DisconnectResult>;

package/dist/unpair.js

@@ -0,0 +1,71 @@
+"use strict";
+// Disconnecting a node from +Ai.
+//
+// Shared by `ainode unpair` and the console's disconnect key, because the two
+// must not drift: this is the one action that takes work away from people, and
+// a version of it that forgets to cancel in-flight runs would leave whoever
+// was waiting on them waiting forever.
+//
+// The server soft-disables rather than deletes: the runtime row, its history
+// and its chats all survive, the token is scrubbed, and the status becomes
+// 'unpaired'. Reconnect on the AiNodes page mints a fresh code and the same
+// machine comes back as itself. That is worth saying out loud in the prompt —
+// someone who believes this is permanent will not press it when they should.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeDisconnect = describeDisconnect;
+exports.summariseDisconnect = summariseDisconnect;
+exports.disconnectNode = disconnectNode;
+const supabase_client_1 = require("./supabase-client");
+const store_1 = require("./store");
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+/** The question to ask before doing it. */
+function describeDisconnect(inflight) {
+    const cost = inflight > 0
+        ? `This cancels ${plural(inflight, 'run')} still in flight. `
+        : '';
+    return `${cost}The node keeps its history and can reconnect later.`;
+}
+/** What to say once it is done. */
+function summariseDisconnect(r) {
+    if (!r.ok)
+        return `Could not disconnect: ${r.error ?? 'unknown error'}`;
+    if (r.serverFailed) {
+        // Honest about the half that worked: this machine has forgotten its
+        // pairing, but +Ai still lists the node as paired until it is removed
+        // there. Saying only "disconnected" leaves that to be discovered — and
+        // saying it without the reason leaves nobody able to act on it, which is
+        // how a transient 4s RPC timeout and a revoked grant look identical.
+        const why = r.error ? ` (${r.error})` : '';
+        return `Disconnected on this machine, but +Ai could not be told${why}. Remove the node there too.`;
+    }
+    const tail = r.cancelled > 0 ? ` ${plural(r.cancelled, 'run')} cancelled.` : '';
+    return `Disconnected from +Ai.${tail}`;
+}
+/**
+ * Tell +Ai, then forget the pairing locally.
+ *
+ * Local cleanup happens even when the server call fails. A node whose token
+ * the user has decided to abandon should not keep using it because the network
+ * was down at the wrong moment — and the alternative, refusing to disconnect,
+ * strands them on a machine they may be trying to hand back.
+ */
+async function disconnectNode() {
+    if (!(0, store_1.isPaired)())
+        return { ok: false, cancelled: 0, error: 'this node is not paired' };
+    const token = (0, store_1.readPairing)()?.daemonToken;
+    if (!token)
+        return { ok: false, cancelled: 0, error: 'this node is not paired' };
+    let cancelled = 0;
+    let serverFailed = false;
+    let serverError;
+    try {
+        const r = await (0, supabase_client_1.rpc)('runtime_self_unpair', { p_token: token });
+        cancelled = r?.cancelled_requests ?? 0;
+    }
+    catch (err) {
+        serverFailed = true;
+        serverError = err?.message || String(err);
+    }
+    (0, store_1.clearPairing)();
+    return { ok: true, cancelled, serverFailed, error: serverError };
+}

package/package.json

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