@addai/node 0.6.0 → 0.7.0

package/dist/command-runner.d.ts

@@ -1,6 +1,9 @@
 export type RestartHook = (opts: {
     commandId: string;
     version: string;
+    /** Bounce this daemon on the version it is already running: no npm
+     *  install, no version change. See runUpdateRuntime. */
+    restartOnly?: boolean;
 }) => Promise<void>;
 export declare function setRestartHook(fn: RestartHook): void;
 /** Called from index.ts when a heartbeat reports pending_commands > 0.

package/dist/command-runner.js

@@ -479,26 +479,45 @@ async function runLogout(cmd, spec) {
 /* ── update_runtime ──────────────────────────────────────────────────────
  * Roll THIS node to a version (default: npm latest) and come back up.
  *
+ * Two shapes share the command:
+ *
+ *   {}                       roll to npm latest
+ *   {"version": "0.6.0"}     roll to a pinned version
+ *   {"restart_only": true}   bounce the daemon on the version it is already
+ *                            running — no npm install, no version change
+ *
+ * restart_only exists because the reasons to bounce a node are mostly not
+ * version reasons: a credential edit the running daemon has cached, a wedged
+ * harness, a machine that has been up for a fortnight. Doing that through a
+ * version roll meant an unwanted upgrade every time, and could not be done at
+ * all on a node running from a source checkout — where a restart is exactly
+ * the safe half of the operation.
+ *
+ * An older daemon that has never heard of restart_only still does the right
+ * thing, because the caller also pins `version` to the version it can see the
+ * node running: the old code installs the version already installed and
+ * restarts. Same destination, one wasted npm call.
+ *
  * The command is deliberately left `running` here: this process is about to
  * stop existing, so it cannot honestly report the outcome. index.ts's boot
  * path completes it from the handoff file once the replacement daemon is
  * actually up, with whatever version it actually came up as. */
 async function runUpdateRuntime(cmd) {
-    const target = (cmd.input?.version ?? '').trim() || 'latest';
     if (!restartHook) {
         await update(cmd.id, 'failed', {}, 'this daemon is too old to restart itself');
         return;
     }
     const mode = (0, self_update_1.detectLaunchMode)(process.argv[1] ?? '');
-    if (mode === 'source' && target !== 'latest') {
-        // A git checkout's version comes from the working tree, not npm — we'd
-        // restart and report the same old version, looking like a silent no-op.
-        await update(cmd.id, 'failed', { mode }, 'this node runs from a source checkout — pull and rebuild it there; a remote version bump cannot apply');
+    const { target, restartOnly, refusal } = (0, self_update_1.planRoll)(cmd.input, mode, VERSION);
+    if (refusal) {
+        await update(cmd.id, 'failed', { mode }, refusal);
         return;
     }
-    await update(cmd.id, 'running', { step: 'draining', mode, target_version: target, from_version: VERSION });
+    await update(cmd.id, 'running', {
+        step: 'draining', mode, target_version: target, from_version: VERSION, restart_only: restartOnly,
+    });
     try {
-        await restartHook({ commandId: cmd.id, version: target });
+        await restartHook({ commandId: cmd.id, version: target, restartOnly });
     }
     catch (err) {
         // The hook owns the point of no return (it writes the handoff only once

package/dist/index.js

@@ -248,11 +248,17 @@ async function start() {
     // 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 }) => {
+    //
+    // A restart-only bounce takes the same path minus the install: `version` is
+    // already this process's version, so the respawn plan pins the replacement
+    // to the same bits (which matters for npx, whose cache dir is per-version)
+    // and npm is never called — nothing to fetch, and nothing that can fail
+    // offline.
+    (0, command_runner_1.setRestartHook)(async ({ commandId, version, restartOnly }) => {
         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) {
+        if (plan.installFirst && !restartOnly) {
             const err = await (0, self_update_1.installGlobal)(version);
             if (err)
                 throw new Error(err);
@@ -276,14 +282,16 @@ async function start() {
                 at: new Date().toISOString(),
                 drained: lastDrain.drained,
                 timed_out: lastDrain.timedOut,
+                restart_only: restartOnly === true,
             });
         }
         catch (err) {
             console.error('[restart] handoff write failed — the roll still happened, it just cannot self-report:', err.message);
         }
+        const what = restartOnly ? `${mode} → restart on ${version}` : `${mode} → ${version}`;
         console.log(supervised
-            ? `[restart] standing down for launchd to restart us (${mode} → ${version}); exiting`
-            : `[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
+            ? `[restart] standing down for launchd to restart us (${what}); exiting`
+            : `[restart] handed over to ${plan.file} (${what}); exiting`);
         setTimeout(() => process.exit(0), 250).unref?.();
     });
     process.once('SIGINT', () => { stop().finally(() => process.exit(0)); });
@@ -395,6 +403,7 @@ async function finalizeRestartHandoff() {
                 version: VERSION,
                 mode: h.mode,
                 restarted: true,
+                restart_only: h.restart_only === true,
                 version_changed: changed,
                 drained: h.drained ?? 0,
                 // >0 means the drain ceiling expired with work still running — the

package/dist/self-update.d.ts

@@ -45,6 +45,27 @@ export declare function planRespawn(mode: LaunchMode, entryPath: string, targetV
  *  slice(2)) — carried across the restart so a node launched as
  *  `… cli.js run --foo` doesn't silently come back up without them. */
 userArgs?: string[]): RespawnPlan;
+export interface RollPlan {
+    /** Version the replacement must come up as. */
+    target: string;
+    /** A bounce on the running version: nothing is installed, nothing moves. */
+    restartOnly: boolean;
+    /** Non-null = refuse before anything drains, with this explanation. */
+    refusal: string | null;
+}
+/**
+ * Read an `update_runtime` command's input into what this node should do.
+ *
+ * Pure so the one rule that is easy to get wrong stays testable: a source
+ * checkout may not be version-bumped remotely (its version comes from the
+ * working tree, so it would restart and report the same version — a silent
+ * no-op dressed up as success) but it MAY be restarted, which is the half of
+ * the operation that works there.
+ */
+export declare function planRoll(input: {
+    version?: string;
+    restart_only?: boolean;
+} | null, mode: LaunchMode, currentVersion: string): RollPlan;
 export interface RestartHandoff {
     command_id: string;
     from_version: string;
@@ -56,6 +77,10 @@ export interface RestartHandoff {
      *  work unfinished rather than claiming a clean restart either way. */
     drained?: number;
     timed_out?: number;
+    /** True when this was a bounce on the running version rather than a roll,
+     *  so the completed command says which one actually happened instead of
+     *  leaving it to be inferred from two versions that match. */
+    restart_only?: boolean;
 }
 export declare function handoffPath(runtimeDir: string): string;
 export declare function writeHandoff(runtimeDir: string, h: RestartHandoff): void;

package/dist/self-update.js

@@ -55,6 +55,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_NAME = void 0;
 exports.detectLaunchMode = detectLaunchMode;
 exports.planRespawn = planRespawn;
+exports.planRoll = planRoll;
 exports.handoffPath = handoffPath;
 exports.writeHandoff = writeHandoff;
 exports.takeHandoff = takeHandoff;
@@ -112,6 +113,26 @@ userArgs = []) {
         canChangeVersion: mode === 'global',
     };
 }
+/**
+ * Read an `update_runtime` command's input into what this node should do.
+ *
+ * Pure so the one rule that is easy to get wrong stays testable: a source
+ * checkout may not be version-bumped remotely (its version comes from the
+ * working tree, so it would restart and report the same version — a silent
+ * no-op dressed up as success) but it MAY be restarted, which is the half of
+ * the operation that works there.
+ */
+function planRoll(input, mode, currentVersion) {
+    const restartOnly = input?.restart_only === true;
+    // A restart targets the version already running, which keeps the boot-side
+    // "did we come up as what was asked for?" check meaningful instead of
+    // special-cased — and pins npx, whose cache dir is per-version.
+    const target = restartOnly ? currentVersion : (input?.version ?? '').trim() || 'latest';
+    const refusal = !restartOnly && mode === 'source' && target !== 'latest'
+        ? 'this node runs from a source checkout — pull and rebuild it there; a remote version bump cannot apply'
+        : null;
+    return { target, restartOnly, refusal };
+}
 function handoffPath(runtimeDir) {
     return path.join(runtimeDir, 'restart.json');
 }

package/package.json

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