@addai/node 0.30.0 → 0.30.2

package/dist/desktop/learn/browser.d.ts

@@ -4,6 +4,28 @@ export declare const DEBUG_PORT = 9222;
  *  it would point the wrapper at itself and exec forever. */
 export declare const REAL_BROWSERS: string[];
 export declare const WRAPPER_PATH = "/usr/local/bin/browser";
+/**
+ * A line of the wrapper distinctive enough to recognise it by.
+ *
+ * ⚠️ This exists because the wrapper used to destroy the browser it wraps.
+ *
+ * In the image WRAPPER_PATH is a SYMLINK — `ln -sf /usr/bin/chromium
+ * /usr/local/bin/browser`. `cp` follows a symlink destination and writes
+ * THROUGH it, so `cp wrapper /usr/local/bin/browser` overwrote /usr/bin/
+ * chromium — the real browser — with a script whose last line is
+ *
+ *     exec /usr/bin/chromium --remote-debugging-port=9222 ... "$@"
+ *
+ * which is now itself. Each hop re-appended the flags and passed the lot on
+ * as "$@", so a single launch exec'd itself until the argument list blew up.
+ * From the outside: the browser simply never opened, and the flags appeared
+ * hundreds of times over in ps.
+ *
+ * The write is fixed below. This marker is the second line of defence: a
+ * candidate that is really this wrapper is never treated as a real browser,
+ * so the loop cannot be rebuilt even if something else recreates the shape.
+ */
+export declare const WRAPPER_MARKER = "Written by @addai/node";
 /** The in-container script that signs the browser in. Beside the extension,
  *  under the same bind mount, so it arrives by the same route. */
 export declare const SEED_SCRIPT = "/conf/vault/vault-seed.mjs";

package/dist/desktop/learn/browser.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEED_SCRIPT = exports.WRAPPER_PATH = exports.REAL_BROWSERS = exports.DEBUG_PORT = void 0;
+exports.SEED_SCRIPT = exports.WRAPPER_MARKER = exports.WRAPPER_PATH = exports.REAL_BROWSERS = exports.DEBUG_PORT = void 0;
 exports.wrapperScript = wrapperScript;
 exports.wrapperIsCurrent = wrapperIsCurrent;
 exports.ensureBrowserWrapper = ensureBrowserWrapper;
@@ -65,6 +65,28 @@ exports.REAL_BROWSERS = [
     '/usr/bin/chromium-browser',
 ];
 exports.WRAPPER_PATH = '/usr/local/bin/browser';
+/**
+ * A line of the wrapper distinctive enough to recognise it by.
+ *
+ * ⚠️ This exists because the wrapper used to destroy the browser it wraps.
+ *
+ * In the image WRAPPER_PATH is a SYMLINK — `ln -sf /usr/bin/chromium
+ * /usr/local/bin/browser`. `cp` follows a symlink destination and writes
+ * THROUGH it, so `cp wrapper /usr/local/bin/browser` overwrote /usr/bin/
+ * chromium — the real browser — with a script whose last line is
+ *
+ *     exec /usr/bin/chromium --remote-debugging-port=9222 ... "$@"
+ *
+ * which is now itself. Each hop re-appended the flags and passed the lot on
+ * as "$@", so a single launch exec'd itself until the argument list blew up.
+ * From the outside: the browser simply never opened, and the flags appeared
+ * hundreds of times over in ps.
+ *
+ * The write is fixed below. This marker is the second line of defence: a
+ * candidate that is really this wrapper is never treated as a real browser,
+ * so the loop cannot be rebuilt even if something else recreates the shape.
+ */
+exports.WRAPPER_MARKER = 'Written by @addai/node';
 /** The in-container script that signs the browser in. Beside the extension,
  *  under the same bind mount, so it arrives by the same route. */
 exports.SEED_SCRIPT = '/conf/vault/vault-seed.mjs';
@@ -112,10 +134,28 @@ function wrapperIsCurrent(content, realBrowser, extensionDir) {
  * cheap execs and no change.
  */
 async function ensureBrowserWrapper(run, confDir, extensionDir) {
+    // Each candidate is classified, not just found: one that is really this
+    // wrapper (see WRAPPER_MARKER) is a browser an older build overwrote, and
+    // pointing a new wrapper at it would rebuild the exec loop.
     const found = await run(['sh', '-c',
-        exports.REAL_BROWSERS.map(b => `[ -x ${b} ] && echo ${b}`).join(' || ') + ' || true']);
-    const real = found.out.trim().split('\n')[0]?.trim();
+        `for b in ${exports.REAL_BROWSERS.join(' ')}; do [ -x "$b" ] || continue; ` +
+            `if head -c 512 "$b" 2>/dev/null | grep -qF '${exports.WRAPPER_MARKER}'; ` +
+            `then echo "wrapped $b"; else echo "real $b"; fi; done`]);
+    const lines = found.out.trim().split('\n').map(l => l.trim()).filter(Boolean);
+    const real = lines.find(l => l.startsWith('real '))?.slice(5);
     if (!real) {
+        const wrapped = lines.find(l => l.startsWith('wrapped '))?.slice(8);
+        if (wrapped) {
+            // Deliberately not repaired from here. Putting the browser back means
+            // reinstalling its package — a network install, on every start, on a
+            // machine that is somebody's desktop — and this path is meant to be two
+            // cheap execs. Rebuilding the desktop restores it from the image.
+            return {
+                changed: false, browser: null,
+                note: `${wrapped} was overwritten by an older version of this wrapper `
+                    + 'and no longer starts a browser. Rebuild this desktop to restore it.',
+            };
+        }
         return { changed: false, browser: null, note: 'this desktop has no browser installed' };
     }
     const current = await run(['sh', '-c', `cat ${exports.WRAPPER_PATH} 2>/dev/null || true`]);
@@ -127,8 +167,15 @@ async function ensureBrowserWrapper(run, confDir, extensionDir) {
     // sudo, not `docker exec -u root`: the image gives the entity passwordless
     // sudo inside its own container, and going through the same exec path as
     // everything else keeps one way of talking to a desktop rather than two.
+    // ⚠️ rm FIRST, and it is the whole fix. In the image WRAPPER_PATH is a
+    // symlink to the real browser, and `cp` follows a symlink destination —
+    // writing through it, over the browser, rather than replacing the link.
+    // Unlinking first makes the wrapper a file of its own and leaves whatever
+    // it pointed at alone. (`cp --remove-destination` does the same in one
+    // call; this shape says why out loud and needs no GNU-only flag.)
     const put = await run(['sh', '-c',
-        `sudo cp /conf/learn/browser ${exports.WRAPPER_PATH} && sudo chmod +x ${exports.WRAPPER_PATH}`]);
+        `sudo rm -f ${exports.WRAPPER_PATH} && sudo cp /conf/learn/browser ${exports.WRAPPER_PATH} `
+            + `&& sudo chmod +x ${exports.WRAPPER_PATH}`]);
     if (!put.ok) {
         return { changed: false, browser: real, note: `could not install the browser wrapper: ${put.out.trim().slice(0, 200)}` };
     }

package/dist/desktop/relay-client.js

@@ -83,6 +83,30 @@ let missedPongs = 0;
  *  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();
+/**
+ * Bytes that arrived while their bridge was still being built.
+ *
+ * ⚠️ There is an await between 'attach' and the socket existing — the row has
+ * to be looked up to know which port to dial — and a viewer can send in that
+ * window. RFB never did: x11vnc speaks first, so noVNC has nothing to say
+ * until the server has already said hello, and the gap was invisible for as
+ * long as the screen was the only channel.
+ *
+ * xpra is the other way round. Its client sends its own hello the moment the
+ * socket opens, so on the windows channel the first packet ALWAYS raced the
+ * lookup — and losing it was not a dropped packet but a dead session: the data
+ * branch found no bridge, reported the viewer gone, and the connection that
+ * finished opening a moment later sat there with nothing on it until xpra
+ * timed out 20 seconds on:
+ *
+ *     New tcp connection received from '172.17.0.1:58222'
+ *     0 packets received
+ *     1 packets sent (25 bytes)
+ *
+ * A viewerId present here means "attaching" — distinct from present in
+ * `bridges` (attached) and from neither (gone, and the sender should be told).
+ */
+const pendingWrites = new Map();
 const wakeHooks = new Map();
 function onWake(kind, fn) {
     wakeHooks.set(kind, fn);
@@ -95,6 +119,9 @@ function dropBridges() {
         catch { /* gone */ }
     }
     bridges.clear();
+    // The link went down mid-attach. Nothing will ever flush these, and keeping
+    // them would hand a reconnecting viewer the last session's first packet.
+    pendingWrites.clear();
 }
 /**
  * Start a connection attempt that CANNOT take the daemon down with it.
@@ -175,11 +202,17 @@ async function connect() {
         const gone = (viewerId, reason) => {
             bridges.get(viewerId)?.destroy();
             bridges.delete(viewerId);
+            // Anything still waiting for a bridge that is never coming.
+            pendingWrites.delete(viewerId);
             if (sock.readyState === ws_1.default.OPEN) {
                 sock.send(JSON.stringify({ type: 'gone', viewerId, reason }));
             }
         };
         if (msg.type === 'attach') {
+            // Claim the viewer BEFORE the await, so a packet arriving during the
+            // lookup is held rather than treated as arriving after a lost bridge.
+            if (!pendingWrites.has(msg.viewerId))
+                pendingWrites.set(msg.viewerId, []);
             const row = (await (0, manager_1.listDesktops)()).find(d => d.id === msg.desktopId);
             if (!row?.vnc_port) {
                 gone(msg.viewerId, 'desktop is not running');
@@ -223,14 +256,28 @@ async function connect() {
             tcp.on('close', () => gone(msg.viewerId, 'the desktop closed the connection'));
             bridges.get(msg.viewerId)?.destroy();
             bridges.set(msg.viewerId, tcp);
+            // Whatever arrived while the row was being looked up, in order and
+            // before anything newer. net.connect returns a socket that is still
+            // connecting, and node queues writes on it until it is — so this needs
+            // no wait of its own.
+            const queued = pendingWrites.get(msg.viewerId) ?? [];
+            pendingWrites.delete(msg.viewerId);
+            for (const chunk of queued)
+                tcp.write(chunk);
             return;
         }
         if (msg.type === 'data' && msg.b64) {
             const bridge = bridges.get(msg.viewerId);
-            // Input for a bridge that no longer exists. Dropping it quietly is how
-            // "take control does nothing" happens: the pointer never moves and the
-            // viewer has no idea why.
             if (!bridge) {
+                // Still attaching: hold it. The first xpra packet always lands here.
+                const queue = pendingWrites.get(msg.viewerId);
+                if (queue) {
+                    queue.push(Buffer.from(msg.b64, 'base64'));
+                    return;
+                }
+                // Input for a bridge that no longer exists. Dropping it quietly is how
+                // "take control does nothing" happens: the pointer never moves and the
+                // viewer has no idea why.
                 gone(msg.viewerId, 'no longer connected to the desktop');
                 return;
             }
@@ -260,6 +307,8 @@ async function connect() {
         if (msg.type === 'detach') {
             bridges.get(msg.viewerId)?.destroy();
             bridges.delete(msg.viewerId);
+            // A viewer that left while it was still attaching.
+            pendingWrites.delete(msg.viewerId);
         }
     });
     const retry = () => {

package/package.json

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