@addai/node 0.11.3 → 0.13.0

package/dist/desktop/manager.js

@@ -0,0 +1,214 @@
+"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.reconcileAction = reconcileAction;
+exports.listDesktops = listDesktops;
+exports.setStatus = setStatus;
+exports.allocateVncPort = allocateVncPort;
+exports.ensureDirs = ensureDirs;
+exports.startDesktopManager = startDesktopManager;
+exports.stopDesktopManager = stopDesktopManager;
+exports.ensureRunning = ensureRunning;
+// Keeps the desktops the server believes in and the containers that actually
+// exist in agreement. Modelled on projects.ts: a slow poll, no realtime, and
+// every transition reported back so a Studio row reflects the machine.
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const supabase_client_1 = require("../supabase-client");
+const store_1 = require("../store");
+const spec_1 = require("./spec");
+const docker_1 = require("./docker");
+// Desktops are not latency-sensitive: a container that died is a rare event
+// and 15s to notice it is fine. Slower interval = less pooler pressure.
+const POLL_INTERVAL_MS = 15_000;
+/** Pure: given what the row claims and what the engine reports, what now?
+ *  `actual` is null when no such container exists. */
+function reconcileAction(row, actual) {
+    // In-flight and terminal states belong to the command runner, not here -
+    // reconciling mid-create would fight the thing doing the creating.
+    if (row.status === 'creating' || row.status === 'starting'
+        || row.status === 'deleting' || row.status === 'pending'
+        || row.status === 'failed')
+        return 'none';
+    if (actual === null) {
+        // The row says this exists and it does not. Someone pruned it by hand.
+        return row.status === 'running' || row.status === 'stopped' ? 'mark_failed' : 'none';
+    }
+    if (row.status === 'running' && !actual.running) {
+        return row.autostart ? 'start' : 'mark_stopped';
+    }
+    if (row.status === 'stopped' && actual.running)
+        return 'mark_running';
+    return 'none';
+}
+function token() { return (0, store_1.readPairing)()?.daemonToken ?? null; }
+async function listDesktops() {
+    const t = token();
+    if (!t)
+        return [];
+    return (await (0, supabase_client_1.rpc)('runtime_desktops_list', { p_token: t })) ?? [];
+}
+async function setStatus(id, fields) {
+    const t = token();
+    if (!t)
+        return;
+    try {
+        await (0, supabase_client_1.rpc)('runtime_desktop_status_update', {
+            p_token: t, p_desktop_id: id,
+            p_status: fields.status ?? null,
+            p_status_message: fields.status_message ?? null,
+            p_container_id: fields.container_id ?? null,
+            p_engine: fields.engine ?? null,
+            p_vnc_port: fields.vnc_port ?? null,
+        });
+    }
+    catch (err) {
+        console.error('[desktops] status update failed:', err.message);
+    }
+}
+/** 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. */
+function allocateVncPort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.once('error', reject);
+        srv.listen(0, '127.0.0.1', () => {
+            const port = srv.address().port;
+            srv.close(() => resolve(port));
+        });
+    });
+}
+function ensureDirs(desktopId) {
+    const confDir = (0, spec_1.confDirFor)(desktopId);
+    const workDir = (0, spec_1.workDirFor)(desktopId);
+    fs.mkdirSync(confDir, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(workDir, { recursive: true, mode: 0o700 });
+    return { confDir, workDir };
+}
+let timer = null;
+let inflight = false;
+async function tick() {
+    if (inflight)
+        return;
+    inflight = true;
+    try {
+        const provider = await (0, docker_1.getProvider)();
+        if (!provider)
+            return; // no engine: nothing to reconcile
+        const rows = await listDesktops();
+        for (const row of rows) {
+            const actual = await provider.inspect(row);
+            const action = reconcileAction(row, actual);
+            if (action === 'none')
+                continue;
+            try {
+                if (action === 'start') {
+                    await provider.start(row);
+                    await setStatus(row.id, { status: 'running', status_message: null });
+                }
+                else if (action === 'mark_failed') {
+                    await setStatus(row.id, {
+                        status: 'failed',
+                        status_message: 'Container no longer exists on this machine. Rebuild to recreate it.',
+                    });
+                }
+                else if (action === 'mark_stopped') {
+                    await setStatus(row.id, { status: 'stopped' });
+                }
+                else if (action === 'mark_running') {
+                    await setStatus(row.id, {
+                        status: 'running', container_id: actual?.containerId ?? null, status_message: null,
+                    });
+                }
+            }
+            catch (err) {
+                await setStatus(row.id, {
+                    status: 'failed', status_message: err.message.slice(0, 400),
+                });
+            }
+        }
+    }
+    catch (err) {
+        console.error('[desktops] reconcile failed:', err.message);
+    }
+    finally {
+        inflight = false;
+    }
+}
+function startDesktopManager() {
+    if (timer)
+        return;
+    void tick();
+    timer = setInterval(() => { void tick(); }, POLL_INTERVAL_MS);
+}
+function stopDesktopManager() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+/** 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. */
+async function ensureRunning(desktopId, timeoutMs = 60_000) {
+    const provider = await (0, docker_1.getProvider)();
+    if (!provider)
+        return null;
+    const rows = await listDesktops();
+    const row = rows.find(r => r.id === desktopId);
+    if (!row)
+        return null;
+    const actual = await provider.inspect(row);
+    if (actual?.running)
+        return row;
+    if (!actual)
+        return null; // never created / pruned: cannot start
+    const deadline = Date.now() + timeoutMs;
+    try {
+        await provider.start(row);
+    }
+    catch {
+        return null;
+    }
+    while (Date.now() < deadline) {
+        const now = await provider.inspect(row);
+        if (now?.running) {
+            await setStatus(row.id, { status: 'running', status_message: null });
+            return row;
+        }
+        await new Promise(r => setTimeout(r, 1_000));
+    }
+    return null;
+}

package/dist/desktop/provider.d.ts

@@ -0,0 +1,35 @@
+import { DesktopRow } from './spec';
+export interface EngineInfo {
+    id: 'docker' | 'podman';
+    version: string;
+}
+export interface ExecOpts {
+    cwd: string;
+    env: Record<string, string>;
+    /** PTY-driven harnesses need a tty allocated inside the container. */
+    tty: boolean;
+}
+export interface CreateOpts {
+    confDir: string;
+    workDir?: string;
+    vncPort: number;
+}
+export interface DesktopProvider {
+    readonly id: 'docker' | 'podman';
+    probe(): Promise<EngineInfo | null>;
+    create(row: DesktopRow, opts: CreateOpts, onLog: (chunk: string) => void): Promise<string>;
+    start(row: DesktopRow): Promise<void>;
+    stop(row: DesktopRow): Promise<void>;
+    remove(row: DesktopRow): Promise<void>;
+    /** null when the container does not exist. */
+    inspect(row: DesktopRow): Promise<{
+        running: boolean;
+        containerId: string;
+    } | null>;
+}
+/** Docker/Podman object names allow [a-zA-Z0-9][a-zA-Z0-9_.-]*. The id suffix
+ *  keeps a renamed desktop from colliding with a leftover container of the
+ *  same name. */
+export declare function containerName(row: Pick<DesktopRow, 'id' | 'name'>): string;
+export declare function buildCreateArgs(row: DesktopRow, opts: CreateOpts): string[];
+export declare function buildExecArgs(row: DesktopRow, cmd: string[], opts: ExecOpts): string[];

package/dist/desktop/provider.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containerName = containerName;
+exports.buildCreateArgs = buildCreateArgs;
+exports.buildExecArgs = buildExecArgs;
+// The interface every desktop backend implements, plus the pure command
+// builders. Kept free of I/O so the argv construction - the part most likely
+// to be subtly wrong, and the part that behaves differently on Windows - is
+// unit-testable with no container engine installed.
+const spec_1 = require("./spec");
+/** Docker/Podman object names allow [a-zA-Z0-9][a-zA-Z0-9_.-]*. The id suffix
+ *  keeps a renamed desktop from colliding with a leftover container of the
+ *  same name. */
+function containerName(row) {
+    const slug = row.name.toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 32) || 'desktop';
+    return `ainode-desktop-${slug}-${row.id.slice(0, 8)}`;
+}
+function buildCreateArgs(row, opts) {
+    const args = [
+        'run', '-d',
+        '--name', containerName(row),
+        '--cpus', String(row.cpus),
+        '--memory', `${row.memory_mb}m`,
+        '--shm-size', '512m', // Chromium crashes on the 64m default
+        '--restart', 'unless-stopped',
+        // Loopback ONLY. Binding 0.0.0.0 would expose a logged-in desktop to the
+        // whole LAN; the relay reaches it from the daemon on the same host.
+        '-p', `127.0.0.1:${opts.vncPort}:${spec_1.VNC_PORT_IN_CONTAINER}`,
+        '-v', `${opts.confDir}:${spec_1.CONF_ROOT}`,
+    ];
+    if (opts.workDir)
+        args.push('-v', `${opts.workDir}:${spec_1.WORK_ROOT}`);
+    if (row.vnc_password)
+        args.push('-e', `VNC_PASSWORD=${row.vnc_password}`);
+    args.push(row.image);
+    return args;
+}
+function buildExecArgs(row, cmd, opts) {
+    const args = ['exec', '-i'];
+    if (opts.tty)
+        args.push('-t');
+    args.push('-w', opts.cwd);
+    for (const [k, v] of Object.entries(opts.env))
+        args.push('-e', `${k}=${v}`);
+    args.push(containerName(row));
+    // cmd goes in as separate argv entries - never joined into a shell string.
+    // A prompt containing quotes, newlines or ESC bytes must survive verbatim.
+    args.push(...cmd);
+    return args;
+}

package/dist/desktop/relay-client.d.ts

@@ -0,0 +1,2 @@
+export declare function startRelayClient(): void;
+export declare function stopRelayClient(): void;

package/dist/desktop/relay-client.js

@@ -0,0 +1,170 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRelayClient = startRelayClient;
+exports.stopRelayClient = stopRelayClient;
+// Dial-out socket to the desktop relay.
+//
+// The daemon connects OUT whenever it has a running desktop, so there is no
+// inbound port and no NAT problem - and because the socket is already open,
+// attaching a viewer is instant rather than waiting on the 30s heartbeat.
+//
+// It carries RAW RFB bytes. The container serves RFB directly (no websockify),
+// so noVNC in the browser speaks RFB across this pipe unchanged.
+const ws_1 = __importDefault(require("ws"));
+const net = __importStar(require("net"));
+const store_1 = require("../store");
+const manager_1 = require("./manager");
+const RELAY_URL = process.env.AINODE_RELAY_URL ?? 'wss://desktop-relay.add.ai';
+const RECONNECT_MIN_MS = 2_000;
+const RECONNECT_MAX_MS = 60_000;
+/** Re-check whether any desktop is running this often while idle. */
+const IDLE_CHECK_MS = 60_000;
+let ws = null;
+let stopped = true;
+let backoff = RECONNECT_MIN_MS;
+let idleTimer = null;
+/** desktopId -> the local TCP socket to that desktop's published RFB port. */
+const bridges = new Map();
+function dropBridges() {
+    for (const s of bridges.values()) {
+        try {
+            s.destroy();
+        }
+        catch { /* gone */ }
+    }
+    bridges.clear();
+}
+async function anyDesktopRunning() {
+    try {
+        return (await (0, manager_1.listDesktops)()).some(d => d.status === 'running');
+    }
+    catch {
+        return false;
+    }
+}
+function scheduleReconnect() {
+    if (stopped)
+        return;
+    setTimeout(() => { void connect(); }, backoff);
+    backoff = Math.min(backoff * 2, RECONNECT_MAX_MS);
+}
+async function connect() {
+    if (stopped || ws)
+        return;
+    const token = (0, store_1.readPairing)()?.daemonToken;
+    if (!token) {
+        scheduleReconnect();
+        return;
+    }
+    // No point holding a socket open for a machine with nothing to show.
+    if (!(await anyDesktopRunning())) {
+        idleTimer = setTimeout(() => { void connect(); }, IDLE_CHECK_MS);
+        return;
+    }
+    const sock = new ws_1.default(`${RELAY_URL}/node?token=${encodeURIComponent(token)}`);
+    ws = sock;
+    sock.on('open', () => { backoff = RECONNECT_MIN_MS; });
+    sock.on('message', async (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            return;
+        }
+        if (msg.type === 'attach') {
+            const row = (await (0, manager_1.listDesktops)()).find(d => d.id === msg.desktopId);
+            if (!row?.vnc_port)
+                return;
+            // Loopback only - the container published its RFB on 127.0.0.1 and this
+            // process is the only thing on the machine that reaches it.
+            const tcp = net.connect(row.vnc_port, '127.0.0.1');
+            tcp.on('data', chunk => {
+                if (sock.readyState === ws_1.default.OPEN) {
+                    sock.send(JSON.stringify({
+                        type: 'data', desktopId: msg.desktopId, b64: chunk.toString('base64'),
+                    }));
+                }
+            });
+            const forget = () => { bridges.delete(msg.desktopId); };
+            tcp.on('close', forget);
+            tcp.on('error', forget);
+            bridges.get(msg.desktopId)?.destroy();
+            bridges.set(msg.desktopId, tcp);
+            return;
+        }
+        if (msg.type === 'data' && msg.b64) {
+            bridges.get(msg.desktopId)?.write(Buffer.from(msg.b64, 'base64'));
+            return;
+        }
+        if (msg.type === 'detach') {
+            bridges.get(msg.desktopId)?.destroy();
+            bridges.delete(msg.desktopId);
+        }
+    });
+    const retry = () => {
+        if (ws !== sock)
+            return; // superseded by a newer socket
+        dropBridges();
+        ws = null;
+        scheduleReconnect();
+    };
+    sock.on('close', retry);
+    sock.on('error', retry);
+}
+function startRelayClient() {
+    if (!stopped)
+        return;
+    stopped = false;
+    backoff = RECONNECT_MIN_MS;
+    void connect();
+}
+function stopRelayClient() {
+    stopped = true;
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+    }
+    dropBridges();
+    try {
+        ws?.close();
+    }
+    catch { /* already closing */ }
+    ws = null;
+}

package/dist/desktop/spec.d.ts

@@ -0,0 +1,37 @@
+export interface DesktopRow {
+    id: string;
+    runtime_id: string;
+    name: string;
+    image: string;
+    engine: 'docker' | 'podman' | null;
+    container_id: string | null;
+    cpus: number;
+    memory_mb: number;
+    disk_gb: number;
+    setup_script: string | null;
+    enabled_mcps: string[];
+    enabled_skills: string[];
+    enabled_packages: string[];
+    autostart: boolean;
+    status: 'pending' | 'creating' | 'starting' | 'running' | 'stopped' | 'failed' | 'deleting';
+    status_message: string | null;
+    vnc_port: number | null;
+    vnc_password: string | null;
+}
+/** Workspace root inside the container. Projects clone to /work/<name>,
+ *  session cwds live at /work/.sessions/<requestId>. */
+export declare const WORK_ROOT = "/work";
+/** Where the daemon's generated files (MCP config, memory pack, attachments)
+ *  appear inside the container. Bind-mounted from the host. */
+export declare const CONF_ROOT = "/conf";
+/** The container's RAW RFB port, fixed by the image.
+ *
+ *  Raw, not websockified: the relay carries these bytes over its own
+ *  WebSocket and noVNC in the browser speaks RFB across it. Putting
+ *  websockify in the container too would mean a WebSocket handshake tunnelled
+ *  inside a WebSocket, which no client can read. */
+export declare const VNC_PORT_IN_CONTAINER = 5900;
+/** Host directory bind-mounted at CONF_ROOT for one desktop. */
+export declare function confDirFor(desktopId: string): string;
+/** Host directory holding the desktop's persistent /work volume. */
+export declare function workDirFor(desktopId: string): string;

package/dist/desktop/spec.js

@@ -0,0 +1,62 @@
+"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.VNC_PORT_IN_CONTAINER = exports.CONF_ROOT = exports.WORK_ROOT = void 0;
+exports.confDirFor = confDirFor;
+exports.workDirFor = workDirFor;
+// Shapes and paths shared by every desktop module. No I/O here.
+const path = __importStar(require("path"));
+const paths_1 = require("../paths");
+/** Workspace root inside the container. Projects clone to /work/<name>,
+ *  session cwds live at /work/.sessions/<requestId>. */
+exports.WORK_ROOT = '/work';
+/** Where the daemon's generated files (MCP config, memory pack, attachments)
+ *  appear inside the container. Bind-mounted from the host. */
+exports.CONF_ROOT = '/conf';
+/** The container's RAW RFB port, fixed by the image.
+ *
+ *  Raw, not websockified: the relay carries these bytes over its own
+ *  WebSocket and noVNC in the browser speaks RFB across it. Putting
+ *  websockify in the container too would mean a WebSocket handshake tunnelled
+ *  inside a WebSocket, which no client can read. */
+exports.VNC_PORT_IN_CONTAINER = 5900;
+/** Host directory bind-mounted at CONF_ROOT for one desktop. */
+function confDirFor(desktopId) {
+    return path.join(paths_1.RUNTIME_HOME, 'desktops', desktopId, 'conf');
+}
+/** Host directory holding the desktop's persistent /work volume. */
+function workDirFor(desktopId) {
+    return path.join(paths_1.RUNTIME_HOME, 'desktops', desktopId, 'work');
+}

package/dist/grok-spawn.d.ts

@@ -38,4 +38,8 @@ export interface GrokHandle {
     onActivity(cb: () => void): void;
     done: Promise<number>;
 }
+/** Write the entity's MCP servers as a project-scoped `<cwd>/.grok/config.toml`.
+ *  Project scope only supports `[mcp_servers]`, which is exactly what we need.
+ *  Returns the config path (for logging) or null when there are no servers. */
+export declare function writeProjectMcpConfig(workingDirectory: string, servers: GrokMcpServer[]): string | null;
 export declare function spawnGrok(input: GrokInput): GrokHandle;

package/dist/grok-spawn.js

@@ -64,6 +64,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeProjectMcpConfig = writeProjectMcpConfig;
 exports.spawnGrok = spawnGrok;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -158,6 +159,18 @@ function writeProjectMcpConfig(workingDirectory, servers) {
     }
     const lines = [];
     for (const s of usable) {
+        // Remote MCP servers (registry command='http'|'sse', args=[url]) have no
+        // verified grok config spelling, and writing the row verbatim is worse
+        // than skipping: grok would try to exec a binary called `http`, the
+        // server would never start, and its tools would vanish with no error —
+        // the exact silent failure that cost an entity its GitHub access after a
+        // provider-ladder hop. Skip it, and say so loudly enough to be findable.
+        if (s.command === 'http' || s.command === 'sse') {
+            console.error(`[grok] MCP ${s.slug}: remote ${s.command} servers are not supported by the grok ` +
+                `adapter — skipping. Its tools will be ABSENT from this run. Use claude (or codex, ` +
+                `which supports url + bearer_token_env_var) for entities that depend on it.`);
+            continue;
+        }
         // `cmd /c` wrapper for npm-shim commands on native Windows (no-op on POSIX).
         const wrapped = (0, win_1.wrapMcpCommandForPlatform)(s.command, Array.isArray(s.args) ? s.args.map(String) : []);
         lines.push(`[mcp_servers.${tomlStr(s.slug)}]`);

package/dist/heartbeat.d.ts

@@ -1,4 +1,5 @@
 export declare function setPendingCommandsHook(cb: () => void): void;
+export declare function autoUpdateEnabled(): boolean;
 /** Announce a clean shutdown so the server flips us offline immediately
  *  (status='offline') instead of waiting ~90s for last_seen_at to age out —
  *  lets a planned restart fail over instantly. Best-effort; the stale-window

package/dist/heartbeat.js

@@ -4,6 +4,7 @@
 // is paired.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setPendingCommandsHook = setPendingCommandsHook;
+exports.autoUpdateEnabled = autoUpdateEnabled;
 exports.goOffline = goOffline;
 exports.beat = beat;
 exports.start = start;
@@ -21,6 +22,15 @@ let onPendingCommands = null;
 function setPendingCommandsHook(cb) {
     onPendingCommands = cb;
 }
+// Is hourly auto-update armed for this node? It rides the heartbeat rather
+// than getting an RPC of its own — the daemon is already talking to the server
+// every 30s, and the answer is one boolean on the node's own row.
+//
+// Default ON, and specifically ON when the field is ABSENT: a server that has
+// not had the migration yet must not read as "everybody opted out". Only an
+// explicit `false` turns it off.
+let autoUpdateArmed = true;
+function autoUpdateEnabled() { return autoUpdateArmed; }
 async function tick() {
     // Skip if the daemon-wide circuit breaker is open. Heartbeats are
     // safe to miss — vault marks the runtime offline after ~90s; the
@@ -41,6 +51,8 @@ async function tick() {
         if (res && typeof res.pending_commands === 'number' && res.pending_commands > 0) {
             onPendingCommands?.();
         }
+        if (res && typeof res.auto_update === 'boolean')
+            autoUpdateArmed = res.auto_update;
     }
     catch (err) {
         if (err instanceof supabase_client_1.RpcError && err.status === 401) {