@addai/node 0.30.1 → 0.30.3

package/dist/capabilities.js

@@ -76,7 +76,14 @@ function runCmd(cmd, args, timeoutMs = 5000) {
         // a single failing probe must not take down the whole heartbeat.
         try {
             const inv = (0, win_1.resolveCliInvocation)(cmd, args);
-            (0, child_process_1.execFile)(inv.file, inv.args, { timeout: timeoutMs, maxBuffer: 256 * 1024 }, (err, stdout, stderr) => {
+            // windowsHide: this probe runs for every harness on every heartbeat, so
+            // without it a Windows node flashes a console window several times a
+            // minute, for ever. stderr is captured here rather than discarded — a
+            // probe's error text is the diagnosis when a harness is present but
+            // broken, unlike the "not found" that whereLookup drops.
+            (0, child_process_1.execFile)(inv.file, inv.args, {
+                timeout: timeoutMs, maxBuffer: 256 * 1024, windowsHide: true,
+            }, (err, stdout, stderr) => {
                 resolve({ ok: !err, stdout: (stdout ?? '').trim(), stderr: (stderr ?? '').trim() });
             });
         }

package/dist/claude-binary.js

@@ -86,7 +86,13 @@ function findClaudeBinary() {
             // (extensionless bash script, .cmd, .ps1). Prefer a native .exe
             // (installer builds), then .cmd — never the extensionless one,
             // which CreateProcess can't run.
-            const lines = (0, child_process_1.execSync)('where claude', { encoding: 'utf-8', timeout: 5000 })
+            // windowsHide and a discarded stderr — see whereLookup in win.ts for
+            // why. execSync goes through cmd.exe, so a miss here costs a console
+            // window AND a line of noise in daemon.log every time it runs.
+            const lines = (0, child_process_1.execSync)('where claude', {
+                encoding: 'utf-8', timeout: 5000, windowsHide: true,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            })
                 .split(/\r?\n/)
                 .map(l => l.trim())
                 .filter(Boolean);

package/dist/claude-print.js

@@ -181,6 +181,9 @@ function spawnClaudePrint(input) {
             cwd: input.workingDirectory,
             env: { ...process.env, TERM: 'dumb' },
             stdio: ['ignore', 'pipe', 'pipe'],
+            // No console window. This is headless work on somebody's machine —
+            // on Windows a spawn without this flashes a terminal every run.
+            windowsHide: true,
         });
     }
     catch (err) {

package/dist/codex-spawn.js

@@ -301,6 +301,9 @@ function spawnCodex(input) {
             cwd: input.workingDirectory,
             env: childEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
+            // No console window. This is headless work on somebody's machine —
+            // on Windows a spawn without this flashes a terminal every run.
+            windowsHide: true,
         });
     }
     catch (err) {

package/dist/desktop/learn/browser.js

@@ -87,6 +87,31 @@ exports.WRAPPER_PATH = '/usr/local/bin/browser';
  * so the loop cannot be rebuilt even if something else recreates the shape.
  */
 exports.WRAPPER_MARKER = 'Written by @addai/node';
+/**
+ * The first-run flow, off.
+ *
+ * ⚠️ Without these you do not get a browser. You get Chrome's first-run
+ * DIALOGS — the terms of service, then "make Chrome your default" — each one a
+ * separate top-level X window. Over xpra, which forwards windows one at a
+ * time, that is what lands on somebody's desktop: a 610x564 dialog, then a
+ * 490x162 one, and never the browser behind them.
+ *
+ * Worse, they are modal and they are traps. Escape on the terms dialog means
+ * DECLINE, and Chrome exits — so "close that popup" closed the whole thing,
+ * and an entity typing into what it assumed was a search box was typing into
+ * a consent prompt.
+ *
+ * Every container starts with a fresh profile, so this happened on every
+ * desktop, every time, and only ever looked like the browser being broken.
+ *
+ * The crash bubble is the same class of problem: any unclean exit — a rebuild,
+ * a killed container — and the next launch opens with "Restore pages?" over
+ * the top of whatever was asked for.
+ *
+ * Verified on a live container: with these flags the first window is
+ * 1918x1078 with a tab strip and an address bar, instead of a dialog.
+ */
+const FIRST_RUN = ' --no-first-run --no-default-browser-check --hide-crash-restore-bubble';
 /** 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';
@@ -117,7 +142,7 @@ function wrapperScript(realBrowser, extensionDir) {
     return `#!/bin/sh
 # Written by @addai/node so +Ai Learn can watch this browser${extensionDir ? ' and the +Ai Vault can fill logins in it' : ''}.
 # Removing it costs you the page detail in a lesson${extensionDir ? ' and vault autofill' : ''} and nothing else.
-${seed}exec ${realBrowser} --remote-debugging-port=${exports.DEBUG_PORT} --remote-debugging-address=127.0.0.1${ext} "$@"
+${seed}exec ${realBrowser} --remote-debugging-port=${exports.DEBUG_PORT} --remote-debugging-address=127.0.0.1${FIRST_RUN}${ext} "$@"
 `;
 }
 /** Is what is on disk already what we would write? Exact match, so a change to

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/dist/gemini-spawn.js

@@ -357,6 +357,9 @@ function spawnGemini(input) {
             cwd: input.workingDirectory,
             env: childEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
+            // No console window. This is headless work on somebody's machine —
+            // on Windows a spawn without this flashes a terminal every run.
+            windowsHide: true,
         });
     }
     catch (err) {

package/dist/git-identity.js

@@ -66,7 +66,9 @@ async function applyGitIdentity(dir, requestId, token) {
     if (!ident?.configured || !ident.author_name || !ident.author_email)
         return;
     const git = (args) => new Promise((resolve) => {
-        (0, child_process_1.execFile)('git', ['-C', dir, ...args], { timeout: 10_000 }, () => resolve());
+        (0, child_process_1.execFile)('git', ['-C', dir, ...args], 
+        // Headless: no console window on Windows.
+        { timeout: 10_000, windowsHide: true }, () => resolve());
     });
     // Repo-local only — never touch the machine's global config, which other
     // entities and the human owner share.

package/dist/grok-spawn.js

@@ -349,6 +349,9 @@ function spawnGrok(input) {
             cwd: input.workingDirectory,
             env: childEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
+            // No console window. This is headless work on somebody's machine —
+            // on Windows a spawn without this flashes a terminal every run.
+            windowsHide: true,
         });
     }
     catch (err) {

package/dist/kimi-spawn.js

@@ -390,6 +390,9 @@ function spawnKimi(input) {
             cwd: input.workingDirectory,
             env: childEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
+            // No console window. This is headless work on somebody's machine —
+            // on Windows a spawn without this flashes a terminal every run.
+            windowsHide: true,
         });
     }
     catch (err) {

package/dist/projects.js

@@ -105,7 +105,12 @@ function projectDir(p) {
 }
 function run(cmd, args, opts = {}) {
     return new Promise(resolve => {
-        (0, child_process_1.execFile)(cmd, args, { cwd: opts.cwd, timeout: opts.timeoutMs ?? 5 * 60_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+        (0, child_process_1.execFile)(cmd, args, {
+            cwd: opts.cwd, timeout: opts.timeoutMs ?? 5 * 60_000,
+            maxBuffer: 4 * 1024 * 1024,
+            // Headless: no console window on Windows.
+            windowsHide: true,
+        }, (err, stdout, stderr) => {
             resolve({ ok: !err, stdout: stdout.toString(), stderr: stderr.toString() });
         });
     });

package/dist/win.js

@@ -91,7 +91,19 @@ function whereLookup(name) {
     if (!exports.IS_WINDOWS)
         return null;
     try {
-        const out = (0, child_process_1.execFileSync)('where', [name], { encoding: 'utf8', timeout: 5000 });
+        // ⚠️ windowsHide, and stderr thrown away. Both for the same reason: this
+        // runs for every CLI we look for, on a timer, and most of them are not
+        // installed. Without windowsHide each miss flashes a console window on
+        // the user's screen; without the stdio the miss writes
+        //
+        //     INFO: Could not find files for the given pattern(s).
+        //
+        // to our stderr, and daemon.log fills with nothing else. "Not found" is
+        // the return value here, not an event worth reporting.
+        const out = (0, child_process_1.execFileSync)('where', [name], {
+            encoding: 'utf8', timeout: 5000, windowsHide: true,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
         const lines = out.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
         const pick = lines.find(l => /\.exe$/i.test(l)) ??
             lines.find(l => /\.cmd$/i.test(l)) ??

package/package.json

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