@addai/node 0.30.5 → 0.30.7

package/dist/desktop/manager.d.ts

@@ -62,6 +62,12 @@ export declare function desktopStartAllowed(rows: DesktopRow[], excludeId?: stri
 }>;
 export declare function startDesktopManager(): void;
 export declare function stopDesktopManager(): void;
+/** For the sleep monitor. A machine that just resumed may have a Docker that
+ *  died with the suspend and a cached provider still pointing at its dead
+ *  socket — so drop the cache (the next probe re-detects, and relaunches the
+ *  engine if it must) and reconcile now rather than up to a poll interval
+ *  later. Safe any time: tick() no-ops if one is already running. */
+export declare function reconcileAfterWake(): void;
 /** Bring a desktop up and wait for it, for the run path. Returns the row when
  *  running, null when it could not be started - the caller then falls back to
  *  the host rather than failing the run. */

package/dist/desktop/manager.js

@@ -47,6 +47,7 @@ exports.queueOrder = queueOrder;
 exports.desktopStartAllowed = desktopStartAllowed;
 exports.startDesktopManager = startDesktopManager;
 exports.stopDesktopManager = stopDesktopManager;
+exports.reconcileAfterWake = reconcileAfterWake;
 exports.ensureRunning = ensureRunning;
 // Keeps the desktops the server believes in and the containers that actually
 // exist in agreement. Modelled on projects.ts: a slow poll, no realtime, and
@@ -57,6 +58,7 @@ const supabase_client_1 = require("../supabase-client");
 const store_1 = require("../store");
 const spec_1 = require("./spec");
 const docker_1 = require("./docker");
+const start_engine_1 = require("./start-engine");
 // Desktops are not latency-sensitive: a container that died is a rare event
 // and 15s to notice it is fine. Slower interval = less pooler pressure.
 const POLL_INTERVAL_MS = 15_000;
@@ -243,6 +245,63 @@ async function desktopStartAllowed(rows, excludeId) {
             + `its limit. Stop one, or raise the limit on the machine's page.`,
     };
 }
+// ── Starting the engine when a desktop needs it ──────────────────────────────
+//
+// The commonest reason the Desktops tab is dark is Docker installed and closed
+// — a fresh boot, or a laptop that resumed with Docker not relaunched. The
+// reconcile used to see no engine and simply return, so a desktop that should
+// be running sat dark until someone opened Docker by hand. Now, if any desktop
+// on this machine wants to run and we can start the engine without a password
+// (Windows/macOS), the daemon starts it itself and the next tick picks it up.
+// Linux runs Docker as a root service and gets no unattended start here.
+let engineStarting = false;
+let lastEngineAttempt = 0;
+const ENGINE_RETRY_MS = 3 * 60_000;
+function wantsToRun(row) {
+    if (row.status === 'running' || row.status === 'queued')
+        return true;
+    return row.status === 'stopped' && !!row.autostart;
+}
+async function maybeStartEngineForDesktops() {
+    if (engineStarting || Date.now() - lastEngineAttempt < ENGINE_RETRY_MS)
+        return;
+    let rows;
+    try {
+        rows = await listDesktops();
+    }
+    catch {
+        return;
+    }
+    const waiting = rows.filter(wantsToRun);
+    if (waiting.length === 0)
+        return; // nothing on this machine needs the engine
+    // Only where we can drive it without a password. Linux needs systemctl and a
+    // root round trip we cannot answer unattended — and those hosts keep Docker
+    // running as a service anyway.
+    const plan = (0, start_engine_1.startPlan)(process.platform, (0, start_engine_1.runningAsRoot)(), process.env.ProgramFiles);
+    if (!plan.file || plan.needsRoot)
+        return;
+    engineStarting = true;
+    lastEngineAttempt = Date.now();
+    console.warn(`[desktops] the container engine is down and ${waiting.length} `
+        + `desktop${waiting.length === 1 ? '' : 's'} want it — starting it`);
+    try {
+        const engine = await (0, start_engine_1.startEngine)(s => process.stdout.write(s), async () => null);
+        if (engine) {
+            (0, docker_1.resetProviderCache)();
+            console.log('[desktops] the container engine is up — reconciling');
+        }
+        else {
+            console.warn('[desktops] the engine did not come up in time; will try again later');
+        }
+    }
+    catch (err) {
+        console.warn('[desktops] could not start the engine:', err.message);
+    }
+    finally {
+        engineStarting = false;
+    }
+}
 let timer = null;
 let inflight = false;
 async function tick() {
@@ -250,9 +309,18 @@ async function tick() {
         return;
     inflight = true;
     try {
-        const provider = await (0, docker_1.getProvider)();
+        let provider = await (0, docker_1.getProvider)();
+        // A provider cached as null from a boot when the engine was down stays null
+        // until forced — so re-probe once (cheap) in case the engine has since come
+        // up, by our hand or the user's.
         if (!provider)
-            return; // no engine: nothing to reconcile
+            provider = await (0, docker_1.getProvider)(true);
+        if (!provider) {
+            // Still nothing. If a desktop wants the engine, start it; the next tick
+            // reconciles once it answers.
+            await maybeStartEngineForDesktops();
+            return;
+        }
         const rows = await listDesktops();
         for (const row of queueOrder(rows)) {
             const actual = await provider.inspect(row);
@@ -320,6 +388,15 @@ function stopDesktopManager() {
         timer = null;
     }
 }
+/** For the sleep monitor. A machine that just resumed may have a Docker that
+ *  died with the suspend and a cached provider still pointing at its dead
+ *  socket — so drop the cache (the next probe re-detects, and relaunches the
+ *  engine if it must) and reconcile now rather than up to a poll interval
+ *  later. Safe any time: tick() no-ops if one is already running. */
+function reconcileAfterWake() {
+    (0, docker_1.resetProviderCache)();
+    void tick();
+}
 /** Bring a desktop up and wait for it, for the run path. Returns the row when
  *  running, null when it could not be started - the caller then falls back to
  *  the host rather than failing the run. */

package/dist/index.js

@@ -200,9 +200,15 @@ async function start(argv = []) {
         intervalMs: 30_000,
         thresholdMs: 90_000, // >90s late = we were suspended (matches server offline window)
         onWake: (gapMs) => {
-            console.warn(`[wake] detected ~${Math.round(gapMs / 1000)}s suspend — re-heartbeating and reclaiming in-flight runs`);
+            console.warn(`[wake] detected ~${Math.round(gapMs / 1000)}s suspend — re-heartbeating, reclaiming runs, and rechecking desktops`);
             void (0, heartbeat_1.beat)().catch(() => { });
             reclaimOrphanedRequests('wake').catch(err => console.error('[wake] reclaim error:', err.message));
+            // A resumed laptop may have a Docker that went down with the suspend, and
+            // a desktop that should be running gone dark with it. Drop the cached
+            // provider (it may point at a dead socket) and reconcile now — which
+            // relaunches the engine if a desktop needs it — rather than waiting for
+            // the 15s poll to notice.
+            (0, manager_1.reconcileAfterWake)();
         },
     });
     // Begin polling for pending requests.

package/dist/win.js

@@ -245,6 +245,28 @@ function resolveNpmShimScript(shimPath) {
     const re = /%(?:~dp0|dp0%)[\\/]([^"\s]+\.(?:m|c)?js)/gi;
     for (const m of body.matchAll(re))
         candidates.push(m[1]);
+    // ⚠️ The CLI entry point first — NOT the file's order.
+    //
+    // npm's own npm.cmd names two %~dp0 scripts, and the helper comes first:
+    //
+    //     SET "NPM_PREFIX_JS=%~dp0\node_modules\npm\bin\npm-prefix.js"
+    //     SET "NPM_CLI_JS=%~dp0\node_modules\npm\bin\npm-cli.js"
+    //     ...
+    //     "%NODE_EXE%" "%NPM_CLI_JS%" %*
+    //
+    // Only that last line runs, and it runs NPM_CLI_JS. Taking the first that
+    // exists therefore spawned npm-prefix.js — and the reason this hid for so
+    // long is that doing so does not FAIL: it exits 0 and prints the npm prefix
+    // path. npmLatestVersion saw a clean exit whose output was not a version,
+    // returned null, and the auto-updater logged "could not read the latest
+    // published version" on every tick. A Windows node then sat for ever on the
+    // version it was installed with — the machine this was found on was still
+    // running 0.30.3 while 0.30.6 was published.
+    //
+    // Every package bin shim names exactly one script and is unaffected: the
+    // sort is stable, so with nothing to promote nothing moves.
+    const isCliEntry = (rel) => /(^|[\\/])(npm|npx)-cli\.(m|c)?js$/i.test(rel);
+    candidates.sort((a, b) => Number(isCliEntry(b)) - Number(isCliEntry(a)));
     for (const rel of candidates) {
         // Shims always write backslashes. Split on either separator and re-join
         // with the platform's, so the same parsing is exercisable off Windows —

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "@addai/node",
-  "version": "0.30.5",
-  "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": [
-    "addai",
-    "entity-studio",
-    "claude",
-    "codex",
-    "kimi",
-    "gemini",
-    "agent",
-    "daemon",
-    "supabase",
-    "mcp"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
-  },
-  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
-  "bugs": {
-    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
-  },
-  "type": "commonjs",
-  "main": "dist/index.js",
-  "bin": {
-    "ainode": "dist/cli.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist",
-    "scripts",
-    "README.md",
-    "assets"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
-    "start": "node dist/cli.js",
-    "dev": "tsc -p tsconfig.json && node dist/cli.js",
-    "test": "npm run build && node --test test/*.test.mjs",
-    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
-    "postinstall": "node scripts/fix-pty-helper.js",
-    "prepublishOnly": "npm run build"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@addai/node-flows": "^1.0.0",
-    "node-pty": "^1.1.0",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.6.0"
-  }
-}
+{
+  "name": "@addai/node",
+  "version": "0.30.7",
+  "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": [
+    "addai",
+    "entity-studio",
+    "claude",
+    "codex",
+    "kimi",
+    "gemini",
+    "agent",
+    "daemon",
+    "supabase",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-AddAi/addai-entity-runtime.git"
+  },
+  "homepage": "https://github.com/just-AddAi/addai-entity-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/just-AddAi/addai-entity-runtime/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "ainode": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
+    "start": "node dist/cli.js",
+    "dev": "tsc -p tsconfig.json && node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "postinstall": "node scripts/fix-pty-helper.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@addai/node-flows": "^1.0.0",
+    "node-pty": "^1.1.0",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.6.0"
+  }
+}