@addai/node 0.5.1 → 0.6.0

package/dist/cli.js

@@ -4,6 +4,7 @@
 //
 //   ainode                run this node: daemon + live dashboard
 //   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
 //   ainode version        print version
 //
@@ -15,12 +16,46 @@
 //
 // Unpair reaches Supabase via the daemon token in ~/.ainode/state.json and
 // does not require the daemon to be running.
+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 });
 const lockfile_1 = require("./lockfile");
 const index_1 = require("./index");
 const store_1 = require("./store");
 const supabase_client_1 = require("./supabase-client");
 const run_1 = require("./tui/run");
+const autostart = __importStar(require("./autostart"));
 const args = process.argv.slice(2);
 function token() {
     const p = (0, store_1.readPairing)();
@@ -53,9 +88,53 @@ async function cmdUnpair() {
     (0, store_1.clearPairing)();
     console.log('Unpaired. Run `ainode` to pair again.');
 }
+function cmdStartup() {
+    const sub = args[1] ?? 'status';
+    if (sub === 'status') {
+        console.log(autostart.describeStatus(autostart.status()));
+        return;
+    }
+    if (sub === 'enable') {
+        const r = autostart.enable({ force: args.includes('--force') });
+        if (!r.ok) {
+            console.error(r.error ?? 'could not enable startup');
+            process.exit(1);
+        }
+        for (const w of r.warnings)
+            console.log(`  note: ${w}`);
+        console.log('This node now starts when you log in.');
+        if (r.path)
+            console.log(`  definition: ${r.path}`);
+        return;
+    }
+    if (sub === 'disable') {
+        const before = autostart.status();
+        const r = autostart.disable();
+        if (!r.ok) {
+            console.error(r.error ?? 'could not disable startup');
+            process.exit(1);
+        }
+        console.log('This node no longer starts at login.');
+        // launchd's bootout stops the job it was supervising, so the node just
+        // went offline. Saying so beats letting the user discover it later.
+        if (before.supervisor === 'launchd' && before.enabled) {
+            console.log('  the supervised node was stopped — run `ainode` to bring it back');
+        }
+        return;
+    }
+    console.error(`unknown startup command: ${sub}`);
+    console.error('try: ainode startup enable | disable | status');
+    process.exit(2);
+}
 async function main() {
     const cmd = args[0];
     if (!cmd || cmd === 'run' || cmd === 'start' || cmd === '--run') {
+        // `--ensure` means "make sure a node is running here, then get out of the
+        // way". Windows' startup task repeats every five minutes to catch a
+        // crashed daemon; without this it would stack a second one every time.
+        if (args.includes('--ensure') && (0, lockfile_1.lockfileAlive)((0, lockfile_1.readLockfile)())) {
+            return;
+        }
         const tui = (0, run_1.shouldRenderTui)({
             isTTY: Boolean(process.stdout.isTTY),
             stdinTTY: Boolean(process.stdin.isTTY),
@@ -99,6 +178,9 @@ async function main() {
         case 'harnesses':
             await (0, run_1.runHarnessesTui)();
             return;
+        case 'startup':
+            cmdStartup();
+            return;
         case 'unpair':
             await cmdUnpair();
             return;
@@ -115,11 +197,15 @@ async function main() {
 usage:
   ainode                    run this +Ai Node — daemon + live dashboard
   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
+  ainode startup status     where the startup entry is and what it runs
   ainode unpair --yes       disconnect from +Ai
   ainode version            print version
 
 Piped or headless output falls back to plain log lines. Set AINODE_NO_TUI=1
-to force that on a terminal.
+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>.

package/dist/command-runner.js

@@ -56,6 +56,7 @@ const heartbeat_1 = require("./heartbeat");
 const win_1 = require("./win");
 const harness_registry_1 = require("./harness-registry");
 const self_update_1 = require("./self-update");
+const autostart_1 = require("./autostart");
 const paths_1 = require("./paths");
 const pty_helper_1 = require("./pty-helper");
 const COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
@@ -505,6 +506,38 @@ async function runUpdateRuntime(cmd) {
         await update(cmd.id, 'failed', { mode }, `restart failed: ${err.message}`);
     }
 }
+/* ── set_autostart ───────────────────────────────────────────────────────
+ * Arm (or disarm) "start when the machine starts" on a node you are not
+ * sitting at. Unlike a roll, this one CAN honestly report its own outcome:
+ * nothing restarts, so the process that did the work is still here to say
+ * what happened — and it reports the state it actually READ BACK afterwards,
+ * not the state it intended.
+ *
+ * Enabling under launchd hands the node over: a daemon started by hand is
+ * asked to drain and stop so launchd can own it. That means this command can
+ * legitimately stop and restart the daemon underneath the caller. It does not
+ * restart THIS process, so the reporting contract still holds. */
+async function runSetAutostart(cmd) {
+    const want = cmd.input?.enabled !== false;
+    await update(cmd.id, 'running', { step: want ? 'enabling' : 'disabling' });
+    if (want) {
+        const r = (0, autostart_1.enable)({ force: cmd.input?.force === true });
+        const state = (0, autostart_1.status)();
+        if (!r.ok) {
+            await update(cmd.id, 'failed', { autostart: state }, r.error ?? 'could not enable startup');
+            return;
+        }
+        await update(cmd.id, 'completed', { autostart: state, path: r.path, warnings: r.warnings });
+        return;
+    }
+    const r = (0, autostart_1.disable)();
+    const state = (0, autostart_1.status)();
+    if (!r.ok) {
+        await update(cmd.id, 'failed', { autostart: state }, r.error ?? 'could not disable startup');
+        return;
+    }
+    await update(cmd.id, 'completed', { autostart: state });
+}
 /* ── dispatcher ──────────────────────────────────────────────────────── */
 async function execute(cmd) {
     // Not a harness command — dispatch before the harness lookup, which would
@@ -513,6 +546,10 @@ async function execute(cmd) {
         await runUpdateRuntime(cmd);
         return;
     }
+    if (cmd.kind === 'set_autostart') {
+        await runSetAutostart(cmd);
+        return;
+    }
     const spec = (0, harness_registry_1.harness)(cmd.harness ?? '');
     if (!spec) {
         await update(cmd.id, 'failed', {}, `unknown harness: ${cmd.harness}`);

package/dist/index.js

@@ -49,6 +49,7 @@ const pairing_1 = require("./pairing");
 const heartbeat_1 = require("./heartbeat");
 const command_runner_1 = require("./command-runner");
 const self_update_1 = require("./self-update");
+const autostart_1 = require("./autostart");
 const sleep_detector_1 = require("./sleep-detector");
 const claude_config_1 = require("./claude-config");
 const request_pump_1 = require("./request-pump");
@@ -236,13 +237,21 @@ async function start() {
         (0, lockfile_1.releaseLockfile)();
     };
     // Remote roll: drain like a clean shutdown, install the target version if
-    // this launch mode can, then hand over to a detached replacement. The
-    // handoff file is written only AFTER the replacement is spawned, so a
-    // failure anywhere before that leaves this daemon running and the command
-    // is failed by the caller instead of silently taking the node down.
+    // this launch mode can, then hand over to a replacement. The handoff file is
+    // written only AFTER the replacement is arranged, so a failure anywhere
+    // before that leaves this daemon running and the command is failed by the
+    // caller instead of silently taking the node down.
+    //
+    // WHO starts the replacement depends on whether anything is supervising us.
+    // Historically nothing was, so this spawned a detached child of its own. On
+    // a node with `ainode startup enable` under launchd that would be a second
+    // daemon for one node — the failure the lockfile-identity fix was about. So
+    // when launchd is holding us up, the roll simply STANDS DOWN and lets
+    // KeepAlive do the starting.
     (0, command_runner_1.setRestartHook)(async ({ commandId, version }) => {
         const mode = (0, self_update_1.detectLaunchMode)(process.argv[1] ?? '');
         const plan = (0, self_update_1.planRespawn)(mode, process.argv[1] ?? '', version, process.execPath, process.argv.slice(2));
+        const supervised = (0, autostart_1.isSupervised)();
         if (plan.installFirst) {
             const err = await (0, self_update_1.installGlobal)(version);
             if (err)
@@ -251,11 +260,13 @@ async function start() {
         // Drain generously — a restart is elective, so it should never guillotine
         // a live entity turn the way a 15s SIGTERM drain would.
         await stop(RESTART_DRAIN_MS);
-        // Point of no return. Past this line a replacement daemon exists, so we
-        // MUST exit — two live daemons on one node is worse than a command left
-        // unreported. Hence the handoff write (which only affects reporting) can
-        // never abort the exit.
-        (0, self_update_1.spawnReplacement)(plan, path.join(paths_1.RUNTIME_HOME, 'daemon.log'), process.cwd());
+        // Point of no return. Past this line a replacement daemon either exists or
+        // is guaranteed by the supervisor, so we MUST exit — two live daemons on
+        // one node is worse than a command left unreported. Hence the handoff
+        // write (which only affects reporting) can never abort the exit.
+        if (!supervised) {
+            (0, self_update_1.spawnReplacement)(plan, path.join(paths_1.RUNTIME_HOME, 'daemon.log'), process.cwd());
+        }
         try {
             (0, self_update_1.writeHandoff)(paths_1.RUNTIME_HOME, {
                 command_id: commandId,
@@ -270,7 +281,9 @@ async function start() {
         catch (err) {
             console.error('[restart] handoff write failed — the roll still happened, it just cannot self-report:', err.message);
         }
-        console.log(`[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
+        console.log(supervised
+            ? `[restart] standing down for launchd to restart us (${mode} → ${version}); exiting`
+            : `[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
         setTimeout(() => process.exit(0), 250).unref?.();
     });
     process.once('SIGINT', () => { stop().finally(() => process.exit(0)); });

package/dist/tui/dashboard.d.ts

@@ -1,5 +1,6 @@
 import { type AppHost, type Screen } from './app';
 import type { DataLayer, NodeSelf, NodeStats, RequestRow } from './data';
+import { type AutostartState } from '../autostart';
 export interface DashboardState {
     self: NodeSelf | null;
     stats: NodeStats | null;
@@ -18,6 +19,11 @@ export interface DashboardState {
     version: string;
     /** How many daemon log lines have been captured this session. */
     logCount: number;
+    /** Does this node come back after a reboot? Null until first read. */
+    autostart: AutostartState | null;
+    /** Set while a toggle is in flight, and to whatever it had to say after —
+     *  enabling can stop and restart the daemon, which deserves a sentence. */
+    autostartNote: string | null;
 }
 /** The landing screen's menu. */
 export declare const MENU: Array<{
@@ -38,6 +44,14 @@ export declare function liveRequests(rows: RequestRow[]): RequestRow[];
  * second of every session claimed the node was in an unknown state.
  */
 export declare function stateLabel(st: DashboardState): string;
+/**
+ * Whether the box comes back on its own.
+ *
+ * On the header, not buried in a menu: "will this node survive a reboot" is a
+ * property of the node in the same way "is it online" is, and the answer was
+ * previously knowable only by reading the docs and looking for a plist.
+ */
+export declare function autostartLine(st: DashboardState): string;
 /** 1204 reads as a year; 1,204 reads as a count. */
 export declare function fmtCount(n: number | null | undefined): string;
 export declare function nowLines(st: DashboardState, width: number, rows: number): string[];

package/dist/tui/dashboard.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_NOW_ROWS = exports.MENU = void 0;
 exports.liveRequests = liveRequests;
 exports.stateLabel = stateLabel;
+exports.autostartLine = autostartLine;
 exports.fmtCount = fmtCount;
 exports.nowLines = nowLines;
 exports.renderDashboard = renderDashboard;
@@ -16,6 +17,7 @@ exports.createDashboardScreen = createDashboardScreen;
 const render_1 = require("./render");
 const request_row_1 = require("./request-row");
 const app_1 = require("./app");
+const autostart_1 = require("../autostart");
 /** The landing screen's menu. */
 exports.MENU = [
     { key: 'activity', label: 'Activity', hint: 'Every request this node has handled', shortcut: 'a' },
@@ -59,7 +61,27 @@ function headerLines(st) {
         ? `${(0, render_1.cyan)('⏺')} Viewer  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)('· another process owns this node')}`
         : `${(0, render_1.green)('⏺')} Running  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)(`up ${up}`)}  ${(0, render_1.dim)(`${st.inflight} in flight`)}`;
     const chip = st.offline ? `  ${(0, render_1.yellow)('⚠ Offline · retrying')}` : '';
-    return [first, daemon + chip];
+    return [first, daemon + chip, autostartLine(st)];
+}
+/**
+ * Whether the box comes back on its own.
+ *
+ * On the header, not buried in a menu: "will this node survive a reboot" is a
+ * property of the node in the same way "is it online" is, and the answer was
+ * previously knowable only by reading the docs and looking for a plist.
+ */
+function autostartLine(st) {
+    if (st.autostartNote)
+        return (0, render_1.dim)(`  ${st.autostartNote}`);
+    const a = st.autostart;
+    if (!a)
+        return (0, render_1.dim)('  Starts at login  …');
+    if (!a.supported)
+        return (0, render_1.dim)(`  Starts at login  ${(0, render_1.grey)('not supported on this platform')}`);
+    const issue = a.issues?.length ? `  ${(0, render_1.yellow)(`⚠ ${a.issues[0]}`)}` : '';
+    return a.enabled
+        ? `  ${(0, render_1.dim)('Starts at login')}  ${(0, render_1.green)('yes')}${(0, render_1.dim)(a.supervisor ? ` · ${a.supervisor}` : '')}${issue}`
+        : `  ${(0, render_1.dim)('Starts at login')}  ${(0, render_1.yellow)('no')}  ${(0, render_1.dim)('press s to turn it on')}`;
 }
 /** 1204 reads as a year; 1,204 reads as a count. */
 function fmtCount(n) {
@@ -141,6 +163,7 @@ function renderDashboard(st, width, height) {
     const foot = (0, app_1.footerHint)([
         { keys: '↑↓', label: 'move' },
         { keys: '⏎', label: 'open' },
+        { keys: 's', label: st.autostart?.enabled ? 'startup off' : 'startup on' },
         { keys: 'r', label: 'refresh' },
         { keys: '?', label: 'keys' },
         { keys: 'q', label: 'quit' },
@@ -179,8 +202,46 @@ function createDashboardScreen(deps) {
         if (recent.length)
             st.recent = recent;
         st.offline = deps.data.offline();
+        // Reads a file (and, on Windows, a cached schtasks query) — cheap enough
+        // to ride the same poll, so the header can't disagree with reality after
+        // someone changes it from Studio or the CLI.
+        st.autostart = (0, autostart_1.status)();
         deps.host.redraw();
     };
+    /**
+     * Turn "start at login" on or off from here.
+     *
+     * Enabling can stop a daemon — a node started by hand has to stand down so
+     * launchd can own it — so the outcome is reported in the header rather than
+     * left for the user to infer. The work is deferred a tick so the "Working…"
+     * line is actually on screen before the blocking call begins.
+     */
+    const toggleAutostart = async () => {
+        const on = st.autostart?.enabled === true;
+        if (st.autostart && !st.autostart.supported) {
+            st.autostartNote = `Starts at login isn't supported on ${process.platform}`;
+            deps.host.redraw();
+            return;
+        }
+        st.autostartNote = on ? 'Turning off start at login…' : 'Turning on start at login…';
+        deps.host.redraw();
+        await new Promise(r => setTimeout(r, 0));
+        if (on) {
+            const r = (0, autostart_1.disable)();
+            st.autostartNote = r.ok ? 'This node no longer starts at login' : `Could not turn it off: ${r.error}`;
+        }
+        else {
+            const r = (0, autostart_1.enable)();
+            st.autostartNote = r.ok
+                ? ['This node now starts when you log in', ...r.warnings].join(' — ')
+                : `Could not turn it on: ${r.error}`;
+        }
+        st.autostart = (0, autostart_1.status)();
+        deps.host.redraw();
+        // Let the sentence sit long enough to read, then fall back to the state
+        // line — a note that never clears becomes furniture.
+        setTimeout(() => { st.autostartNote = null; deps.host.redraw(); }, 8000).unref?.();
+    };
     return {
         id: 'dashboard',
         title: '+Ai Node',
@@ -202,6 +263,7 @@ function createDashboardScreen(deps) {
             { keys: 'a', label: 'activity — full request history' },
             { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
             { keys: 'l', label: 'logs — daemon output' },
+            { keys: 's', label: 'start this node at login (on / off)' },
             { keys: 'r', label: 'refresh now' },
         ],
         async onKey(key) {
@@ -227,6 +289,10 @@ function createDashboardScreen(deps) {
                 deps.openLogs();
                 return;
             }
+            if (key.name === 's') {
+                await toggleAutostart();
+                return;
+            }
             if (key.name === 'r') {
                 await refresh();
                 return;

package/dist/tui/data.d.ts

@@ -2,6 +2,15 @@ export interface RequestRow {
     id: string;
     entity_name: string | null;
     agent: string;
+    /** Where the row ENDED up. `agent` is what this node actually spawned — the
+     *  ladder mutates the request's agent column in place, so the two differ on
+     *  a run that hopped. */
+    current_agent?: string | null;
+    ladder_hops?: number | null;
+    /** This node ran it but no longer owns it — it was handed to another
+     *  machine, and that machine finished it. */
+    handed_off?: boolean | null;
+    to_runtime_name?: string | null;
     mode: string;
     model: string | null;
     issued_via: string | null;

package/dist/tui/request-row.d.ts

@@ -19,7 +19,7 @@ export declare function shortModel(model: string | null | undefined): string;
 export declare function statusLabel(status: string): string;
 export declare function statusColour(status: string): (s: string) => string;
 /** Live rows get a moving spinner; settled rows get a dot. */
-export declare function marker(status: string, spin: number): string;
+export declare function marker(status: string, spin: number, handedOff?: boolean): string;
 export declare function durationOf(r: RequestRow, now: number): number | null;
 /**
  * Column widths for the request table.

package/dist/tui/request-row.js

@@ -78,7 +78,12 @@ function statusColour(status) {
     return render_1.red;
 }
 /** Live rows get a moving spinner; settled rows get a dot. */
-function marker(status, spin) {
+function marker(status, spin, handedOff = false) {
+    // A run this node handed on didn't finish here, whatever the row's terminal
+    // status says. Marking it as an outcome would credit this machine with
+    // another machine's work.
+    if (handedOff)
+        return (0, render_1.grey)('↗');
     const colour = statusColour(status);
     return colour(exports.ACTIVE.has(status) ? render_1.SPIN[spin % render_1.SPIN.length] : '⏺');
 }
@@ -106,7 +111,7 @@ function requestColumns(width) {
         // status, which is the one column that must never be ambiguous.
         { min: 9 },
         { min: 10, grow: 1 },
-        { min: 12 },
+        { min: 13 },
         // 'haiku-4-5' is nine columns once the claude- prefix is stripped.
         { min: 9 },
         { min: 8 },
@@ -122,18 +127,27 @@ function requestHeader(width) {
 function requestLine(r, now, selected, width, spin = 0) {
     const w = requestColumns(width);
     const colour = statusColour(r.status);
+    const handedOff = r.handed_off === true;
     // A run that failed once and then succeeded on retry still carries the
     // old error_code. Showing it on a DONE row reads as "this broke" when
     // the work actually landed — so the code is only for rows that ended badly.
     const endedBadly = r.status !== 'completed' && !exports.ACTIVE.has(r.status);
-    const tail = r.error_code && endedBadly
-        ? (0, render_1.red)(`[${r.error_code}]`)
-        : (r.prompt ?? '').replace(/\s+/g, ' ');
+    const tail = handedOff
+        // Say where it went. Without this the row reads as a run that simply
+        // stopped, when in fact it continued somewhere else.
+        ? (0, render_1.grey)(`→ ${r.to_runtime_name ?? 'another node'}  `) + (0, render_1.dim)((r.prompt ?? '').replace(/\s+/g, ' '))
+        : (r.error_code && endedBadly
+            ? (0, render_1.red)(`[${r.error_code}]`)
+            : (r.prompt ?? '').replace(/\s+/g, ' '));
+    // `agent` is what this node spawned. A run that laddered ended somewhere
+    // else, and saying so is the difference between a history and a guess.
+    const hopped = (r.ladder_hops ?? 0) > 0 && r.current_agent && r.current_agent !== r.agent;
+    const agentCell = hopped ? `${r.agent}→${r.current_agent}` : `${r.agent}/${r.mode}`;
     const cells = [
-        marker(r.status, spin),
-        colour(statusLabel(r.status)),
+        marker(r.status, spin, handedOff),
+        handedOff ? (0, render_1.grey)('Moved') : colour(statusLabel(r.status)),
         r.entity_name ?? '—',
-        (0, render_1.dim)(`${r.agent}/${r.mode}`),
+        (0, render_1.dim)(agentCell),
         (0, render_1.dim)(shortModel(r.model)),
         (0, render_1.dim)(shortVia(r.issued_via)),
         (0, render_1.dim)((0, render_1.fmtDuration)(durationOf(r, now))),

package/dist/tui/run.js

@@ -197,6 +197,9 @@ async function runDashboard(opts) {
         inflight: 0, paired: (0, store_1.isPaired)(), viewerMode: opts.viewerMode,
         offline: false, now: Date.now(), version: opts.version,
         logCount: 0,
+        // Read on the first poll rather than here — the first frame must paint
+        // before anything touches the filesystem.
+        autostart: null, autostartNote: null,
     };
     const ui = createConsole((host, suspend) => {
         const openTranscript = (r) => host.push((0, transcript_1.createTranscriptScreen)({ data, host, request: r }));

package/package.json

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