@addai/node 0.30.13 → 0.30.14

package/dist/desktop/manager.js

@@ -39,6 +39,7 @@ exports.listDesktops = listDesktops;
 exports.setStatus = setStatus;
 exports.allocateVncPort = allocateVncPort;
 exports.ensureDirs = ensureDirs;
+exports.entityboxDesktopLimitKnown = entityboxDesktopLimitKnown;
 exports.clampMaxDesktops = clampMaxDesktops;
 exports.setMaxConcurrentDesktops = setMaxConcurrentDesktops;
 exports.maxConcurrentDesktops = maxConcurrentDesktops;
@@ -49,6 +50,7 @@ exports.startDesktopManager = startDesktopManager;
 exports.stopDesktopManager = stopDesktopManager;
 exports.reconcileAfterWake = reconcileAfterWake;
 exports.ensureRunning = ensureRunning;
+const entitybox_desktop_admission_1 = require("../entitybox-desktop-admission");
 // 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.
@@ -65,6 +67,8 @@ 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) {
+    if (row.entitybox_managed === true)
+        return 'none';
     // 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'
@@ -177,6 +181,10 @@ function ensureDirs(desktopId) {
 exports.DEFAULT_MAX_CONCURRENT_DESKTOPS = 2;
 const MAX_MAX_CONCURRENT_DESKTOPS = 16;
 let maxDesktops = exports.DEFAULT_MAX_CONCURRENT_DESKTOPS;
+// Only the opt-in EntityBox host requires a server-provided initial limit.
+// Ordinary legacy behavior retains its existing default while unconfigured.
+let entityboxLimitKnown = false;
+function entityboxDesktopLimitKnown() { return entityboxLimitKnown; }
 function clampMaxDesktops(value) {
     if (typeof value !== 'number' && typeof value !== 'string')
         return exports.DEFAULT_MAX_CONCURRENT_DESKTOPS;
@@ -191,6 +199,7 @@ function clampMaxDesktops(value) {
  *  killing someone's live session to satisfy a number they just typed would
  *  be a worse surprise than being one over the cap for a while. */
 function setMaxConcurrentDesktops(value) {
+    entityboxLimitKnown = true;
     const next = clampMaxDesktops(value);
     if (next === maxDesktops)
         return;
@@ -207,6 +216,13 @@ async function runningDesktopCount(rows) {
         return 0;
     let count = 0;
     for (const row of rows) {
+        // Reserved/paused dedicated capacity still consumes a slot. Never inspect
+        // it through the ordinary one-container naming convention.
+        if (row.entitybox_managed === true) {
+            if (row.status !== 'pending')
+                count++;
+            continue;
+        }
         try {
             const actual = await provider.inspect(row);
             if (actual?.running)
@@ -236,6 +252,11 @@ function queueOrder(rows) {
 /** Whether one more may start. Returns the reason when it may not, so the
  *  caller can say something better than "failed". */
 async function desktopStartAllowed(rows, excludeId) {
+    if (excludeId) {
+        const admission = await (0, entitybox_desktop_admission_1.entityboxDesktopAdmission)(rows, excludeId);
+        if (admission)
+            return admission;
+    }
     const running = await runningDesktopCount(rows.filter(r => r.id !== excludeId));
     if (running < maxDesktops)
         return { allowed: true };
@@ -258,6 +279,8 @@ let engineStarting = false;
 let lastEngineAttempt = 0;
 const ENGINE_RETRY_MS = 3 * 60_000;
 function wantsToRun(row) {
+    if (row.entitybox_managed === true)
+        return false;
     if (row.status === 'running' || row.status === 'queued')
         return true;
     return row.status === 'stopped' && !!row.autostart;
@@ -304,7 +327,22 @@ async function maybeStartEngineForDesktops() {
 }
 let timer = null;
 let inflight = false;
+let entityboxTickQueued = false;
 async function tick() {
+    if (entityboxTickQueued)
+        return;
+    entityboxTickQueued = true;
+    try {
+        await (0, entitybox_desktop_admission_1.entityboxWithDesktopStart)(() => tickUncoordinated());
+    }
+    catch {
+        console.warn('[desktops] desktop admission unavailable');
+    }
+    finally {
+        entityboxTickQueued = false;
+    }
+}
+async function tickUncoordinated() {
     if (inflight)
         return;
     inflight = true;
@@ -323,6 +361,8 @@ async function tick() {
         }
         const rows = await listDesktops();
         for (const row of queueOrder(rows)) {
+            if (row.entitybox_managed === true)
+                continue;
             const actual = await provider.inspect(row);
             const action = reconcileAction(row, actual);
             if (action === 'none')
@@ -400,7 +440,10 @@ function reconcileAfterWake() {
 /** 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) {
+function ensureRunning(desktopId, timeoutMs = 60_000) {
+    return ensureRunningUncoordinated(desktopId, timeoutMs);
+}
+async function ensureRunningUncoordinated(desktopId, timeoutMs = 60_000, admissionHeld = false) {
     const provider = await (0, docker_1.getProvider)();
     if (!provider)
         return null;
@@ -408,11 +451,18 @@ async function ensureRunning(desktopId, timeoutMs = 60_000) {
     const row = rows.find(r => r.id === desktopId);
     if (!row)
         return null;
+    if (row.entitybox_managed === true)
+        throw new Error('This computer requires EntityBox execution; host fallback is not allowed');
     const actual = await provider.inspect(row);
     if (actual?.running)
         return row;
     if (!actual)
         return null; // never created / pruned: cannot start
+    // Existing running desktops never wait behind new provisioning. Only an
+    // operation that needs to start one joins admission, then re-reads its state.
+    if (!admissionHeld && (0, entitybox_desktop_admission_1.entityboxAdmissionEnabled)()) {
+        return (0, entitybox_desktop_admission_1.entityboxWithDesktopStart)(() => ensureRunningUncoordinated(desktopId, timeoutMs, true));
+    }
     // At the cap, the run falls back to the host rather than starting an
     // eleventh container. Returning null is how this function already says
     // "could not start it" and the caller already handles it.

package/dist/desktop/provider.d.ts

@@ -39,6 +39,6 @@ export interface DesktopProvider {
 /** 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 containerName(row: Pick<DesktopRow, 'id' | 'name' | 'entitybox_managed'>): 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

@@ -12,6 +12,8 @@ const spec_1 = require("./spec");
  *  keeps a renamed desktop from colliding with a leftover container of the
  *  same name. */
 function containerName(row) {
+    if (row.entitybox_managed === true)
+        throw new Error('This computer is managed by EntityBox');
     const slug = row.name.toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '')

package/dist/desktop/relay-client.js

@@ -271,6 +271,13 @@ async function connect() {
                 gone(msg.viewerId, 'desktop is not running');
                 return;
             }
+            // This dedicated display publishes only RFB. Never derive an xpra port
+            // that could point at an unrelated loopback service. Ordinary rows keep
+            // their existing fixed-offset windows channel.
+            if (row.entitybox_managed === true && msg.channel === 'windows') {
+                gone(msg.viewerId, 'EntityBox computers support the screen channel only');
+                return;
+            }
             // WHICH stream of that desktop.
             //
             // 'screen' is the whole framebuffer over RFB, and is what every viewer

package/dist/desktop/spec.d.ts

@@ -1,4 +1,6 @@
 export interface DesktopRow {
+    /** New dedicated EntityBox capacity has a separate lifecycle owner. */
+    entitybox_managed?: boolean;
     id: string;
     runtime_id: string;
     name: string;

package/dist/direct/aios-bridge.d.ts

@@ -0,0 +1,13 @@
+import { type DesktopCall } from './aios-tools';
+export interface AiosLaunch {
+    claudeConfig: string;
+    command: string;
+    args: string[];
+    close(): void;
+}
+/** Private per-process capability; never receives a Supabase, pairing or entity token. */
+export declare function createAiosBridge(call: DesktopCall): AiosLaunch;
+export declare function callAiosBridge(config: {
+    endpoint: string;
+    token: string;
+}, name: string, args: Record<string, unknown>): Promise<unknown>;

package/dist/direct/aios-bridge.js

@@ -0,0 +1,177 @@
+"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.createAiosBridge = createAiosBridge;
+exports.callAiosBridge = callAiosBridge;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const net = __importStar(require("node:net"));
+const node_crypto_1 = require("node:crypto");
+const aios_tools_1 = require("./aios-tools");
+/** Private per-process capability; never receives a Supabase, pairing or entity token. */
+function createAiosBridge(call) {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'addai-codeflows-'));
+    fs.chmodSync(directory, 0o700);
+    const nonce = (0, node_crypto_1.randomBytes)(24).toString('hex');
+    const endpoint = process.platform === 'win32' ? `\\\\.\\pipe\\addai-codeflows-${nonce}` : path.join(directory, 'bridge.sock');
+    const token = (0, node_crypto_1.randomBytes)(32).toString('hex');
+    const sockets = new Set();
+    let closed = false;
+    const server = net.createServer(socket => {
+        if (closed || sockets.size >= 8) {
+            socket.destroy();
+            return;
+        }
+        sockets.add(socket);
+        socket.setEncoding('utf8');
+        const timer = setTimeout(() => socket.destroy(), aios_tools_1.AIOS_TIMEOUT + 1000);
+        socket.on('error', () => { });
+        socket.on('close', () => { clearTimeout(timer); sockets.delete(socket); });
+        let buffer = '', received = false;
+        socket.on('data', chunk => {
+            if (received) {
+                socket.destroy();
+                return;
+            }
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > aios_tools_1.AIOS_LIMIT) {
+                socket.destroy();
+                return;
+            }
+            const end = buffer.indexOf('\n');
+            if (end < 0)
+                return;
+            received = true;
+            void (async () => {
+                try {
+                    const q = JSON.parse(buffer.slice(0, end));
+                    if (typeof q.token !== 'string' || q.token.length !== token.length || !(0, node_crypto_1.timingSafeEqual)(Buffer.from(q.token), Buffer.from(token)))
+                        throw new Error('+Ai connection denied.');
+                    (0, aios_tools_1.validateDesktopCall)(q.name, q.args);
+                    const result = await call(q.name, q.args);
+                    const reply = JSON.stringify({ ok: true, result });
+                    if (Buffer.byteLength(reply) > aios_tools_1.AIOS_LIMIT)
+                        throw new Error('+Ai result is too large.');
+                    if (!socket.destroyed)
+                        socket.end(reply + '\n');
+                }
+                catch (err) {
+                    if (!socket.destroyed)
+                        socket.end(JSON.stringify({ ok: false, error: err.message.slice(0, 500) }) + '\n');
+                }
+            })();
+        });
+    });
+    const config = path.join(directory, 'connection.json');
+    const claudeConfig = path.join(directory, 'mcp.json');
+    const command = process.execPath, args = [path.join(__dirname, 'aios-mcp.js'), config];
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        for (const socket of sockets)
+            socket.destroy();
+        server.close();
+        // Only our fixed files, no recursive deletion or following directory links.
+        for (const file of [config, claudeConfig]) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch { }
+        }
+        if (process.platform !== 'win32') {
+            try {
+                fs.unlinkSync(endpoint);
+            }
+            catch { }
+        }
+        try {
+            fs.rmdirSync(directory);
+        }
+        catch { }
+    }
+    server.on('error', close); // Failure disables only this optional connection.
+    try {
+        fs.writeFileSync(config, JSON.stringify({ endpoint, token }), { mode: 0o600, flag: 'wx' });
+        fs.writeFileSync(claudeConfig, JSON.stringify({ mcpServers: { addai_codeflows: { type: 'stdio', command, args } } }), { mode: 0o600, flag: 'wx' });
+        server.listen(endpoint);
+    }
+    catch (err) {
+        close();
+        throw err;
+    }
+    return { command, args, claudeConfig, close };
+}
+function callAiosBridge(config, name, args) {
+    (0, aios_tools_1.validateDesktopCall)(name, args);
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(config.endpoint);
+        let buffer = '', settled = false;
+        const timer = setTimeout(() => finish(new Error('+Ai desktop did not respond. Reopen CodeFlows and try again.')), aios_tools_1.AIOS_TIMEOUT + 500);
+        function finish(error, result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        }
+        socket.setEncoding('utf8');
+        socket.on('connect', () => socket.write(JSON.stringify({ token: config.token, name, args }) + '\n'));
+        socket.on('error', () => finish(new Error('+Ai connection is unavailable. Reopen this session in CodeFlows.')));
+        socket.on('close', () => finish(new Error('+Ai connection closed.')));
+        socket.on('data', chunk => {
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > aios_tools_1.AIOS_LIMIT) {
+                finish(new Error('+Ai response is too large.'));
+                return;
+            }
+            const end = buffer.indexOf('\n');
+            if (end < 0)
+                return;
+            try {
+                const reply = JSON.parse(buffer.slice(0, end));
+                finish(reply.ok === true ? undefined : new Error(reply.error || '+Ai request failed.'), reply.result);
+            }
+            catch {
+                finish(new Error('Invalid +Ai response.'));
+            }
+        });
+    });
+}

package/dist/direct/aios-mcp.d.ts

@@ -0,0 +1,2 @@
+/** Small stdio MCP adapter. stdout is reserved for newline-delimited JSON-RPC. */
+export declare function runAiosMcp(file: string): void;

package/dist/direct/aios-mcp.js

@@ -0,0 +1,132 @@
+"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.runAiosMcp = runAiosMcp;
+const fs = __importStar(require("node:fs"));
+const aios_tools_1 = require("./aios-tools");
+const aios_bridge_1 = require("./aios-bridge");
+/** Small stdio MCP adapter. stdout is reserved for newline-delimited JSON-RPC. */
+function runAiosMcp(file) {
+    if (fs.statSync(file).size > 8192)
+        throw new Error('Invalid connection configuration.');
+    const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (typeof config.endpoint !== 'string' || typeof config.token !== 'string')
+        throw new Error('Invalid connection configuration.');
+    let buffer = '', active = 0, initialized = false;
+    const send = (message) => process.stdout.write(JSON.stringify(message) + '\n');
+    async function handle(q) {
+        if (!q || q.jsonrpc !== '2.0' || typeof q.method !== 'string') {
+            send({ jsonrpc: '2.0', id: null, error: { code: -32600, message: 'Invalid request.' } });
+            return;
+        }
+        if (q.id === undefined)
+            return; // No server-originated work or notifications to process.
+        if (!(typeof q.id === 'string' || typeof q.id === 'number'))
+            return;
+        const reply = (result) => send({ jsonrpc: '2.0', id: q.id, result });
+        const error = (code, message) => send({ jsonrpc: '2.0', id: q.id, error: { code, message } });
+        if (q.method === 'initialize') {
+            initialized = true;
+            const supported = ['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25'];
+            reply({ protocolVersion: supported.includes(q.params?.protocolVersion) ? q.params.protocolVersion : '2025-11-25', capabilities: { tools: {} }, serverInfo: { name: 'addai-codeflows', version: '1.0.0' } });
+            return;
+        }
+        if (q.method === 'ping') {
+            reply({});
+            return;
+        }
+        if (!initialized) {
+            error(-32002, 'Initialize first.');
+            return;
+        }
+        if (q.method === 'tools/list') {
+            reply({ tools: aios_tools_1.AIOS_TOOLS });
+            return;
+        }
+        if (q.method !== 'tools/call') {
+            error(-32601, 'Method not found.');
+            return;
+        }
+        if (active >= 8) {
+            error(-32000, 'Too many pending +Ai calls.');
+            return;
+        }
+        active++;
+        try {
+            const result = await (0, aios_bridge_1.callAiosBridge)(config, q.params?.name, q.params?.arguments ?? {});
+            reply({ content: [{ type: 'text', text: JSON.stringify(result) }] });
+        }
+        catch (err) {
+            reply({ isError: true, content: [{ type: 'text', text: err.message.slice(0, 500) }] });
+        }
+        finally {
+            active--;
+        }
+    }
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+        buffer += chunk;
+        // Bound both incomplete frames and batches delivered in one read.
+        if (Buffer.byteLength(buffer) > aios_tools_1.AIOS_LIMIT) {
+            process.exitCode = 1;
+            process.stdin.destroy();
+            return;
+        }
+        let end;
+        while ((end = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, end);
+            buffer = buffer.slice(end + 1);
+            if (!line.trim())
+                continue;
+            try {
+                void handle(JSON.parse(line));
+            }
+            catch {
+                send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Invalid JSON.' } });
+            }
+        }
+    });
+    process.stdout.on('error', () => process.exit(0));
+    process.stdin.on('end', () => process.exit(0));
+}
+if (require.main === module) {
+    try {
+        runAiosMcp(process.argv[2]);
+    }
+    catch {
+        process.stderr.write('CodeFlows +Ai connection could not start.\n');
+        process.exitCode = 1;
+    }
+}