@addai/node 0.14.0 → 0.16.0

package/dist/command-runner.js

@@ -63,6 +63,7 @@ const pty_helper_1 = require("./pty-helper");
 const docker_1 = require("./desktop/docker");
 const manager_1 = require("./desktop/manager");
 const creds_1 = require("./desktop/creds");
+const install_engine_1 = require("./desktop/install-engine");
 const COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 /** Own version, read the same way index.ts does. Resolved here rather than
  *  imported from index.ts, which already imports this module. */
@@ -107,6 +108,12 @@ async function npmGlobalBinFor(name) {
     return null;
 }
 const INPUT_POLL_MS = 2_000;
+/** How long to wait on a HUMAN before giving up. Deliberately shorter than
+ *  COMMAND_TIMEOUT_MS: one command runs at a time, so a login nobody ever
+ *  pastes a code into blocks every other command on this node for as long as
+ *  it waits. Three minutes is long enough to fetch a code from a browser and
+ *  short enough that a forgotten login is not a wedged machine. */
+const INPUT_WAIT_MS = 3 * 60_000;
 const LOG_TAIL_CHARS = 4_000;
 const LOG_PUSH_MS = 1_000;
 let running = false;
@@ -254,7 +261,7 @@ async function runLoginPty(cmd, spec, login = spec.login) {
         return;
     }
     await update(cmd.id, 'running', { step: 'starting-login', instructions: login.instructions });
-    const deadline = Date.now() + COMMAND_TIMEOUT_MS;
+    const deadline = Date.now() + INPUT_WAIT_MS;
     const ptyOpts = {
         name: 'xterm-256color', cols: 120, rows: 30,
         cwd: os.homedir(),
@@ -408,7 +415,7 @@ async function applyApiKey(spec, key, method) {
 }
 async function runLoginApiKey(cmd, spec, method, instructions) {
     await update(cmd.id, 'awaiting_input', { needs: 'api_key', instructions: instructions ?? spec.login.instructions });
-    const deadline = Date.now() + COMMAND_TIMEOUT_MS;
+    const deadline = Date.now() + INPUT_WAIT_MS;
     const key = cmd.input?.api_key?.trim() || await awaitInput(cmd.id, deadline, i => i.api_key);
     if (key === null) {
         await update(cmd.id, 'canceled', {}, 'canceled or timed out waiting for the key');
@@ -673,6 +680,35 @@ async function runDesktopCommand(cmd) {
         }
     }
 }
+/** Install a container engine, then prove it took. The capability probe is
+ *  the verdict, not the installer's exit code - Docker Desktop on macOS
+ *  installs the app but the daemon is not up until someone launches it, so a
+ *  clean exit does not mean a usable engine. */
+async function runInstallEngine(cmd) {
+    let log = '';
+    const onLog = (chunk) => {
+        log = (log + chunk).slice(-LOG_TAIL_CHARS);
+        void update(cmd.id, null, { log });
+    };
+    await update(cmd.id, 'running', { log });
+    try {
+        await (0, install_engine_1.installEngine)(onLog);
+        (0, docker_1.resetProviderCache)();
+        const engine = await (0, docker_1.getProvider)(true);
+        if (!engine) {
+            await update(cmd.id, 'failed', { log }, 'Installed, but no engine is answering yet. On macOS, Docker Desktop has to be opened once before its daemon runs.');
+            return;
+        }
+        onLog(`\n${engine.id} is ready.\n`);
+        await update(cmd.id, 'completed', { log, engine: engine.id });
+        // Push the new capability immediately so the tab flips without waiting
+        // for the next 30s heartbeat.
+        await (0, heartbeat_1.beat)();
+    }
+    catch (err) {
+        await update(cmd.id, 'failed', { log }, err.message.slice(0, 600));
+    }
+}
 /* ── dispatcher ──────────────────────────────────────────────────────── */
 async function execute(cmd) {
     // Not a harness command — dispatch before the harness lookup, which would
@@ -685,6 +721,10 @@ async function execute(cmd) {
         await runSetAutostart(cmd);
         return;
     }
+    if (cmd.kind === 'install_engine') {
+        await runInstallEngine(cmd);
+        return;
+    }
     if (DESKTOP_KINDS.includes(cmd.kind)) {
         await runDesktopCommand(cmd);
         return;

package/dist/desktop/install-engine.d.ts

@@ -0,0 +1,12 @@
+export interface InstallPlan {
+    /** Null when this platform has no unattended path we trust. */
+    file: string | null;
+    args: string[];
+    /** What a human would have to run, shown when we cannot do it ourselves. */
+    manual: string;
+    needsRoot: boolean;
+}
+/** Pure, so the choice is testable on any machine. */
+export declare function installPlan(platform: NodeJS.Platform, isRoot: boolean): InstallPlan;
+export declare function runningAsRoot(): boolean;
+export declare function installEngine(onLog: (s: string) => void): Promise<void>;

package/dist/desktop/install-engine.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPlan = installPlan;
+exports.runningAsRoot = runningAsRoot;
+exports.installEngine = installEngine;
+// Install a container engine on this machine, on request.
+//
+// Deliberately per-platform and deliberately honest about privilege: the
+// Linux path needs root, and a daemon running as an ordinary user cannot get
+// it. Rather than half-run and leave a broken apt state, it checks first and
+// says exactly what to do instead. A button that fails clearly beats one that
+// fails mysteriously.
+const child_process_1 = require("child_process");
+const win_1 = require("../win");
+/** Pure, so the choice is testable on any machine. */
+function installPlan(platform, isRoot) {
+    if (platform === 'darwin') {
+        // Homebrew installs Docker Desktop without sudo when brew owns its prefix.
+        return {
+            file: 'brew', args: ['install', '--cask', '--no-quarantine', 'docker'],
+            manual: 'brew install --cask docker', needsRoot: false,
+        };
+    }
+    if (platform === 'win32') {
+        return {
+            file: 'winget',
+            args: ['install', '-e', '--id', 'Docker.DockerDesktop', '--accept-package-agreements', '--accept-source-agreements'],
+            manual: 'winget install -e --id Docker.DockerDesktop', needsRoot: false,
+        };
+    }
+    // Linux: get.docker.com is the vendor's own script and needs root. Podman
+    // from the distro is the lighter option but still needs a package manager.
+    return {
+        file: isRoot ? 'sh' : null,
+        args: ['-c', 'curl -fsSL https://get.docker.com | sh'],
+        manual: 'curl -fsSL https://get.docker.com | sudo sh', needsRoot: true,
+    };
+}
+function runningAsRoot() {
+    return typeof process.getuid === 'function' && process.getuid() === 0;
+}
+async function installEngine(onLog) {
+    const plan = installPlan(process.platform, runningAsRoot());
+    if (!plan.file) {
+        throw new Error(`This needs root, and the node is not running as root. Run this on ${require('os').hostname()}:\n  ${plan.manual}`);
+    }
+    onLog(`installing a container engine\n  ${plan.manual}\n\n`);
+    const inv = (0, win_1.resolveCliInvocation)(plan.file, plan.args);
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(inv.file, inv.args, {
+            env: process.env, windowsHide: true, timeout: 25 * 60_000,
+        });
+        let tail = '';
+        const cap = (b) => { const s = b.toString('utf8'); tail = (tail + s).slice(-2000); onLog(s); };
+        child.stdout?.on('data', cap);
+        child.stderr?.on('data', cap);
+        child.on('error', err => reject(new Error(`${plan.file} is not available here. Install it by hand:\n  ${plan.manual}\n(${err.message})`)));
+        child.on('exit', code => code === 0
+            ? resolve()
+            : reject(new Error(`install failed (exit ${code}). Try by hand:\n  ${plan.manual}\n${tail.slice(-400)}`)));
+    });
+}

package/dist/desktop/open-viewer.d.ts

@@ -0,0 +1,17 @@
+export interface ViewerTarget {
+    vncPort: number | null;
+    vncPassword: string | null;
+    desktopId: string;
+}
+/** What we would run, as a pure value, so the choice is testable without
+ *  launching anything. */
+export declare function viewerCommand(platform: NodeJS.Platform, t: ViewerTarget, studioBase?: string): {
+    file: string;
+    args: string[];
+    kind: 'local' | 'browser';
+} | null;
+export declare function openViewer(t: ViewerTarget): {
+    ok: boolean;
+    kind: string;
+    error?: string;
+};

package/dist/desktop/open-viewer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewerCommand = viewerCommand;
+exports.openViewer = openViewer;
+// Open a desktop in whatever this machine calls a screen viewer.
+//
+// A terminal cannot draw a remote framebuffer, so "control it from the
+// console" means handing the desktop to something that can. macOS has a VNC
+// client built in and the RFB port is already on loopback, so Screen Sharing
+// connects straight to the container with no relay in the path - the lowest
+// latency route there is. Windows has no built-in VNC client, so there the
+// browser viewer is the honest fallback.
+const child_process_1 = require("child_process");
+/** What we would run, as a pure value, so the choice is testable without
+ *  launching anything. */
+function viewerCommand(platform, t, studioBase = 'https://entities.add.ai') {
+    if (platform === 'darwin' && t.vncPort) {
+        // The password rides in the URL so Screen Sharing does not prompt. It
+        // never leaves this machine: the whole URL is handed to a local app.
+        const auth = t.vncPassword ? `:${encodeURIComponent(t.vncPassword)}@` : '';
+        return { file: 'open', args: [`vnc://${auth}127.0.0.1:${t.vncPort}`], kind: 'local' };
+    }
+    const url = `${studioBase}/desktops/${t.desktopId}`;
+    if (platform === 'win32')
+        return { file: 'cmd', args: ['/c', 'start', '', url], kind: 'browser' };
+    return { file: 'xdg-open', args: [url], kind: 'browser' };
+}
+function openViewer(t) {
+    const cmd = viewerCommand(process.platform, t);
+    if (!cmd)
+        return { ok: false, kind: 'none', error: 'no viewer for this platform' };
+    try {
+        const child = (0, child_process_1.spawn)(cmd.file, cmd.args, { detached: true, stdio: 'ignore' });
+        child.unref();
+        return { ok: true, kind: cmd.kind };
+    }
+    catch (err) {
+        return { ok: false, kind: cmd.kind, error: err.message };
+    }
+}

package/dist/desktop/relay-client.js

@@ -68,7 +68,10 @@ let idleTimer = null;
 let liveTimer = null;
 /** Set on every pong; cleared when a ping goes out. Two misses = dead. */
 let missedPongs = 0;
-/** desktopId -> the local TCP socket to that desktop's published RFB port. */
+/** 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()) {
@@ -155,24 +158,24 @@ 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 = () => {

package/dist/tui/dashboard.d.ts

@@ -86,5 +86,6 @@ export declare function createDashboardScreen(deps: {
     openTranscript(r: RequestRow): void;
     openRequests(): void;
     openHarnesses(): void;
+    openDesktops(): void;
     openLogs(): void;
 }): Screen;

package/dist/tui/dashboard.js

@@ -26,6 +26,7 @@ const autostart_1 = require("../autostart");
 exports.MENU = [
     { key: 'activity', label: 'Activity', hint: 'Every request this node has handled', shortcut: 'a' },
     { key: 'harnesses', label: 'Harnesses', hint: 'Install / log in agent CLIs', shortcut: 'h' },
+    { key: 'desktops', label: 'Desktops', hint: 'Isolated environments entities work in', shortcut: 'd' },
     { key: 'logs', label: 'Logs', hint: 'What the daemon is saying', shortcut: 'l' },
 ];
 /** Live rows the NOW band shows before it starts counting the rest. */
@@ -388,6 +389,7 @@ function createDashboardScreen(deps) {
             { keys: '⏎', label: 'open the destination, or watch the selected run' },
             { keys: 'a', label: 'activity — full request history' },
             { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
+            { keys: 'd', label: 'desktops — the environments entities work in' },
             { keys: 'l', label: 'logs — daemon output' },
             { keys: 's', label: 'start this node at login (on / off)' },
             { keys: 'r', label: 'refresh now' },
@@ -412,6 +414,10 @@ function createDashboardScreen(deps) {
                 deps.openHarnesses();
                 return;
             }
+            if (key.name === 'd') {
+                deps.openDesktops();
+                return;
+            }
             if (key.name === 'l') {
                 deps.openLogs();
                 return;
@@ -445,6 +451,8 @@ function createDashboardScreen(deps) {
                 const target = exports.MENU[st.sel]?.key;
                 if (target === 'harnesses')
                     deps.openHarnesses();
+                else if (target === 'desktops')
+                    deps.openDesktops();
                 else if (target === 'logs')
                     deps.openLogs();
                 else

package/dist/tui/desktops.d.ts

@@ -0,0 +1,11 @@
+import type { DesktopRow } from '../desktop/spec';
+import { type AppHost, type Screen } from './app';
+/** A desktop with a recent tool call is being worked in right now. Same 90s
+ *  definition the chat card uses, so the console and chat never disagree. */
+export declare function isBusyWith(row: {
+    last_used_at?: string | null;
+}): boolean;
+export declare function desktopLine(d: DesktopRow, selected: boolean, width: number): string;
+export declare function createDesktopsScreen(deps: {
+    host: AppHost;
+}): Screen;

package/dist/tui/desktops.js

@@ -0,0 +1,201 @@
+"use strict";
+// The desktops on this machine, and what is happening in them.
+//
+// A screen on the stack like Harnesses, so it inherits the diff painter, the
+// footer grammar and `?` help for free. Actions go through the same command
+// path Studio uses rather than touching docker directly — one way to start a
+// desktop, whoever asked for it, so the two surfaces can never disagree.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBusyWith = isBusyWith;
+exports.desktopLine = desktopLine;
+exports.createDesktopsScreen = createDesktopsScreen;
+const manager_1 = require("../desktop/manager");
+const docker_1 = require("../desktop/docker");
+const open_viewer_1 = require("../desktop/open-viewer");
+const render_1 = require("./render");
+const app_1 = require("./app");
+function tone(status) {
+    if (status === 'running')
+        return render_1.green;
+    if (status === 'failed')
+        return render_1.red;
+    if (status === 'creating' || status === 'starting' || status === 'deleting')
+        return render_1.yellow;
+    return render_1.grey;
+}
+/** A desktop with a recent tool call is being worked in right now. Same 90s
+ *  definition the chat card uses, so the console and chat never disagree. */
+function isBusyWith(row) {
+    if (!row.last_used_at)
+        return false;
+    return Date.now() - new Date(row.last_used_at).getTime() < 90_000;
+}
+function desktopLine(d, selected, width) {
+    const mark = selected ? (0, render_1.bold)('▸ ') : '  ';
+    const status = tone(d.status)(d.status.padEnd(9));
+    const size = (0, render_1.grey)(`${d.cpus}c ${Math.round(d.memory_mb / 1024)}g`);
+    const port = d.vnc_port ? (0, render_1.grey)(`:${d.vnc_port}`) : (0, render_1.grey)('—');
+    const name = (0, render_1.truncate)(d.name, Math.max(12, width - 34));
+    return `${mark}${status} ${name.padEnd(Math.max(12, width - 34))} ${size} ${port}`;
+}
+function createDesktopsScreen(deps) {
+    const st = { rows: null, sel: 0, spin: 0, busy: null, confirmDelete: null, note: null };
+    const current = () => st.rows?.[st.sel] ?? null;
+    const act = async (label, fn) => {
+        st.busy = label;
+        deps.host.redraw();
+        try {
+            await fn();
+            st.note = null;
+        }
+        catch (err) {
+            st.note = err.message.slice(0, 120);
+        }
+        finally {
+            st.busy = null;
+            await refresh();
+            deps.host.redraw();
+        }
+    };
+    const refresh = async () => {
+        try {
+            st.rows = await (0, manager_1.listDesktops)();
+        }
+        catch (err) {
+            st.note = err.message.slice(0, 120);
+            st.rows = st.rows ?? [];
+        }
+        if (st.sel >= (st.rows?.length ?? 0))
+            st.sel = Math.max(0, (st.rows?.length ?? 1) - 1);
+    };
+    return {
+        id: 'desktops',
+        title: 'Desktops',
+        async poll() { await refresh(); },
+        pollMs: () => 5_000,
+        tick(n) { st.spin = n; return st.busy !== null; },
+        keys() {
+            return [
+                { keys: '↑/↓', label: 'choose a desktop' },
+                { keys: '↵', label: 'open it — Screen Sharing on this Mac' },
+                { keys: 's', label: 'start / stop' },
+                { keys: 'r', label: 'rebuild from the image' },
+                { keys: 'd', label: 'delete (asks first)' },
+            ];
+        },
+        render(width, height) {
+            const out = [];
+            out.push((0, app_1.heading)('Desktops', 'on this machine'));
+            out.push('');
+            if (st.rows === null) {
+                out.push((0, render_1.dim)(`  ${render_1.SPIN[st.spin % render_1.SPIN.length]} looking…`));
+                return out;
+            }
+            if (st.rows.length === 0) {
+                out.push((0, render_1.dim)('  No desktops here yet.'));
+                out.push('');
+                out.push((0, render_1.dim)('  Create one from the machine\'s page in Entity Studio.'));
+                return out;
+            }
+            const live = st.rows.filter(d => d.status === 'running').length;
+            out.push((0, render_1.dim)(`  ${live} running · ${st.rows.length} total`));
+            out.push('');
+            const room = Math.max(3, height - 8);
+            st.rows.slice(0, room).forEach((d, i) => out.push(desktopLine(d, i === st.sel, width)));
+            const sel = current();
+            if (sel?.status_message) {
+                out.push('');
+                out.push((0, render_1.dim)(`  ${(0, render_1.truncate)(sel.status_message, width - 4)}`));
+            }
+            if (st.busy) {
+                out.push('');
+                out.push((0, render_1.dim)(`  ${render_1.SPIN[st.spin % render_1.SPIN.length]} ${st.busy}…`));
+            }
+            if (st.confirmDelete) {
+                out.push('');
+                out.push((0, render_1.red)(`  Delete "${st.confirmDelete}"? y to confirm, any other key to keep it.`));
+            }
+            if (st.note) {
+                out.push('');
+                out.push((0, render_1.red)(`  ${(0, render_1.truncate)(st.note, width - 4)}`));
+            }
+            out.push('');
+            out.push((0, app_1.footerHint)(this.keys ? this.keys() : []));
+            return out;
+        },
+        async onKey(key) {
+            if (st.confirmDelete) {
+                const name = st.confirmDelete;
+                st.confirmDelete = null;
+                if (key.name !== 'y') {
+                    deps.host.redraw();
+                    return;
+                }
+                const row = st.rows?.find(d => d.name === name);
+                if (row) {
+                    await act('deleting', async () => {
+                        const p = await (0, docker_1.getProvider)();
+                        if (!p)
+                            throw new Error('no container engine on this machine');
+                        await p.remove(row);
+                        await (0, manager_1.setStatus)(row.id, { status: 'deleting' });
+                    });
+                }
+                return;
+            }
+            const rows = st.rows ?? [];
+            if (key.name === 'up') {
+                st.sel = Math.max(0, st.sel - 1);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'down') {
+                st.sel = Math.min(rows.length - 1, st.sel + 1);
+                deps.host.redraw();
+                return;
+            }
+            const row = current();
+            if (!row)
+                return;
+            if (key.name === 'return') {
+                if (row.status !== 'running') {
+                    st.note = 'Start it first — there is nothing to show yet.';
+                    deps.host.redraw();
+                    return;
+                }
+                const r = (0, open_viewer_1.openViewer)({ vncPort: row.vnc_port, vncPassword: row.vnc_password, desktopId: row.id });
+                st.note = r.ok
+                    ? (r.kind === 'local' ? 'Opening in Screen Sharing…' : 'Opening the viewer in your browser…')
+                    : `Could not open it: ${r.error ?? 'unknown'}`;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 's') {
+                await act(row.status === 'running' ? 'stopping' : 'starting', async () => {
+                    const p = await (0, docker_1.getProvider)();
+                    if (!p)
+                        throw new Error('no container engine on this machine');
+                    if (row.status === 'running') {
+                        await p.stop(row);
+                        await (0, manager_1.setStatus)(row.id, { status: 'stopped' });
+                    }
+                    else {
+                        await p.start(row);
+                        await (0, manager_1.setStatus)(row.id, { status: 'running', status_message: null });
+                    }
+                });
+                return;
+            }
+            if (key.name === 'r') {
+                st.note = 'Rebuild runs from Entity Studio — it re-pulls the image and copies logins in.';
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'd') {
+                st.confirmDelete = row.name;
+                deps.host.redraw();
+                return;
+            }
+        },
+    };
+}

package/dist/tui/run.js

@@ -48,6 +48,7 @@ const dashboard_1 = require("./dashboard");
 const requests_1 = require("./requests");
 const transcript_1 = require("./transcript");
 const harnesses_1 = require("./harnesses");
+const desktops_1 = require("./desktops");
 const logs_1 = require("./logs");
 const render_1 = require("./render");
 const console_capture_1 = require("./console-capture");
@@ -208,6 +209,7 @@ async function runDashboard(opts) {
             openTranscript,
             openRequests: () => host.push((0, requests_1.createRequestsScreen)({ data, host, openTranscript })),
             openHarnesses: () => host.push((0, harnesses_1.createHarnessesScreen)({ host, suspend })),
+            openDesktops: () => host.push((0, desktops_1.createDesktopsScreen)({ host })),
             openLogs: () => host.push((0, logs_1.createLogsScreen)({
                 host,
                 logs,

package/package.json

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