@addai/node 0.10.0 → 0.11.1

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
@@ -53,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");
@@ -139,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.
         //
@@ -147,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,
@@ -157,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(() => { });
@@ -194,6 +228,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

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/package.json

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