@addai/node 0.11.3 → 0.13.0

package/dist/command-runner.js

@@ -45,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setRestartHook = setRestartHook;
 exports.wake = wake;
 const child_process_1 = require("child_process");
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -59,6 +60,9 @@ const self_update_1 = require("./self-update");
 const autostart_1 = require("./autostart");
 const paths_1 = require("./paths");
 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 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. */
@@ -557,6 +561,115 @@ async function runSetAutostart(cmd) {
     }
     await update(cmd.id, 'completed', { autostart: state });
 }
+/* ── desktops ────────────────────────────────────────────────────────────
+ * All six desktop_* kinds. Progress streams into the command payload the
+ * same way install_harness does, so Studio's existing live-log panel renders
+ * the image pull with no new component. */
+const DESKTOP_KINDS = [
+    'desktop_create', 'desktop_start', 'desktop_stop',
+    'desktop_delete', 'desktop_rebuild', 'desktop_sync_logins',
+];
+/** Setup scripts run as a FILE, never as a `sh -c` string: a script with
+ *  quotes or newlines must not need escaping to survive. */
+async function runSetupScript(provider, row, onLog) {
+    const { confDir } = (0, manager_1.ensureDirs)(row.id);
+    fs.writeFileSync(path.join(confDir, 'setup.sh'), row.setup_script ?? '', { mode: 0o700 });
+    await (0, creds_1.execInDesktop)(provider, row, ['bash', '/conf/setup.sh'], onLog);
+}
+async function runDesktopCommand(cmd) {
+    if (!cmd.desktop_id) {
+        await update(cmd.id, 'failed', undefined, 'no desktop on command');
+        return;
+    }
+    // force: a user who just installed Docker should not have to restart the
+    // daemon for their first desktop to build.
+    const provider = await (0, docker_1.getProvider)(true);
+    if (!provider) {
+        const why = 'No container engine on this machine. Install Docker Desktop or Podman, then try again.';
+        await update(cmd.id, 'failed', undefined, why);
+        await (0, manager_1.setStatus)(cmd.desktop_id, { status: 'failed', status_message: why });
+        return;
+    }
+    const rows = await (0, manager_1.listDesktops)();
+    const row = rows.find(r => r.id === cmd.desktop_id);
+    if (!row) {
+        await update(cmd.id, 'failed', undefined, 'desktop row not found');
+        return;
+    }
+    let log = '';
+    const onLog = (chunk) => {
+        log = (log + chunk).slice(-LOG_TAIL_CHARS);
+        void update(cmd.id, null, { log });
+    };
+    try {
+        await update(cmd.id, 'running', { log });
+        switch (cmd.kind) {
+            case 'desktop_create':
+            case 'desktop_rebuild': {
+                if (cmd.kind === 'desktop_rebuild') {
+                    onLog('removing existing container\n');
+                    await provider.remove(row);
+                }
+                await (0, manager_1.setStatus)(row.id, { status: 'creating', status_message: null });
+                const { confDir, workDir } = (0, manager_1.ensureDirs)(row.id);
+                const vncPort = await (0, manager_1.allocateVncPort)();
+                // A fresh password on every build; it only ever travels between the
+                // daemon and the container on the same machine.
+                const vncPassword = crypto.randomBytes(12).toString('base64url');
+                const built = { ...row, vnc_password: vncPassword };
+                const containerId = await provider.create(built, { confDir, workDir, vncPort }, onLog);
+                await (0, manager_1.setStatus)(row.id, {
+                    status: 'running', container_id: containerId,
+                    engine: provider.id, vnc_port: vncPort, status_message: null,
+                });
+                await (0, creds_1.syncCredentials)(provider, built, onLog);
+                if (row.setup_script) {
+                    onLog('running setup script\n');
+                    try {
+                        await runSetupScript(provider, built, onLog);
+                    }
+                    catch (err) {
+                        // The desktop exists and works; the script did not. Record it and
+                        // do not destroy the box the user just waited minutes for.
+                        await (0, manager_1.setStatus)(row.id, {
+                            status_message: `Setup script failed: ${err.message}`.slice(0, 400),
+                        });
+                    }
+                }
+                break;
+            }
+            case 'desktop_start':
+                await (0, manager_1.setStatus)(row.id, { status: 'starting' });
+                await provider.start(row);
+                await (0, manager_1.setStatus)(row.id, { status: 'running', status_message: null });
+                break;
+            case 'desktop_stop':
+                await provider.stop(row);
+                await (0, manager_1.setStatus)(row.id, { status: 'stopped', status_message: null });
+                break;
+            case 'desktop_delete': {
+                await provider.remove(row);
+                // The server keeps the row until the machine confirms, so a delete
+                // issued to an offline node is not lost.
+                const t = token();
+                if (t)
+                    await (0, supabase_client_1.rpc)('runtime_desktop_deleted', { p_token: t, p_desktop_id: row.id });
+                break;
+            }
+            case 'desktop_sync_logins':
+                await (0, creds_1.syncCredentials)(provider, row, onLog);
+                break;
+        }
+        await update(cmd.id, 'completed', { log });
+    }
+    catch (err) {
+        const message = err.message.slice(0, 500);
+        await update(cmd.id, 'failed', { log }, message);
+        if (cmd.kind !== 'desktop_delete') {
+            await (0, manager_1.setStatus)(row.id, { status: 'failed', status_message: message });
+        }
+    }
+}
 /* ── dispatcher ──────────────────────────────────────────────────────── */
 async function execute(cmd) {
     // Not a harness command — dispatch before the harness lookup, which would
@@ -569,6 +682,10 @@ async function execute(cmd) {
         await runSetAutostart(cmd);
         return;
     }
+    if (DESKTOP_KINDS.includes(cmd.kind)) {
+        await runDesktopCommand(cmd);
+        return;
+    }
     const spec = (0, harness_registry_1.harness)(cmd.harness ?? '');
     if (!spec) {
         await update(cmd.id, 'failed', {}, `unknown harness: ${cmd.harness}`);

package/dist/desktop/creds.d.ts

@@ -0,0 +1,7 @@
+import { DesktopRow } from './spec';
+import { DesktopProvider } from './provider';
+/** Keep the auth fields, drop host MCP servers and project history. */
+export declare function stripMcpServers(raw: string): string;
+/** Run a command inside a desktop, streaming output to onLog. */
+export declare function execInDesktop(provider: DesktopProvider, row: DesktopRow, cmd: string[], onLog: (c: string) => void): Promise<void>;
+export declare function syncCredentials(provider: DesktopProvider, row: DesktopRow, onLog: (c: string) => void): Promise<void>;

package/dist/desktop/creds.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripMcpServers = stripMcpServers;
+exports.execInDesktop = execInDesktop;
+exports.syncCredentials = syncCredentials;
+// Harness logins are COPIED into a desktop, never bind-mounted.
+//
+// Bind-mounting ~/.claude would hand the box write access to every transcript
+// on this machine - which defeats the isolation the desktop exists for. The
+// entity already effectively holds these tokens, so copying the auth blob
+// costs nothing; the host's project history and MCP servers are what must not
+// travel, so they are stripped here.
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const win_1 = require("../win");
+const provider_1 = require("./provider");
+/** Keep the auth fields, drop host MCP servers and project history. */
+function stripMcpServers(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== 'object')
+            throw new Error('not an object');
+    }
+    catch {
+        return '{"mcpServers":{}}';
+    }
+    delete parsed.projects;
+    parsed.mcpServers = {};
+    return JSON.stringify(parsed);
+}
+/** Run a command inside a desktop, streaming output to onLog. */
+function execInDesktop(provider, row, cmd, onLog) {
+    const args = (0, provider_1.buildExecArgs)(row, cmd, { cwd: '/work', env: {}, tty: false });
+    const inv = (0, win_1.resolveCliInvocation)(provider.id, args);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(inv.file, inv.args, {
+            env: process.env, windowsHide: true, timeout: 10 * 60_000,
+        });
+        let err = '';
+        child.stdout?.on('data', b => onLog(b.toString('utf8')));
+        child.stderr?.on('data', b => { const s = b.toString('utf8'); err += s; onLog(s); });
+        child.on('error', reject);
+        child.on('exit', code => code === 0
+            ? resolve()
+            : reject(new Error(err.trim().slice(0, 400) || `exit ${code}`)));
+    });
+}
+/** Write a file into the container through stdin, so contents with quotes,
+ *  newlines or ESC bytes survive verbatim - nothing is ever interpolated
+ *  into a shell string. */
+function writeInto(provider, row, dest, contents) {
+    const args = (0, provider_1.buildExecArgs)(row, ['sh', '-c', 'mkdir -p "$(dirname "$1")" && cat > "$1"', '_', dest], { cwd: '/work', env: {}, tty: false });
+    const inv = (0, win_1.resolveCliInvocation)(provider.id, args);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(inv.file, inv.args, { env: process.env, windowsHide: true });
+        child.on('error', reject);
+        child.on('exit', code => code === 0
+            ? resolve()
+            : reject(new Error(`write ${dest} failed (exit ${code})`)));
+        child.stdin?.end(contents);
+    });
+}
+function credFiles() {
+    const home = os.homedir();
+    return [
+        {
+            hostPath: path.join(home, '.claude.json'),
+            destPath: '/home/entity/.claude.json',
+            transform: stripMcpServers,
+        },
+        { hostPath: path.join(home, '.claude', '.credentials.json'),
+            destPath: '/home/entity/.claude/.credentials.json' },
+        { hostPath: path.join(home, '.codex', 'auth.json'),
+            destPath: '/home/entity/.codex/auth.json' },
+        { hostPath: path.join(home, '.gemini', 'oauth_creds.json'),
+            destPath: '/home/entity/.gemini/oauth_creds.json' },
+    ];
+}
+async function syncCredentials(provider, row, onLog) {
+    for (const f of credFiles()) {
+        let raw;
+        try {
+            raw = fs.readFileSync(f.hostPath, 'utf8');
+        }
+        catch {
+            continue;
+        } // not logged in here: nothing to copy
+        const body = f.transform ? f.transform(raw) : raw;
+        try {
+            await writeInto(provider, row, f.destPath, body);
+            onLog(`copied ${path.basename(f.destPath)}\n`);
+        }
+        catch (err) {
+            // One missing login must not abort the others.
+            onLog(`could not copy ${path.basename(f.destPath)}: ${err.message}\n`);
+        }
+    }
+}

package/dist/desktop/docker.d.ts

@@ -0,0 +1,19 @@
+import { DesktopRow } from './spec';
+import { DesktopProvider, EngineInfo, CreateOpts } from './provider';
+export declare class CliProvider implements DesktopProvider {
+    readonly id: 'docker' | 'podman';
+    private version;
+    constructor(id: 'docker' | 'podman', version: string);
+    private run;
+    probe(): Promise<EngineInfo | null>;
+    create(row: DesktopRow, opts: CreateOpts, onLog: (c: string) => void): Promise<string>;
+    start(row: DesktopRow): Promise<void>;
+    stop(row: DesktopRow): Promise<void>;
+    remove(row: DesktopRow): Promise<void>;
+    inspect(row: DesktopRow): Promise<{
+        running: boolean;
+        containerId: string;
+    } | null>;
+}
+export declare function getProvider(force?: boolean): Promise<DesktopProvider | null>;
+export declare function resetProviderCache(): void;

package/dist/desktop/docker.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliProvider = void 0;
+exports.getProvider = getProvider;
+exports.resetProviderCache = resetProviderCache;
+// Docker/Podman backend. One class serves both: the CLI surface we use
+// (run/start/stop/rm/inspect/exec) is compatible between them.
+const child_process_1 = require("child_process");
+const win_1 = require("../win");
+const provider_1 = require("./provider");
+const engine_1 = require("./engine");
+class CliProvider {
+    id;
+    version;
+    constructor(id, version) {
+        this.id = id;
+        this.version = version;
+    }
+    run(args, onLog, timeoutMs = 15 * 60_000) {
+        return new Promise(resolve => {
+            let stdout = '', stderr = '';
+            try {
+                const inv = (0, win_1.resolveCliInvocation)(this.id, args);
+                const child = (0, child_process_1.spawn)(inv.file, inv.args, {
+                    env: process.env, windowsHide: true, timeout: timeoutMs,
+                });
+                child.stdout?.on('data', b => { const s = b.toString('utf8'); stdout += s; onLog?.(s); });
+                child.stderr?.on('data', b => { const s = b.toString('utf8'); stderr += s; onLog?.(s); });
+                child.on('error', err => resolve({ ok: false, stdout, stderr: String(err) }));
+                child.on('exit', code => resolve({ ok: code === 0, stdout, stderr }));
+            }
+            catch (err) {
+                resolve({ ok: false, stdout, stderr: err.message });
+            }
+        });
+    }
+    async probe() {
+        return { id: this.id, version: this.version };
+    }
+    async create(row, opts, onLog) {
+        // Pull first so the slow, chatty image download streams into the command
+        // 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)}`);
+        onLog(`creating ${(0, provider_1.containerName)(row)}\n`);
+        const res = await this.run((0, provider_1.buildCreateArgs)(row, opts), onLog);
+        if (!res.ok)
+            throw new Error(`create failed: ${res.stderr.trim().slice(0, 500)}`);
+        return res.stdout.trim().split('\n').pop() || '';
+    }
+    async start(row) {
+        const res = await this.run(['start', (0, provider_1.containerName)(row)], undefined, 60_000);
+        if (!res.ok)
+            throw new Error(`start failed: ${res.stderr.trim().slice(0, 300)}`);
+    }
+    async stop(row) {
+        const res = await this.run(['stop', '-t', '10', (0, provider_1.containerName)(row)], undefined, 60_000);
+        if (!res.ok)
+            throw new Error(`stop failed: ${res.stderr.trim().slice(0, 300)}`);
+    }
+    async remove(row) {
+        // -f so a running desktop deletes without a separate stop; -v drops its
+        // anonymous volumes, otherwise deleting leaks disk forever.
+        const res = await this.run(['rm', '-f', '-v', (0, provider_1.containerName)(row)], undefined, 120_000);
+        // "No such container" IS success for a delete.
+        if (!res.ok && !/no such container/i.test(res.stderr)) {
+            throw new Error(`remove failed: ${res.stderr.trim().slice(0, 300)}`);
+        }
+    }
+    async inspect(row) {
+        const res = await this.run(['inspect', '-f', '{{.Id}} {{.State.Running}}', (0, provider_1.containerName)(row)], undefined, 30_000);
+        if (!res.ok)
+            return null;
+        const [id, running] = res.stdout.trim().split(/\s+/);
+        if (!id)
+            return null;
+        return { running: running === 'true', containerId: id };
+    }
+}
+exports.CliProvider = CliProvider;
+let cached;
+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;
+    return cached;
+}
+function resetProviderCache() { cached = undefined; }

package/dist/desktop/engine.d.ts

@@ -0,0 +1,3 @@
+import { EngineInfo } from './provider';
+export declare function parseEngineVersion(stdout: string): string | null;
+export declare function detectEngine(): Promise<EngineInfo | null>;

package/dist/desktop/engine.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEngineVersion = parseEngineVersion;
+exports.detectEngine = detectEngine;
+// Which container engine is on this machine? Docker first (the verified
+// path), Podman second. Never installs anything: installing Docker Desktop
+// needs admin rights and, on Windows, a reboot for the WSL2 kernel, so the
+// daemon reports the absence and Studio shows guidance instead.
+const child_process_1 = require("child_process");
+const win_1 = require("../win");
+function parseEngineVersion(stdout) {
+    const m = /version\s+v?(\d+\.\d+\.\d+)/i.exec(stdout);
+    return m ? m[1] : null;
+}
+function runVersion(binary) {
+    return new Promise(resolve => {
+        try {
+            const inv = (0, win_1.resolveCliInvocation)(binary, ['--version']);
+            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));
+        }
+        catch {
+            // resolveCliInvocation throws when a Windows shim can't be resolved -
+            // that is "not installed" as far as this probe is concerned.
+            resolve(null);
+        }
+    });
+}
+async function detectEngine() {
+    for (const id of ['docker', 'podman']) {
+        const out = await runVersion(id);
+        if (!out)
+            continue;
+        const version = parseEngineVersion(out);
+        if (version)
+            return { id, version };
+    }
+    return null;
+}

package/dist/desktop/launcher.d.ts

@@ -0,0 +1,30 @@
+import { DesktopRow } from './spec';
+export interface Assignment {
+    desktop_id: string;
+    runtime_id: string;
+    is_default: boolean;
+}
+export interface Invocation {
+    file: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+}
+/** Resolution order from the spec: the chat/schedule picker, then the
+ *  entity's default on THIS node, then any assignment on this node, then the
+ *  host. Returns the desktop id, or null for "run on the host".
+ *
+ *  A desktop on another node is deliberately ignored rather than treated as
+ *  an error: a run that failed over to a second machine must still run. */
+export declare function resolveDesktopForRun(req: {
+    desktop_id: string | null;
+    runtime_id: string;
+}, assignments: Assignment[], desktops: {
+    id: string;
+    runtime_id: string;
+}[]): string | null;
+/** Turn a host invocation into a container one. */
+export declare function wrapInvocation(engine: 'docker' | 'podman', row: Pick<DesktopRow, 'id' | 'name'>, inv: Invocation, tty?: boolean): {
+    file: string;
+    args: string[];
+};

package/dist/desktop/launcher.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDesktopForRun = resolveDesktopForRun;
+exports.wrapInvocation = wrapInvocation;
+// Decides whether a run happens on the host or inside a desktop, and wraps
+// the spawn when it is the latter. Everything about HOW a session runs is
+// unchanged - only the argv it is launched with.
+const spec_1 = require("./spec");
+const provider_1 = require("./provider");
+/** Resolution order from the spec: the chat/schedule picker, then the
+ *  entity's default on THIS node, then any assignment on this node, then the
+ *  host. Returns the desktop id, or null for "run on the host".
+ *
+ *  A desktop on another node is deliberately ignored rather than treated as
+ *  an error: a run that failed over to a second machine must still run. */
+function resolveDesktopForRun(req, assignments, desktops) {
+    const onThisNode = (id) => desktops.some(d => d.id === id && d.runtime_id === req.runtime_id);
+    if (req.desktop_id && onThisNode(req.desktop_id))
+        return req.desktop_id;
+    const here = assignments.filter(a => a.runtime_id === req.runtime_id
+        && onThisNode(a.desktop_id));
+    const preferred = here.find(a => a.is_default) ?? here[0];
+    return preferred ? preferred.desktop_id : null;
+}
+/** Turn a host invocation into a container one. */
+function wrapInvocation(engine, row, inv, tty = false) {
+    // A cwd that isn't a posix absolute path is a HOST path (a Windows drive
+    // path, or a relative one) and means nothing inside the container. Falling
+    // back to the workspace root beats handing docker a path it will reject.
+    const cwd = inv.cwd.startsWith('/') ? inv.cwd : spec_1.WORK_ROOT;
+    const args = (0, provider_1.buildExecArgs)(row, [inv.file, ...inv.args], {
+        cwd, env: inv.env, tty,
+    });
+    return { file: engine, args };
+}

package/dist/desktop/manager.d.ts

@@ -0,0 +1,28 @@
+import { DesktopRow } from './spec';
+export type Action = 'none' | 'start' | 'mark_failed' | 'mark_stopped' | 'mark_running';
+/** Pure: given what the row claims and what the engine reports, what now?
+ *  `actual` is null when no such container exists. */
+export declare function reconcileAction(row: Pick<DesktopRow, 'status' | 'autostart'>, actual: {
+    running: boolean;
+} | null): Action;
+export declare function listDesktops(): Promise<DesktopRow[]>;
+export declare function setStatus(id: string, fields: {
+    status?: DesktopRow['status'];
+    status_message?: string | null;
+    container_id?: string | null;
+    engine?: string | null;
+    vnc_port?: number | 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. */
+export declare function allocateVncPort(): Promise<number>;
+export declare function ensureDirs(desktopId: string): {
+    confDir: string;
+    workDir: string;
+};
+export declare function startDesktopManager(): void;
+export declare function stopDesktopManager(): void;
+/** Bring a desktop up and wait for it, for the run path. Returns the row when
+ *  running, null when it could not be started - the caller then falls back to
+ *  the host rather than failing the run. */
+export declare function ensureRunning(desktopId: string, timeoutMs?: number): Promise<DesktopRow | null>;