@addai/node 0.8.2 → 0.10.0

package/dist/open-browser.js

@@ -0,0 +1,42 @@
+"use strict";
+// Open a URL in whatever the user calls their browser.
+//
+// No dependency for this. The three commands are stable, and a package that
+// shells out for you is a package that can break pairing on a platform we
+// cannot test from here.
+//
+// Windows deliberately does NOT go through cmd.exe. `start` is a shell
+// builtin, so reaching it means spawning a shell around a URL, and this
+// codebase has already been burned by putting cmd.exe near strings it did not
+// control. rundll32 takes the URL as a plain argument and hands it to the
+// registered handler.
+//
+// Everything here is best-effort by design. A browser that fails to open is
+// not a failed pairing — the terminal still shows the code and the link, and
+// the user carries on by hand. So this never throws and never blocks: it
+// reports whether the launch was ACCEPTED, which is all the caller can
+// honestly say.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = openBrowser;
+const child_process_1 = require("child_process");
+function openBrowser(url, platform = process.platform) {
+    const [cmd, args] = platform === 'darwin' ? ['open', [url]]
+        : platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+            : ['xdg-open', [url]];
+    try {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            stdio: 'ignore',
+            // The browser outlives us — and on a machine where the daemon is about
+            // to take over the terminal, a child holding the TTY would fight it.
+            detached: true,
+        });
+        // A missing xdg-open surfaces here rather than as an unhandled error that
+        // takes the daemon down with it.
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/pair-destination.d.ts

@@ -0,0 +1,20 @@
+export interface PairDestination {
+    /** What to call it on screen. */
+    product: string;
+    /** Where the user goes to confirm. */
+    url: string;
+    /** That URL carrying the code, which is what actually gets opened. */
+    link(code: string): string;
+}
+/**
+ * @param argv process.argv.slice(2)
+ * @param env  process.env
+ */
+export declare function pairDestination(argv: string[], env?: NodeJS.ProcessEnv): PairDestination;
+export interface BrowserEnv {
+    isTTY: boolean;
+    platform: NodeJS.Platform | string;
+    env: NodeJS.ProcessEnv;
+}
+/** Would opening a browser here actually show the user anything? */
+export declare function canOpenBrowser({ isTTY, platform, env }: BrowserEnv): boolean;

package/dist/pair-destination.js

@@ -0,0 +1,59 @@
+"use strict";
+// Which product this machine is joining, and whether we can open a browser
+// to finish the job.
+//
+// The command the user ran is the answer to the first question. They copied it
+// off a page that already knew — so asking "which product?" in the terminal
+// would be asking them to repeat themselves. `ainode entities` goes to Entity
+// Studio; everything else keeps going to Vault, exactly as it always has.
+//
+// The second question is the one that decides whether pairing feels like
+// magic or like a broken promise. Opening a browser on a machine nobody is
+// sitting at does nothing; opening one over SSH opens it on the wrong
+// computer entirely. Both are common, so both are checked, and when the
+// answer is no the code gets printed like it always did.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pairDestination = pairDestination;
+exports.canOpenBrowser = canOpenBrowser;
+const config_1 = require("./config");
+const destination = (product, url) => ({
+    product,
+    url,
+    link: (code) => `${url}/${encodeURIComponent(code)}`,
+});
+/**
+ * @param argv process.argv.slice(2)
+ * @param env  process.env
+ */
+function pairDestination(argv, env = process.env) {
+    const entities = argv[0] === 'entities';
+    // A dev override has to move BOTH products or a local Studio ends up
+    // pairing against production Vault, which is a confusing way to lose an
+    // afternoon.
+    const base = env.AINODE_PAIR_BASE?.replace(/\/+$/, '');
+    if (base) {
+        return entities
+            ? destination('+Ai Entities', `${base}/connect`)
+            : destination('+Ai Vault', `${base}/add/entity`);
+    }
+    return entities
+        ? destination('+Ai Entities', config_1.ENTITIES_PAIR_URL)
+        : destination('+Ai Vault', config_1.VAULT_PAIR_URL);
+}
+/** Would opening a browser here actually show the user anything? */
+function canOpenBrowser({ isTTY, platform, env }) {
+    if (!isTTY)
+        return false;
+    if (env.AINODE_NO_BROWSER === '1')
+        return false;
+    // Over SSH the browser would open on the machine being administered, where
+    // nobody is looking at it — and the terminal would sit there claiming it
+    // had done something helpful.
+    if (env.SSH_TTY || env.SSH_CONNECTION)
+        return false;
+    // A Linux box with no display server has no browser to open. macOS and
+    // Windows always have one.
+    if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    return true;
+}

package/dist/pairing.d.ts

@@ -14,7 +14,9 @@ export declare function requestPairCode(): Promise<string>;
  */
 export declare function awaitPairing(code: string): Promise<FinalizeResult>;
 /**
- * Print the human-facing instructions for a fresh pairing.
+ * Run the whole first-run flow: ask, open, wait, save.
+ *
+ * @param argv process.argv.slice(2) — decides which product to join
  */
-export declare function printPairingInstructions(code: string): void;
+export declare function runPairing(argv: string[]): Promise<FinalizeResult>;
 export {};

package/dist/pairing.js

@@ -1,7 +1,15 @@
 "use strict";
-// First-run pairing flow. Called when state.json doesn't exist. Walks the
-// user through obtaining a 5-letter code and entering it at
-// vault.add.ai/add/entity. Once finalized, persists the daemon_token.
+// First-run pairing flow. Called when state.json doesn't exist.
+//
+// The machine now does the walking. It asks one question, opens the user's
+// browser at the confirm page carrying its own code, and waits — so the
+// person types nothing and never has to know a code existed. Where that
+// cannot work (no terminal, over SSH, headless Linux) it prints the code and
+// the link exactly as it always did, because those machines are real and are
+// often the ones that most need a node on them.
+//
+// Which product the browser lands on comes from the command the user ran:
+// `ainode entities` goes to Entity Studio, everything else to Vault.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -38,10 +46,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestPairCode = requestPairCode;
 exports.awaitPairing = awaitPairing;
-exports.printPairingInstructions = printPairingInstructions;
+exports.runPairing = runPairing;
 const os = __importStar(require("os"));
 const supabase_client_1 = require("./supabase-client");
 const store_1 = require("./store");
+const pair_destination_1 = require("./pair-destination");
+const open_browser_1 = require("./open-browser");
+const pair_1 = require("./tui/pair");
 const config_1 = require("./config");
 function platform() {
     const p = process.platform;
@@ -113,17 +124,54 @@ async function awaitPairing(code) {
     throw new Error('pair_timeout');
 }
 /**
- * Print the human-facing instructions for a fresh pairing.
+ * Run the whole first-run flow: ask, open, wait, save.
+ *
+ * @param argv process.argv.slice(2) — decides which product to join
  */
-function printPairingInstructions(code) {
-    console.log('');
-    console.log('  ── Setup needed ──');
-    console.log('');
-    console.log(`  1. Open  ${config_1.VAULT_PAIR_URL}`);
-    console.log(`  2. Enter this code:  ${code}`);
-    console.log('');
-    console.log(`  (or click:  ${config_1.VAULT_PAIR_URL}/${code})`);
-    console.log('');
-    console.log('  Waiting for pairing… (expires in 15 minutes)');
-    console.log('');
+async function runPairing(argv) {
+    const dest = (0, pair_destination_1.pairDestination)(argv);
+    const hostname = os.hostname();
+    const interactive = (0, pair_destination_1.canOpenBrowser)({
+        isTTY: Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY),
+        platform: process.platform,
+        env: process.env,
+    });
+    // Ask BEFORE minting a code. A code starts a 15-minute clock the moment it
+    // exists, and someone who walks away at the question should not come back
+    // to an expired one.
+    const choice = interactive ? await (0, pair_1.promptConnect)({ product: dest.product, hostname }) : 'manual';
+    const code = await requestPairCode();
+    const link = dest.link(code);
+    const opened = choice === 'open' ? (0, open_browser_1.openBrowser)(link) : false;
+    let waiting = null;
+    if (interactive) {
+        waiting = (0, pair_1.renderWaiting)({ product: dest.product, link, code, opened });
+    }
+    else {
+        // Headless: plain lines, no spinner, no cursor games. This output ends up
+        // in a log file as often as on a screen.
+        console.log('');
+        console.log(`  Connect this machine to ${dest.product}`);
+        console.log('');
+        console.log(`  1. Open  ${dest.url}`);
+        console.log(`  2. Enter this code:  ${code}`);
+        console.log('');
+        console.log(`  (or open directly:  ${link})`);
+        console.log('');
+        console.log('  Waiting for pairing… (expires in 15 minutes)');
+        console.log('');
+    }
+    try {
+        const result = await awaitPairing(code);
+        waiting?.stop();
+        if (interactive)
+            (0, pair_1.renderConnected)(hostname);
+        else
+            console.log(`  ✓ Connected as ${hostname}`);
+        return result;
+    }
+    catch (err) {
+        waiting?.stop();
+        throw err;
+    }
 }

package/dist/request-pump.d.ts

@@ -1,4 +1,5 @@
 export declare function inflightCount(): number;
+export declare function activeRequestIdList(): string[];
 export declare function start(): void;
 export declare function stop(): void;
 /**

package/dist/request-pump.js

@@ -5,6 +5,7 @@
 // arrives.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inflightCount = inflightCount;
+exports.activeRequestIdList = activeRequestIdList;
 exports.start = start;
 exports.stop = stop;
 exports.drain = drain;
@@ -59,6 +60,14 @@ let lastHealthBlockAt = 0;
 // Exported so /stats can surface "pump stuck at N inflight" without
 // having to guess.
 function inflightCount() { return inflight; }
+// The runs this daemon is holding a child process for, right now. This is the
+// only honest answer to "is that run alive?" — the server used to infer it from
+// how recently the agent emitted an event, which measures how chatty the agent
+// is, not whether it is alive. A grok turn routinely goes ten minutes between
+// its last streamed token and turn_complete, and the server was failing those
+// runs mid-flight and apologising to the user for a reply that had already
+// arrived. Reported every 30s by the heartbeat.
+function activeRequestIdList() { return [...activeRequestIds]; }
 async function tick() {
     if (stopped)
         return;

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/tui/pair.d.ts

@@ -0,0 +1,33 @@
+export type PairChoice = 'open' | 'manual';
+interface PromptOpts {
+    /** '+Ai Entities' — what the user thinks they are joining. */
+    product: string;
+    hostname: string;
+}
+/**
+ * Ask whether to open the browser. Resolves the user's answer; never rejects.
+ *
+ * Ctrl-C here means "I did not want to do this at all", so it exits rather
+ * than falling through to a code the user never asked for.
+ */
+export declare function promptConnect({ product, hostname }: PromptOpts): Promise<PairChoice>;
+export interface WaitingHandle {
+    /** Stop the spinner and leave the block on screen. */
+    stop(): void;
+}
+/**
+ * The block that stays up while the daemon waits to be claimed.
+ *
+ * It shows the code and the link even when the browser opened fine. That is
+ * not clutter — a browser that opened on the wrong profile, or behind another
+ * window, is invisible from here, and the only recovery is the thing this
+ * block is holding.
+ */
+export declare function renderWaiting(opts: {
+    product: string;
+    link: string;
+    code: string;
+    opened: boolean;
+}): WaitingHandle;
+export declare function renderConnected(name: string): void;
+export {};

package/dist/tui/pair.js

@@ -0,0 +1,178 @@
+"use strict";
+// The first thing anyone sees: one question, then the browser opens.
+//
+// This is not a screen on the console stack, and deliberately so. That stack
+// owns the alt screen and exits the process when it quits — both wrong here.
+// Pairing has to hand back to a daemon that then runs for months, and the code
+// and link have to stay in scrollback afterwards, because the most likely
+// reason someone is still reading this block is that the browser didn't open.
+//
+// So: no alt screen, no takeover. A question that repaints in place, then a
+// block that stays on the terminal and a spinner line that updates until the
+// machine is through.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptConnect = promptConnect;
+exports.renderWaiting = renderWaiting;
+exports.renderConnected = renderConnected;
+const readline = __importStar(require("readline"));
+const render_1 = require("./render");
+const E = '\x1b[';
+const write = (s) => { process.stdout.write(s); };
+/** Move up n lines and clear from there down — how a block repaints in place. */
+const rewind = (n) => { if (n > 0)
+    write(`${E}${n}A${E}0J`); };
+const CHOICES = [
+    { id: 'open', label: 'Yes, open my browser' },
+    { id: 'manual', label: 'No, show me a code instead' },
+];
+/**
+ * Ask whether to open the browser. Resolves the user's answer; never rejects.
+ *
+ * Ctrl-C here means "I did not want to do this at all", so it exits rather
+ * than falling through to a code the user never asked for.
+ */
+function promptConnect({ product, hostname }) {
+    return new Promise(resolve => {
+        let sel = 0;
+        let painted = 0;
+        const frame = () => [
+            '',
+            `  ${(0, render_1.bold)((0, render_1.cyan)('✦'))} ${(0, render_1.bold)('+Ai Node')}`,
+            '',
+            `  Connect ${(0, render_1.bold)(hostname)} to ${(0, render_1.bold)(product)}?`,
+            '',
+            ...CHOICES.map((c, i) => i === sel ? `  ${(0, render_1.green)('▸')} ${c.label}` : `    ${(0, render_1.grey)(c.label)}`),
+            '',
+            `  ${(0, render_1.dim)('↑↓ to choose · ⏎ to continue · ^C to cancel')}`,
+            '',
+        ];
+        const paint = () => {
+            rewind(painted);
+            const lines = frame();
+            write(lines.join('\n') + '\n');
+            painted = lines.length;
+        };
+        const done = (choice) => {
+            rewind(painted);
+            process.stdin.off('keypress', onKey);
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+            process.stdin.pause();
+            resolve(choice);
+        };
+        function onKey(_s, key) {
+            if (!key)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                rewind(painted);
+                write(`  ${(0, render_1.dim)('Cancelled. Run the command again when you are ready.')}\n\n`);
+                process.exit(130);
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                sel = (sel + CHOICES.length - 1) % CHOICES.length;
+                paint();
+            }
+            else if (key.name === 'down' || key.name === 'j') {
+                sel = (sel + 1) % CHOICES.length;
+                paint();
+            }
+            else if (key.name === 'y')
+                done('open');
+            else if (key.name === 'n')
+                done('manual');
+            else if (key.name === 'return' || key.name === 'space')
+                done(CHOICES[sel].id);
+        }
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('keypress', onKey);
+        paint();
+    });
+}
+/**
+ * The block that stays up while the daemon waits to be claimed.
+ *
+ * It shows the code and the link even when the browser opened fine. That is
+ * not clutter — a browser that opened on the wrong profile, or behind another
+ * window, is invisible from here, and the only recovery is the thing this
+ * block is holding.
+ */
+function renderWaiting(opts) {
+    const { product, link, code, opened } = opts;
+    write('\n');
+    if (opened) {
+        write(`  ${(0, render_1.green)('✦')} ${(0, render_1.bold)(`Waiting in your browser…`)}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('Nothing opened? Go to')}  ${(0, render_1.cyan)(link)}\n`);
+    }
+    else {
+        write(`  ${(0, render_1.bold)(`Connect this machine to ${product}`)}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('1.')} Open  ${(0, render_1.cyan)(link.replace(`/${code}`, ''))}\n`);
+        write(`  ${(0, render_1.dim)('2.')} Enter this code:  ${(0, render_1.bold)((0, render_1.green)(code))}\n`);
+        write('\n');
+        write(`  ${(0, render_1.dim)('or open this directly:')}  ${(0, render_1.cyan)(link)}\n`);
+    }
+    if (opened)
+        write(`  ${(0, render_1.dim)('or enter this code:')}  ${(0, render_1.bold)((0, render_1.green)(code))}\n`);
+    write('\n');
+    let n = 0;
+    let painted = false;
+    const line = () => `  ${(0, render_1.green)(render_1.SPIN[n % render_1.SPIN.length])} ${(0, render_1.dim)('waiting for you to confirm · expires in 15 minutes')}`;
+    const tick = () => {
+        if (painted)
+            rewind(1);
+        write(line() + '\n');
+        painted = true;
+        n++;
+    };
+    tick();
+    const timer = setInterval(tick, 120);
+    // A spinner is not a reason to keep the process alive.
+    timer.unref?.();
+    return {
+        stop() {
+            clearInterval(timer);
+            if (painted)
+                rewind(1);
+        },
+    };
+}
+function renderConnected(name) {
+    write(`  ${(0, render_1.green)('✓')} ${(0, render_1.bold)('Connected')} ${(0, render_1.dim)('as')} ${name}\n\n`);
+}

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>;