@addai/node 0.13.0 → 0.15.0

package/dist/command-runner.js

@@ -621,6 +621,9 @@ async function runDesktopCommand(cmd) {
                 await (0, manager_1.setStatus)(row.id, {
                     status: 'running', container_id: containerId,
                     engine: provider.id, vnc_port: vncPort, status_message: null,
+                    // Record the password we actually gave the container, or the viewer
+                    // will keep presenting the previous one.
+                    vnc_password: vncPassword,
                 });
                 await (0, creds_1.syncCredentials)(provider, built, onLog);
                 if (row.setup_script) {

package/dist/desktop/docker.js

@@ -42,8 +42,16 @@ class CliProvider {
         // payload as its own phase rather than hiding inside `run`.
         onLog(`pulling ${row.image}\n`);
         const pull = await this.run(['pull', row.image], onLog);
-        if (!pull.ok)
-            throw new Error(`image pull failed: ${pull.stderr.trim().slice(0, 500)}`);
+        if (!pull.ok) {
+            // A pull failure is only fatal if we have no copy. A locally built or
+            // side-loaded image has no registry to pull FROM, and a node that is
+            // briefly offline should still be able to start a desktop it already
+            // has. Only give up when neither the registry nor the disk has it.
+            const local = await this.run(['image', 'inspect', row.image], undefined, 30_000);
+            if (!local.ok)
+                throw new Error(`image pull failed: ${pull.stderr.trim().slice(0, 500)}`);
+            onLog(`pull failed; using the copy already on this machine\n`);
+        }
         onLog(`creating ${(0, provider_1.containerName)(row)}\n`);
         const res = await this.run((0, provider_1.buildCreateArgs)(row, opts), onLog);
         if (!res.ok)

package/dist/desktop/manager.d.ts

@@ -12,6 +12,10 @@ export declare function setStatus(id: string, fields: {
     container_id?: string | null;
     engine?: string | null;
     vnc_port?: number | null;
+    /** Written only on create/rebuild, when the daemon mints a fresh one. The
+     *  viewer authenticates with whatever is recorded here, so a password used
+     *  but not recorded means "password check failed" at the RFB handshake. */
+    vnc_password?: string | null;
 }): Promise<void>;
 /** A free loopback port for this desktop's VNC. Asking the OS for port 0 and
  *  reading back what it bound is the only race-free way to pick one. */

package/dist/desktop/manager.js

@@ -92,6 +92,7 @@ async function setStatus(id, fields) {
             p_container_id: fields.container_id ?? null,
             p_engine: fields.engine ?? null,
             p_vnc_port: fields.vnc_port ?? null,
+            p_vnc_password: fields.vnc_password ?? null,
         });
     }
     catch (err) {

package/dist/desktop/relay-client.js

@@ -50,16 +50,28 @@ const ws_1 = __importDefault(require("ws"));
 const net = __importStar(require("net"));
 const store_1 = require("../store");
 const manager_1 = require("./manager");
-const RELAY_URL = process.env.AINODE_RELAY_URL ?? 'wss://desktop-relay.add.ai';
+// The deployed relay. Overridable so a node can be pointed at a local one.
+const RELAY_URL = process.env.AINODE_RELAY_URL
+    ?? 'wss://desktop-relay-29522465016.europe-west2.run.app';
 const RECONNECT_MIN_MS = 2_000;
 const RECONNECT_MAX_MS = 60_000;
 /** Re-check whether any desktop is running this often while idle. */
 const IDLE_CHECK_MS = 60_000;
+/** How often to prove the socket is still alive. A machine that suspends
+ *  leaves a half-open socket that never fires 'close', so without this the
+ *  client sits holding a dead handle and never reconnects. */
+const PING_INTERVAL_MS = 30_000;
 let ws = null;
 let stopped = true;
 let backoff = RECONNECT_MIN_MS;
 let idleTimer = null;
-/** desktopId -> the local TCP socket to that desktop's published RFB port. */
+let liveTimer = null;
+/** Set on every pong; cleared when a ping goes out. Two misses = dead. */
+let missedPongs = 0;
+/** viewerId -> that viewer's OWN TCP socket to the desktop's RFB port.
+ *  Keyed per viewer, not per desktop: RFB is a stateful 1:1 protocol, so two
+ *  people watching the same screen each need their own connection and their
+ *  own handshake. x11vnc runs with -shared precisely so it will serve them. */
 const bridges = new Map();
 function dropBridges() {
     for (const s of bridges.values()) {
@@ -99,7 +111,35 @@ async function connect() {
     }
     const sock = new ws_1.default(`${RELAY_URL}/node?token=${encodeURIComponent(token)}`);
     ws = sock;
-    sock.on('open', () => { backoff = RECONNECT_MIN_MS; });
+    sock.on('open', () => {
+        backoff = RECONNECT_MIN_MS;
+        missedPongs = 0;
+        if (liveTimer)
+            clearInterval(liveTimer);
+        // A suspended Mac comes back with a socket that looks open and is not.
+        // Ping until two go unanswered, then tear it down so the normal backoff
+        // path reconnects - the daemon's own sleep detector reports the same
+        // suspends this is guarding against.
+        liveTimer = setInterval(() => {
+            if (sock.readyState !== ws_1.default.OPEN) {
+                sock.terminate();
+                return;
+            }
+            if (missedPongs >= 2) {
+                console.warn('[relay] no pong in 60s — assuming the link died, reconnecting');
+                sock.terminate();
+                return;
+            }
+            missedPongs += 1;
+            try {
+                sock.ping();
+            }
+            catch {
+                sock.terminate();
+            }
+        }, PING_INTERVAL_MS);
+    });
+    sock.on('pong', () => { missedPongs = 0; });
     sock.on('message', async (raw) => {
         let msg;
         try {
@@ -118,27 +158,31 @@ async function connect() {
             tcp.on('data', chunk => {
                 if (sock.readyState === ws_1.default.OPEN) {
                     sock.send(JSON.stringify({
-                        type: 'data', desktopId: msg.desktopId, b64: chunk.toString('base64'),
+                        type: 'data', viewerId: msg.viewerId, b64: chunk.toString('base64'),
                     }));
                 }
             });
-            const forget = () => { bridges.delete(msg.desktopId); };
+            const forget = () => { bridges.delete(msg.viewerId); };
             tcp.on('close', forget);
             tcp.on('error', forget);
-            bridges.get(msg.desktopId)?.destroy();
-            bridges.set(msg.desktopId, tcp);
+            bridges.get(msg.viewerId)?.destroy();
+            bridges.set(msg.viewerId, tcp);
             return;
         }
         if (msg.type === 'data' && msg.b64) {
-            bridges.get(msg.desktopId)?.write(Buffer.from(msg.b64, 'base64'));
+            bridges.get(msg.viewerId)?.write(Buffer.from(msg.b64, 'base64'));
             return;
         }
         if (msg.type === 'detach') {
-            bridges.get(msg.desktopId)?.destroy();
-            bridges.delete(msg.desktopId);
+            bridges.get(msg.viewerId)?.destroy();
+            bridges.delete(msg.viewerId);
         }
     });
     const retry = () => {
+        if (liveTimer) {
+            clearInterval(liveTimer);
+            liveTimer = null;
+        }
         if (ws !== sock)
             return; // superseded by a newer socket
         dropBridges();
@@ -161,6 +205,10 @@ function stopRelayClient() {
         clearTimeout(idleTimer);
         idleTimer = null;
     }
+    if (liveTimer) {
+        clearInterval(liveTimer);
+        liveTimer = null;
+    }
     dropBridges();
     try {
         ws?.close();

package/package.json

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