@addai/node 0.30.5 → 0.30.6

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

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