@addai/node 0.30.13 → 0.30.14

package/dist/model-cache.js

@@ -0,0 +1,137 @@
+"use strict";
+// What every model probe sits behind: one answer per (binary, version), kept
+// for the heartbeat, which must never wait for a CLI to start. claude-models.ts
+// explains why it is shaped this way; codex-models.ts uses it the same way.
+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.createModelCache = createModelCache;
+exports.makeProbeDir = makeProbeDir;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+/** Re-ask now and then even when nothing changed: the CLI's list can move
+ *  without a CLI update. */
+const REFRESH_MS = 6 * 60 * 60 * 1000;
+const RETRY_AFTER_FAIL_MS = 30 * 60 * 1000;
+function createModelCache(opts) {
+    let good = null;
+    let failed = null;
+    let inflight = null;
+    const start = (bin, key) => {
+        if (inflight)
+            return;
+        inflight = opts.probe(bin).then(result => {
+            if (result.ok) {
+                if (good?.key === key && opts.keep?.(good.report, result.report)) {
+                    good = { ...good, at: opts.now() };
+                    if (failed?.key === key)
+                        failed = null;
+                    return;
+                }
+                const changed = !good || good.report.models.join() !== result.report.models.join();
+                good = { key, report: result.report, at: opts.now() };
+                if (failed?.key === key)
+                    failed = null;
+                if (changed) {
+                    const detail = opts.describe?.(result.report);
+                    opts.log(`[models] ${opts.agent}: ${result.report.models.length} models from the CLI${detail ? ` (${detail})` : ''}`);
+                }
+            }
+            else {
+                // An answer this exact binary already gave stays good: a refresh
+                // that fails is a reason to retry, not to forget it.
+                failed = { key, at: opts.now() };
+                const kept = good?.key === key;
+                opts.log(`[models] could not read ${opts.agent}'s model list (${result.reason}) — ${kept ? 'keeping the last answer' : 'offering the built-in list'}; next try in ${RETRY_AFTER_FAIL_MS / 60000} min`);
+            }
+        }).catch(() => { failed = { key, at: opts.now() }; })
+            .finally(() => { inflight = null; });
+    };
+    return {
+        /**
+         * The models for this binary state, or null to mean "use the built-in
+         * list". Never waits: a missing or stale answer is fetched in the
+         * background and arrives on a later call.
+         */
+        get(bin, key) {
+            const now = opts.now();
+            const recentlyFailed = failed?.key === key && now - failed.at < RETRY_AFTER_FAIL_MS;
+            if (good?.key === key) {
+                if (now - good.at > REFRESH_MS && !recentlyFailed)
+                    start(bin, key);
+                return good.report;
+            }
+            if (!recentlyFailed)
+                start(bin, key);
+            // A new CLI version that has not answered yet: keep showing the last
+            // real list — closer to the truth than the constant, and it stops the
+            // pickers flickering to the built-in list across an upgrade. Once the
+            // new version has actually failed, the built-in list it is.
+            return failed?.key === key ? null : (good?.report ?? null);
+        },
+        /** The last real answer, whichever binary gave it. */
+        last() {
+            return good?.report ?? null;
+        },
+    };
+}
+/** A throwaway folder for one probe, under RUNTIME_HOME/model-probe. Folders
+ *  older than a day are swept — a probe's own cleanup can lose a race with
+ *  Windows releasing its files. */
+function makeProbeDir(prefix = 'p-') {
+    const root = path.join(paths_1.RUNTIME_HOME, 'model-probe');
+    try {
+        fs.mkdirSync(root, { recursive: true });
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        for (const name of fs.readdirSync(root)) {
+            const p = path.join(root, name);
+            try {
+                if (fs.lstatSync(p).mtimeMs < cutoff)
+                    fs.rmSync(p, { recursive: true, force: true });
+            }
+            catch { /* next time */ }
+        }
+        return fs.mkdtempSync(path.join(root, prefix));
+    }
+    catch {
+        try {
+            return fs.mkdtempSync(path.join(os.tmpdir(), `ainode-model-probe-${prefix}`));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/request-pump.d.ts

@@ -1,3 +1,4 @@
+import type { EntityboxQueueServices } from './entitybox-queue-request';
 export declare const DEFAULT_MAX_CONCURRENT = 4;
 /** Clamp whatever the server sent into something the pump can act on. A null,
  *  a string, a 0 or a 10_000 must not be able to wedge the pump shut or uncap
@@ -9,6 +10,8 @@ export declare function clampMaxConcurrent(value: unknown): number;
 export declare function setMaxConcurrent(value: unknown): void;
 /** The node's current ceiling. Exported for /stats and the TUI. */
 export declare function maxConcurrentRuns(): number;
+/** Register once before heartbeat/relay pickup can begin. No ordinary host route changes. */
+export declare function configureEntityboxQueueServices(services?: EntityboxQueueServices): void;
 export declare function inflightCount(): number;
 export declare function activeRequestIdList(): string[];
 export declare function start(): void;

package/dist/request-pump.js

@@ -1,19 +1,20 @@
 "use strict";
-// Polls Supabase for pending requests targeted at this runtime and runs
-// them via session-runner. Bounded concurrency keeps a single runtime
-// from spawning unlimited Claude processes when a burst of requests
-// arrives.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_MAX_CONCURRENT = void 0;
 exports.clampMaxConcurrent = clampMaxConcurrent;
 exports.setMaxConcurrent = setMaxConcurrent;
 exports.maxConcurrentRuns = maxConcurrentRuns;
+exports.configureEntityboxQueueServices = configureEntityboxQueueServices;
 exports.inflightCount = inflightCount;
 exports.activeRequestIdList = activeRequestIdList;
 exports.start = start;
 exports.stop = stop;
 exports.pumpNow = pumpNow;
 exports.drain = drain;
+// Polls Supabase for pending requests targeted at this runtime and runs
+// them via session-runner. Bounded concurrency keeps a single runtime
+// from spawning unlimited Claude processes when a burst of requests
+// arrives.
 const supabase_client_1 = require("./supabase-client");
 const store_1 = require("./store");
 const session_runner_1 = require("./session-runner");
@@ -86,7 +87,17 @@ const SLOT_LEAK_BACKSTOP_MS = 12 * 60 * 60 * 1000; // 12 hours
 const SLOT_TIMEOUT_GRACE_MS = 5 * 60 * 1000; // pad over a node timeout
 let timer = null;
 let stopped = false;
+let picking = false;
 let inflight = 0;
+let entityboxServices;
+let entityboxConfigured = false;
+/** Register once before heartbeat/relay pickup can begin. No ordinary host route changes. */
+function configureEntityboxQueueServices(services) {
+    if (entityboxConfigured || timer || inflight || picking || stopped)
+        throw new Error('Computer task services must be configured before request pickup');
+    entityboxConfigured = true;
+    entityboxServices = services;
+}
 // Request ids with a runRequest currently in-flight on THIS daemon.
 // Guards against launching a second run for the same request — e.g. if a
 // reclaim ever requeues one whose spawn is still alive — which is exactly
@@ -120,7 +131,7 @@ function activeRequestIdList() { return [...activeRequestIds]; }
 async function tick() {
     if (stopped)
         return;
-    if (inflight >= maxConcurrent)
+    if (picking || inflight >= maxConcurrent)
         return;
     // Honour the backoff window — skip this tick if we recently failed.
     if (Date.now() < nextPickAllowedAt)
@@ -150,6 +161,7 @@ async function tick() {
         return;
     }
     let row = null;
+    picking = true;
     try {
         // runtime_pick_next_request returns a row record. PostgREST wraps
         // it as an object or null depending on the function shape.
@@ -165,6 +177,7 @@ async function tick() {
         }
     }
     catch (err) {
+        picking = false;
         if (err instanceof supabase_client_1.RpcError && err.status === 401) {
             console.error('[request-pump] unauthorized; will retry on next heartbeat.');
             return;
@@ -185,7 +198,8 @@ async function tick() {
         }
         return;
     }
-    if (!row)
+    picking = false;
+    if (stopped || !row)
         return;
     // Defense-in-depth: never run the same request twice concurrently. The
     // server-side reclaim now keys off real activity so it shouldn't requeue
@@ -232,7 +246,7 @@ async function tick() {
         }, slotBackstopMs);
         t.unref?.();
     });
-    const runPromise = (0, session_runner_1.runRequest)(row).catch(err => console.error(`[request-pump] runRequest threw [reqId=${reqId}]: ${err.message}`));
+    const runPromise = (0, session_runner_1.runRequest)(row, entityboxServices).catch(err => console.error(`[request-pump] runRequest threw [reqId=${reqId}]: ${err.message}`));
     // Heartbeat + in-flight registration live for the REAL lifetime of the
     // run (until the spawn exits), NOT just until the slot's hard timeout.
     // A task that runs longer than REQUEST_HARD_TIMEOUT_MS must keep

package/dist/session-runner.d.ts

@@ -1,8 +1,15 @@
+import { type EntityboxQueueServices } from './entitybox-queue-request';
 import type { RuntimePermissionMode, RuntimeEffortLevel } from './types';
 /** Shape of a row returned by runtime_pick_next_request. */
 export interface RuntimeRequestRow {
     id: string;
     runtime_id: string;
+    /** Native queue destination; EntityBox computer bindings require an exact match. */
+    desktop_id?: string | null;
+    /** Server-stamped routing marker, independent of MCP configuration. Not authorization. */
+    entitybox_computer_request?: boolean;
+    /** Server-stamped requirement; file failures must never become text-only runs. */
+    entitybox_file_request?: boolean;
     project_id: string | null;
     agent: 'claude' | 'claude-tui' | 'claude-bypass' | 'codex' | 'kimi' | 'gemini' | 'grok';
     mode: 'tui' | 'print';
@@ -129,4 +136,4 @@ export declare function notifySelfImproveIfEnabled(requestId: string): Promise<v
  *
  *  Exported for tests. */
 export declare function resumeSessionIsVoid(workingDirectory: string | null | undefined, resumeSessionId: string | null | undefined, cwdSubstituted: boolean): boolean;
-export declare function runRequest(req: RuntimeRequestRow): Promise<void>;
+export declare function runRequest(req: RuntimeRequestRow, entitybox?: EntityboxQueueServices): Promise<void>;

package/dist/session-runner.js

@@ -61,13 +61,17 @@ const projects_1 = require("./projects");
 const claude_print_1 = require("./claude-print");
 const subagent_usage_1 = require("./subagent-usage");
 const attachments_1 = require("./attachments");
+const entitybox_file_session_1 = require("./entitybox-file-session");
+const entitybox_file_inputs_1 = require("./entitybox-file-inputs");
 const codex_spawn_1 = require("./codex-spawn");
+const codex_models_1 = require("./codex-models");
 const diskguard_1 = require("./diskguard");
 const kimi_spawn_1 = require("./kimi-spawn");
 const gemini_spawn_1 = require("./gemini-spawn");
 const grok_spawn_1 = require("./grok-spawn");
 const model_filter_1 = require("./model-filter");
 const agent_auth_1 = require("./agent-auth");
+const entitybox_queue_request_1 = require("./entitybox-queue-request");
 const prompt_keystrokes_1 = require("./prompt-keystrokes");
 const projects_2 = require("./projects");
 const run_retry_1 = require("./run-retry");
@@ -1577,11 +1581,32 @@ async function runClaudePrint(req, cwd, installed) {
     // subagent-usage.ts. Taken before the spawn so nothing this run writes
     // can fall outside the window.
     const startedAtMs = Date.now();
+    let inputBlocks;
+    if (req.entitybox_file_request === true) {
+        const abort = new AbortController(), watcher = startCancelWatcher(req.id, () => abort.abort());
+        try {
+            inputBlocks = await (0, entitybox_file_session_1.prepareEntityboxSessionFiles)(req, { rpc: supabase_client_1.rpc, pairing: store_1.readPairing }, abort.signal);
+        }
+        catch {
+            const status = await (0, supabase_client_1.rpc)('runtime_get_request_status', { p_token: token(), p_request_id: req.id }).catch(() => null);
+            if (!abort.signal.aborted && ['starting', 'running'].includes(status ?? '')) {
+                const message = new entitybox_file_inputs_1.EntityboxFileInputError().message;
+                await setStatus(req.id, { status: 'failed', errorCode: 'entitybox_file_input_failed', errorMessage: message });
+                await emit(req.id, 'error', { code: 'entitybox_file_input_failed', message });
+            }
+            return;
+        }
+        finally {
+            watcher.stop();
+            abort.abort();
+        }
+    }
     let handle;
     try {
         handle = (0, claude_print_1.spawnClaudePrint)({
             workingDirectory: cwd,
             prompt: req.prompt,
+            ...(inputBlocks ? { inputBlocks } : {}),
             permissionMode,
             effortLevel: req.effort ?? undefined,
             model: (0, model_filter_1.modelForAgent)('claude', req.model),
@@ -1692,11 +1717,13 @@ async function runCodex(req, cwd, installed) {
     await (0, diskguard_1.getDiskGuard)().sweep('pre-spawn').catch(() => { });
     let handle;
     try {
+        const codexModel = (0, model_filter_1.modelForAgent)('codex', req.model);
         handle = (0, codex_spawn_1.spawnCodex)({
             workingDirectory: cwd,
             prompt: finalPrompt,
-            model: (0, model_filter_1.modelForAgent)('codex', req.model),
+            model: codexModel,
             effortLevel: req.effort ?? undefined,
+            supportedEfforts: (0, codex_models_1.codexModelEfforts)(codexModel),
             bypassPermissions: req.permission_mode === 'bypassPermissions',
             skipGitRepoCheck: true,
             resumeThreadId: req.resume_session_id ?? undefined,
@@ -2153,7 +2180,20 @@ async function buildMemoryManifest(installed) {
     }
 }
 // ── Dispatcher ─────────────────────────────────────────────────────────────
-async function runRequest(req) {
+async function runRequest(req, entitybox) {
+    if (await (0, entitybox_queue_request_1.runEntityboxQueueRequest)(req, { rpc: supabase_client_1.rpc, pairing: store_1.readPairing }, entitybox))
+        return;
+    if (req.entitybox_file_request === true) {
+        try {
+            (0, entitybox_file_session_1.entityboxFileSessionConfiguration)(req);
+        }
+        catch {
+            const message = "This runtime cannot read the attached images or PDFs. Choose a compatible runtime.";
+            await setStatus(req.id, { status: "failed", errorCode: "entitybox_file_runtime_unavailable", errorMessage: message });
+            await emit(req.id, "error", { code: "entitybox_file_runtime_unavailable", message });
+            return;
+        }
+    }
     // Auth pre-flight: cheap file/env check before we spawn so the user
     // gets a clean `auth_required` event instead of cryptic stderr from
     // the child (e.g. "Invalid API key", "401 unauthorized"). This also
@@ -2220,7 +2260,12 @@ async function runRequest(req) {
     req.mcp_env_overrides ?? undefined, 
     // Per-skill variable values keyed by skill id — substituted into each
     // skill's {{var.<name>}} tokens before SKILL.md is written.
-    req.skill_var_values ?? {}, req.id);
+    req.skill_var_values ?? {}, req.id, async (message) => {
+        // A missing required computer connection must not start an unrestricted
+        // harness or leave the row waiting for reclaim. Other installs are unchanged.
+        await setStatus(req.id, { status: 'failed', errorCode: 'entitybox_computer_setup_failed', errorMessage: message });
+        await emit(req.id, 'error', { code: 'entitybox_computer_setup_failed', message });
+    });
     if (installed.mcpConfigPath || installed.skillSlugs.length > 0) {
         void emit(req.id, 'claude:install_complete', {
             mcps_installed: installed.mcpConfigPath ? true : false,

package/dist/supabase-client.js

@@ -62,6 +62,7 @@ async function rpc(name, args = {}) {
     const ac = new AbortController();
     const timer = setTimeout(() => ac.abort(), DEFAULT_RPC_TIMEOUT_MS);
     let res;
+    let text;
     try {
         res = await fetch(url, {
             method: 'POST',
@@ -74,6 +75,9 @@ async function rpc(name, args = {}) {
             body: JSON.stringify(args),
             signal: ac.signal,
         });
+        // The deadline covers the full body too. A server may send headers and
+        // then stall; clearing the timer at headers stranded runtime pollers.
+        text = await res.text();
     }
     catch (err) {
         clearTimeout(timer);
@@ -89,7 +93,6 @@ async function rpc(name, args = {}) {
         throw err;
     }
     clearTimeout(timer);
-    const text = await res.text();
     let parsed = undefined;
     if (text) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.30.13",
+  "version": "0.30.14",
   "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": [
@@ -40,6 +40,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-assets.js",
     "start": "node dist/cli.js",
+    "direct:relay": "node dist/direct/relay-main.js",
+    "test:direct": "npm run build && node --test test/direct-*.test.mjs",
     "dev": "tsc -p tsconfig.json && node dist/cli.js",
     "test": "npm run build && node --test test/*.test.mjs",
     "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
@@ -51,6 +53,8 @@
   },
   "dependencies": {
     "@addai/node-flows": "^1.0.0",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/headless": "^6.0.0",
     "node-pty": "^1.1.0",
     "ws": "^8.21.3"
   },

package/scripts/copy-assets.js

@@ -1,11 +1,13 @@
-// tsc compiles .ts and ignores everything else, but two files in this package
-// are deliberately plain .mjs: they run inside a desktop container (node 22,
+// tsc compiles .ts and ignores everything else, but some files in this package
+// are deliberately plain JavaScript: they run inside a desktop container (node 22,
 // no build step, no node_modules) rather than in the daemon. Ship them next to
 // the compiled output so dist/ is self-contained.
 const fs = require('fs');
 const path = require('path');
 
 const ASSETS = [
+  ['src/entitybox/container-action.cjs', 'dist/entitybox/container-action.cjs'],
+  ['src/entitybox/container-watchdog.cjs', 'dist/entitybox/container-watchdog.cjs'],
   ['src/desktop/learn/recorder.mjs', 'dist/desktop/learn/recorder.mjs'],
   ['src/desktop/learn/injected.mjs', 'dist/desktop/learn/injected.mjs'],
   ['src/desktop/vault-seed.mjs', 'dist/desktop/vault-seed.mjs'],