@addai/node 0.15.0 → 0.18.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,63 @@ 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, async () => {
+            // Park the command and let Studio collect it, exactly as a harness
+            // login collects a paste-back code.
+            await update(cmd.id, 'awaiting_input', { needs: 'sudo_password', log });
+            const deadline = Date.now() + INPUT_WAIT_MS;
+            while (Date.now() < deadline) {
+                const row = await pollRow(cmd.id);
+                if (!row)
+                    break;
+                if (row.status === 'canceled')
+                    return null;
+                const pw = row.input?.sudo_password;
+                if (pw) {
+                    // Wipe it from the row the moment we hold it. It exists in one
+                    // process's memory from here, and nowhere else.
+                    const t = token();
+                    if (t) {
+                        try {
+                            await (0, supabase_client_1.rpc)('runtime_command_clear_input', { p_token: t, p_id: cmd.id });
+                        }
+                        catch { /* best effort — the install still must not print it */ }
+                    }
+                    await update(cmd.id, 'running', { needs: null, log });
+                    return pw;
+                }
+                await new Promise(r => setTimeout(r, INPUT_POLL_MS));
+            }
+            return null;
+        });
+        (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 +749,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/docker.js

@@ -35,7 +35,7 @@ class CliProvider {
         });
     }
     async probe() {
-        return { id: this.id, version: this.version };
+        return { id: this.id, version: this.version, running: true };
     }
     async create(row, opts, onLog) {
         // Pull first so the slow, chatty image download streams into the command
@@ -93,7 +93,10 @@ async function getProvider(force = false) {
     if (!force && cached !== undefined)
         return cached;
     const info = await (0, engine_1.detectEngine)();
-    cached = info ? new CliProvider(info.id, info.version) : null;
+    // An engine whose daemon is not answering is not a provider: every call
+    // through it would fail at the socket. Studio reports the reason from the
+    // capability probe instead.
+    cached = info?.running ? new CliProvider(info.id, info.version) : null;
     return cached;
 }
 function resetProviderCache() { cached = undefined; }

package/dist/desktop/engine.d.ts

@@ -1,3 +1,15 @@
 import { EngineInfo } from './provider';
 export declare function parseEngineVersion(stdout: string): string | null;
+/** Why an installed engine still cannot run anything. The three causes are
+ *  worth telling apart, because the fix for each is different and none of
+ *  them is "install Docker". */
+export declare function explainUnreachable(output: string, platform: NodeJS.Platform): string;
+/**
+ * Is there an engine here that can actually RUN something?
+ *
+ * `--version` is not enough: the CLI answers it with no daemon at all, so a
+ * machine where Docker Desktop is installed-but-closed, or where the user is
+ * not in the docker group, would report itself ready and then fail on every
+ * create. `info` is the question that needs the daemon, so it is the one asked.
+ */
 export declare function detectEngine(): Promise<EngineInfo | null>;

package/dist/desktop/engine.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEngineVersion = parseEngineVersion;
+exports.explainUnreachable = explainUnreachable;
 exports.detectEngine = detectEngine;
 // Which container engine is on this machine? Docker first (the verified
 // path), Podman second. Never installs anything: installing Docker Desktop
@@ -12,33 +13,61 @@ function parseEngineVersion(stdout) {
     const m = /version\s+v?(\d+\.\d+\.\d+)/i.exec(stdout);
     return m ? m[1] : null;
 }
-function runVersion(binary) {
+/** Run a command and hand back exit code + output. */
+function run(binary, args) {
     return new Promise(resolve => {
         try {
-            const inv = (0, win_1.resolveCliInvocation)(binary, ['--version']);
+            const inv = (0, win_1.resolveCliInvocation)(binary, args);
             const child = (0, child_process_1.spawn)(inv.file, inv.args, {
                 env: process.env, windowsHide: true, timeout: 8_000,
             });
             let out = '';
             child.stdout?.on('data', b => { out += b.toString('utf8'); });
-            child.on('error', () => resolve(null));
-            child.on('exit', code => resolve(code === 0 ? out : null));
+            child.stderr?.on('data', b => { out += b.toString('utf8'); });
+            child.on('error', () => resolve({ ok: false, out: '' }));
+            child.on('exit', code => resolve({ ok: code === 0, out }));
         }
         catch {
             // resolveCliInvocation throws when a Windows shim can't be resolved -
             // that is "not installed" as far as this probe is concerned.
-            resolve(null);
+            resolve({ ok: false, out: '' });
         }
     });
 }
+/** Why an installed engine still cannot run anything. The three causes are
+ *  worth telling apart, because the fix for each is different and none of
+ *  them is "install Docker". */
+function explainUnreachable(output, platform) {
+    const t = output.toLowerCase();
+    if (t.includes('permission denied') || t.includes('dial unix')) {
+        return 'Docker is installed but this user cannot reach it. Add the user to the docker group:\n  sudo usermod -aG docker $USER   (then log out and back in)';
+    }
+    if (platform === 'darwin')
+        return 'Docker is installed but not running. Open Docker Desktop once and leave it running.';
+    if (platform === 'win32')
+        return 'Docker is installed but not running. Start Docker Desktop and let it finish starting.';
+    return 'Docker is installed but its daemon is not answering. Start it:\n  sudo systemctl start docker';
+}
+/**
+ * Is there an engine here that can actually RUN something?
+ *
+ * `--version` is not enough: the CLI answers it with no daemon at all, so a
+ * machine where Docker Desktop is installed-but-closed, or where the user is
+ * not in the docker group, would report itself ready and then fail on every
+ * create. `info` is the question that needs the daemon, so it is the one asked.
+ */
 async function detectEngine() {
     for (const id of ['docker', 'podman']) {
-        const out = await runVersion(id);
-        if (!out)
+        const v = await run(id, ['--version']);
+        if (!v.ok)
+            continue;
+        const version = parseEngineVersion(v.out);
+        if (!version)
             continue;
-        const version = parseEngineVersion(out);
-        if (version)
-            return { id, version };
+        const info = await run(id, ['info', '--format', '{{.ServerVersion}}']);
+        if (info.ok)
+            return { id, version, running: true };
+        return { id, version, running: false, reason: explainUnreachable(info.out, process.platform) };
     }
     return null;
 }

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

@@ -0,0 +1,20 @@
+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;
+/** Build the argv for a privileged install. The password NEVER goes in argv —
+ *  argv is world-readable through /proc on Linux, so anyone with a shell on
+ *  the box could read it. `-S` makes sudo take it on stdin instead, and
+ *  `-p ''` stops it printing a prompt into the log we stream back. */
+export declare function sudoArgv(inner: string): {
+    file: string;
+    args: string[];
+};
+export declare function installEngine(onLog: (s: string) => void, askPassword?: () => Promise<string | null>): Promise<void>;

package/dist/desktop/install-engine.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPlan = installPlan;
+exports.runningAsRoot = runningAsRoot;
+exports.sudoArgv = sudoArgv;
+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;
+}
+/** Build the argv for a privileged install. The password NEVER goes in argv —
+ *  argv is world-readable through /proc on Linux, so anyone with a shell on
+ *  the box could read it. `-S` makes sudo take it on stdin instead, and
+ *  `-p ''` stops it printing a prompt into the log we stream back. */
+function sudoArgv(inner) {
+    return { file: 'sudo', args: ['-S', '-p', '', 'sh', '-c', inner] };
+}
+async function installEngine(onLog, askPassword) {
+    const plan = installPlan(process.platform, runningAsRoot());
+    let file = plan.file;
+    let args = plan.args;
+    let password = null;
+    if (!file && plan.needsRoot && askPassword) {
+        onLog('This machine needs a sudo password to install Docker.\n');
+        password = await askPassword();
+        if (!password) {
+            throw new Error(`No password given. Run it on the machine instead:\n  ${plan.manual}`);
+        }
+        const sudo = sudoArgv(plan.args[1] ?? '');
+        file = sudo.file;
+        args = sudo.args;
+    }
+    if (!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)(file, 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,
+            stdio: password ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+        });
+        if (password) {
+            // Straight down stdin and gone. It is never echoed, never logged, and
+            // the caller wipes it from the row as soon as it reaches here.
+            child.stdin?.write(`${password}\n`);
+            child.stdin?.end();
+            password = null;
+        }
+        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(`${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/provider.d.ts

@@ -2,6 +2,11 @@ import { DesktopRow } from './spec';
 export interface EngineInfo {
     id: 'docker' | 'podman';
     version: string;
+    /** The CLI exists AND its daemon answers. False means installed but
+     *  unusable — a different problem, with a different fix, than missing. */
+    running: boolean;
+    /** Set when running is false: what to do about it, in words. */
+    reason?: string;
 }
 export interface ExecOpts {
     cwd: string;

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.15.0",
+  "version": "0.18.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": [