@addai/node 0.4.0

package/dist/index.js

@@ -0,0 +1,440 @@
+"use strict";
+// ainode — the +Ai Node background daemon that pairs with +Ai (Supabase)
+// and runs Claude / Codex sessions on behalf of authenticated requests.
+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.VERSION = void 0;
+exports.start = start;
+const path = __importStar(require("path"));
+const control_server_1 = require("./control-server");
+const paths_1 = require("./paths");
+const state_migrate_1 = require("./state-migrate");
+const lockfile_1 = require("./lockfile");
+const mcp_config_1 = require("./mcp-config");
+const store_1 = require("./store");
+const supabase_client_1 = require("./supabase-client");
+const pairing_1 = require("./pairing");
+const heartbeat_1 = require("./heartbeat");
+const command_runner_1 = require("./command-runner");
+const self_update_1 = require("./self-update");
+const sleep_detector_1 = require("./sleep-detector");
+const claude_config_1 = require("./claude-config");
+const request_pump_1 = require("./request-pump");
+const projects_1 = require("./projects");
+const session_runner_1 = require("./session-runner");
+const diskguard_1 = require("./diskguard");
+const pty_helper_1 = require("./pty-helper");
+// Read version from package.json at module-load. Previously hardcoded to
+// '0.1.0' and never updated when package.json bumped — the CLI banner lied
+// about which version was actually running, making upgrade verification
+// hard ("addai-entity-runtime --version" always said 0.1.0).
+const VERSION = (() => {
+    try {
+        // Resolves from compiled dist/ → ../package.json.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const pkg = require('../package.json');
+        if (typeof pkg.version === 'string' && pkg.version.length > 0)
+            return pkg.version;
+    }
+    catch { /* fall through */ }
+    return '0.0.0';
+})();
+exports.VERSION = VERSION;
+// ── Daemon crash guard ──────────────────────────────────────────────────────
+// A long-running daemon that spawns one child process per request must never
+// die because a single request's child emitted an 'error' event with no
+// listener, or a fire-and-forget promise rejected. Node's default is to crash
+// the whole process — which kills every other session and wedges in-flight
+// requests at 'running'. There is no OS supervisor on Windows to restart us,
+// so we log and stay up; each request already has its own failure path
+// (failRequest → 'spawn_failed'/etc.). This is the backstop behind the
+// per-spawn guards in claude-print.ts / claude-spawn.ts / *-binary.ts.
+process.on('uncaughtException', (err) => {
+    console.error('[runtime] uncaughtException — daemon staying up:', err?.stack ?? err);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[runtime] unhandledRejection — daemon staying up:', reason instanceof Error ? reason.stack : reason);
+});
+/**
+ * Boot the daemon. If we don't have a pairing yet, run the user through
+ * the 5-letter code flow first; once paired, kick off the heartbeat.
+ */
+async function start() {
+    const migration = (0, state_migrate_1.migrateLegacyStateDir)();
+    if (migration.migrated) {
+        const parts = [
+            migration.copied.length ? `copied ${migration.copied.join(', ')}` : '',
+            migration.moved.length ? `moved ${migration.moved.join(', ')}` : '',
+        ].filter(Boolean).join('; ');
+        console.log(`[ainode] state migrated to ~/.ainode (${parts})`);
+    }
+    (0, mcp_config_1.cleanupAllSessionMcpConfigs)();
+    // Pre-accept claude's bypass-permissions warning once so daemon-spawned
+    // TUIs don't block on the dialog. Idempotent + best-effort.
+    (0, claude_config_1.ensureBypassPermissionsAccepted)();
+    // node-pty's spawn-helper can arrive without its +x bit (npm extraction;
+    // reproducible under npx). Without it EVERY pty spawn — harness logins
+    // and claude TUI runs — dies with "posix_spawnp failed.". Repair here so
+    // a node that installed broken heals on restart, not on reinstall.
+    {
+        const line = (0, pty_helper_1.describeRepair)((0, pty_helper_1.ensurePtyHelperExecutable)());
+        if (line)
+            console.log(line);
+    }
+    const control = await (0, control_server_1.startControlServer)();
+    let lock;
+    try {
+        lock = (0, lockfile_1.acquireLockfile)({ port: control.port, version: VERSION, startedAt: Date.now() });
+    }
+    catch (err) {
+        await control.close();
+        throw err;
+    }
+    if (!(0, store_1.isPaired)()) {
+        try {
+            const code = await (0, pairing_1.requestPairCode)();
+            (0, pairing_1.printPairingInstructions)(code);
+            const result = await (0, pairing_1.awaitPairing)(code);
+            console.log(`  ✓ Paired (runtime_id: ${result.runtime_id})`);
+            console.log('');
+        }
+        catch (err) {
+            console.error('Pairing failed:', err.message || err);
+            await control.close();
+            (0, lockfile_1.releaseLockfile)();
+            throw err;
+        }
+    }
+    // Begin the heartbeat — this also pushes the first capabilities probe
+    // up to Supabase so the runtime appears "online" immediately. When the
+    // server reports queued install/login commands, the command runner
+    // drains them.
+    (0, heartbeat_1.setPendingCommandsHook)(command_runner_1.wake);
+    (0, heartbeat_1.start)();
+    // If we are the daemon a remote `update_runtime` restarted INTO, close out
+    // that command now — with the version we actually came up as. The process
+    // that issued the restart could not report this: it had to exit to make
+    // room for us. A restart that never came back leaves the command `running`
+    // and the node silent, which is exactly the signal we want.
+    void finalizeRestartHandoff();
+    // Crash recovery: if we restarted while requests were still
+    // 'starting'/'running', fail them so paused flow runs can resume.
+    // Best effort — pairing failures shouldn't block startup.
+    reclaimOrphanedRequests('startup').catch(err => console.error('[startup] reclaim error:', err.message));
+    // Sweep stale session dirs (>7 days old). Each request mints a fresh
+    // dir under ~/.ainode/sessions/<reqId>/ which can hold a
+    // 50-500 MB git clone. Without periodic cleanup, a chatty runtime
+    // fills the user's home disk silently over months. Run async at
+    // startup; if it fails, we just keep using the host disk.
+    sweepStaleSessionDirs().catch(err => console.error('[startup] session sweep error:', err.message));
+    // DiskGuard: CCTV-style watermark eviction of the per-run Codex scratch
+    // dirs under os.tmpdir(). codex-spawn cleans up its own dir on exit; this
+    // is the safety net for SIGKILL/crash/orphan cases that skip that path.
+    // On a dedicated runtime host these dirs once grew to ~158 GiB and filled
+    // the disk. Sweeps at startup and on its own interval; unref'd so it never
+    // keeps the process alive.
+    const diskGuard = (0, diskguard_1.getDiskGuard)();
+    diskGuard.start();
+    // Long-lived zombie sweeper: even when the daemon stays alive, a
+    // spawn can die silently (no onExit) or hang past the JSONL timeout
+    // and never reach a terminal status. The RPC's 5-minute stale-after
+    // window means it's safe to call periodically; in-flight legitimate
+    // requests are protected by recent activity timestamps.
+    const reclaimInterval = setInterval(() => {
+        reclaimOrphanedRequests('periodic').catch(err => console.error('[periodic] reclaim error:', err.message));
+    }, 5 * 60 * 1000);
+    // Don't keep the process alive just for this timer.
+    reclaimInterval.unref?.();
+    // Sleep/wake detector: a laptop runtime (e.g. a MacBook) suspends when the
+    // lid closes — timers freeze, in-flight runs stall, and the server watchdog
+    // eventually fails them. On resume, wall-clock has jumped far past the last
+    // probe. When we detect that, immediately push a heartbeat (so the server
+    // stops treating us as offline) and reclaim our own in-flight runs (they
+    // went stale while suspended) so they re-dispatch — to a backup node if
+    // we're still coming back to life.
+    const sleepMonitor = (0, sleep_detector_1.startSleepMonitor)({
+        intervalMs: 30_000,
+        thresholdMs: 90_000, // >90s late = we were suspended (matches server offline window)
+        onWake: (gapMs) => {
+            console.warn(`[wake] detected ~${Math.round(gapMs / 1000)}s suspend — re-heartbeating and reclaiming in-flight runs`);
+            void (0, heartbeat_1.beat)().catch(() => { });
+            reclaimOrphanedRequests('wake').catch(err => console.error('[wake] reclaim error:', err.message));
+        },
+    });
+    // Begin polling for pending requests.
+    (0, request_pump_1.start)();
+    // …and for pending projects (git clones, future MCP/skill installs).
+    (0, projects_1.start)();
+    let stopped = false;
+    // Outcome of the last drain, so a remote roll can report whether it left
+    // work unfinished instead of claiming a clean restart either way.
+    let lastDrain = { drained: 0, timedOut: 0 };
+    const stop = async (drainTimeoutMs = 15_000) => {
+        if (stopped)
+            return;
+        stopped = true;
+        // Stop accepting new work first — otherwise the pump would queue
+        // another request between drain start and process exit.
+        (0, projects_1.stop)();
+        (0, request_pump_1.stop)();
+        (0, heartbeat_1.stop)();
+        sleepMonitor.stop();
+        diskGuard.stop();
+        // Graceful drain: wait up to drainTimeoutMs for in-flight requests
+        // to settle so child spawns get a chance to finish their final
+        // setStatus → notifyFlows webhooks. Without this, a SIGTERM would
+        // leave paused flow runs stuck `waiting` until server-side reclaim
+        // (5 min) requeued or failed them.
+        try {
+            const { drained, timedOut } = await (0, request_pump_1.drain)(drainTimeoutMs);
+            lastDrain = { drained, timedOut };
+            if (drained || timedOut) {
+                console.log(`[shutdown] drained ${drained} request(s); ${timedOut} still in-flight (timed out)`);
+            }
+        }
+        catch (err) {
+            console.error('[shutdown] drain error:', err.message);
+        }
+        // Announce offline AFTER draining, so in-flight runs finish on us first
+        // (marking offline earlier could let failover reassign a run we're about
+        // to complete — a needless double-run). Anything still unfinished past the
+        // drain timeout now fails over instantly instead of waiting the 90s window.
+        await (0, heartbeat_1.goOffline)();
+        await control.close();
+        (0, lockfile_1.releaseLockfile)();
+    };
+    // Remote roll: drain like a clean shutdown, install the target version if
+    // this launch mode can, then hand over to a detached replacement. The
+    // handoff file is written only AFTER the replacement is spawned, so a
+    // failure anywhere before that leaves this daemon running and the command
+    // is failed by the caller instead of silently taking the node down.
+    (0, command_runner_1.setRestartHook)(async ({ commandId, version }) => {
+        const mode = (0, self_update_1.detectLaunchMode)(process.argv[1] ?? '');
+        const plan = (0, self_update_1.planRespawn)(mode, process.argv[1] ?? '', version, process.execPath, process.argv.slice(2));
+        if (plan.installFirst) {
+            const err = await (0, self_update_1.installGlobal)(version);
+            if (err)
+                throw new Error(err);
+        }
+        // Drain generously — a restart is elective, so it should never guillotine
+        // a live entity turn the way a 15s SIGTERM drain would.
+        await stop(RESTART_DRAIN_MS);
+        // Point of no return. Past this line a replacement daemon exists, so we
+        // MUST exit — two live daemons on one node is worse than a command left
+        // unreported. Hence the handoff write (which only affects reporting) can
+        // never abort the exit.
+        (0, self_update_1.spawnReplacement)(plan, path.join(paths_1.RUNTIME_HOME, 'daemon.log'), process.cwd());
+        try {
+            (0, self_update_1.writeHandoff)(paths_1.RUNTIME_HOME, {
+                command_id: commandId,
+                from_version: VERSION,
+                target_version: version,
+                mode,
+                at: new Date().toISOString(),
+                drained: lastDrain.drained,
+                timed_out: lastDrain.timedOut,
+            });
+        }
+        catch (err) {
+            console.error('[restart] handoff write failed — the roll still happened, it just cannot self-report:', err.message);
+        }
+        console.log(`[restart] handed over to ${plan.file} (${mode} → ${version}); exiting`);
+        setTimeout(() => process.exit(0), 250).unref?.();
+    });
+    process.once('SIGINT', () => { stop().finally(() => process.exit(0)); });
+    process.once('SIGTERM', () => { stop().finally(() => process.exit(0)); });
+    if (process.platform === 'win32') {
+        // SIGTERM never fires on Windows. The signals that DO exist there:
+        // SIGBREAK (Ctrl+Break) and SIGHUP (console window closed — Windows
+        // gives ~5s before hard-killing, enough to release the lockfile and
+        // start the drain). Without these, any non-Ctrl+C stop skips cleanup
+        // and leaves a stale lockfile that blocks the next daemon start until
+        // the pid-liveness check catches up.
+        process.once('SIGBREAK', () => { stop().finally(() => process.exit(0)); });
+        process.once('SIGHUP', () => { stop().finally(() => process.exit(0)); });
+    }
+    process.once('beforeExit', () => { (0, lockfile_1.releaseLockfile)(); });
+    return { port: lock.port, pid: lock.pid, stop };
+}
+async function sweepStaleSessionDirs() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const fs = require('fs');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const path = require('path');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { RUNTIME_SESSIONS_DIR } = require('./paths');
+    if (!fs.existsSync(RUNTIME_SESSIONS_DIR))
+        return;
+    const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+    const cutoff = Date.now() - SEVEN_DAYS_MS;
+    // A directory's own mtime only moves when an ENTRY is added or removed, and
+    // a continuation turn merely overwrites the files already in place
+    // (.entities-runtime.mcp.json, .grok/config.toml, skills). So a chat used
+    // every day still looks "last touched" on the day it was created, and a pure
+    // conversation — one that never creates or deletes a file — ages into the
+    // cutoff while fully live. Take the newest mtime among the dir and its
+    // immediate children instead: the per-run config rewrite lands there, which
+    // makes this a real liveness signal rather than a creation date.
+    const effectiveMtimeMs = (dir, dirMtimeMs) => {
+        let newest = dirMtimeMs;
+        try {
+            for (const child of fs.readdirSync(dir)) {
+                try {
+                    const st = fs.statSync(path.join(dir, child));
+                    if (st.mtimeMs > newest)
+                        newest = st.mtimeMs;
+                }
+                catch { /* skip unreadable child */ }
+            }
+        }
+        catch { /* unreadable dir — fall back to its own mtime */ }
+        return newest;
+    };
+    let removed = 0;
+    let kept = 0;
+    for (const name of fs.readdirSync(RUNTIME_SESSIONS_DIR)) {
+        const p = path.join(RUNTIME_SESSIONS_DIR, name);
+        try {
+            const st = fs.statSync(p);
+            if (!st.isDirectory())
+                continue;
+            if (effectiveMtimeMs(p, st.mtimeMs) < cutoff) {
+                // Deleting a session dir un-homes any chat still resuming a session
+                // keyed to it, so say which ones went — the old count-only line made
+                // that class of breakage invisible.
+                console.log(`[startup] sweeping stale session dir: ${p}`);
+                fs.rmSync(p, { recursive: true, force: true });
+                removed++;
+            }
+            else {
+                kept++;
+            }
+        }
+        catch { /* skip unreadable entry */ }
+    }
+    if (removed > 0) {
+        console.log(`[startup] swept ${removed} session dir(s) unused for 7d; ${kept} kept`);
+    }
+}
+/** How long a remote restart waits for live turns to finish before handing
+ *  over. Elective, so far more generous than the 15s SIGTERM drain. */
+const RESTART_DRAIN_MS = 10 * 60_000;
+/**
+ * Complete the `update_runtime` command that restarted us, if any.
+ *
+ * Reports the version this process ACTUALLY came up as, which is the whole
+ * point: an update that installed but relaunched the old bits (the npx cache
+ * trap) reports the old version rather than a cheerful "completed".
+ */
+async function finalizeRestartHandoff() {
+    // Read the token BEFORE consuming the handoff: takeHandoff deletes the file,
+    // so bailing after it would strand the command as `running` forever with
+    // nothing left on disk to retry from.
+    const t = (0, store_1.readPairing)()?.daemonToken;
+    if (!t)
+        return;
+    const h = (0, self_update_1.takeHandoff)(paths_1.RUNTIME_HOME);
+    if (!h)
+        return;
+    const changed = h.from_version !== VERSION;
+    const wanted = h.target_version;
+    const missed = wanted !== 'latest' && wanted !== VERSION;
+    try {
+        await (0, supabase_client_1.rpc)('runtime_command_update', {
+            p_token: t,
+            p_id: h.command_id,
+            p_status: missed ? 'failed' : 'completed',
+            p_payload: {
+                step: 'done',
+                from_version: h.from_version,
+                version: VERSION,
+                mode: h.mode,
+                restarted: true,
+                version_changed: changed,
+                drained: h.drained ?? 0,
+                // >0 means the drain ceiling expired with work still running — the
+                // roll went ahead over the top of it. Visible rather than implied.
+                interrupted_runs: h.timed_out ?? 0,
+            },
+            p_error: missed
+                ? `restarted, but came up as ${VERSION} (wanted ${wanted})`
+                : null,
+        });
+        console.log(`[restart] back up as ${VERSION} (was ${h.from_version}); command ${h.command_id} closed`);
+    }
+    catch (err) {
+        console.error('[restart] could not close command:', err.message);
+    }
+}
+async function reclaimOrphanedRequests(source) {
+    // Honour the shared circuit breaker — if Supabase is overloaded, the
+    // periodic reclaim isn't urgent (server-side reclaim runs anyway). Skip.
+    if ((0, supabase_client_1.rpcShouldSkip)())
+        return;
+    const pairing = (0, store_1.readPairing)();
+    if (!pairing)
+        return;
+    // v2 RPC: returns {request_id, prior_status, requeued}.
+    //   requeued=true  → row is back to 'pending', the request-pump will
+    //                    pick it up and try again. No webhook fires yet —
+    //                    the flow run is still waiting on a terminal state.
+    //   requeued=false → retry budget exhausted, row is now 'failed'. We
+    //                    notify flows so the paused run resumes with the
+    //                    failure.
+    let rows = null;
+    try {
+        rows = await (0, supabase_client_1.rpc)('runtime_reclaim_inflight_requests', {
+            p_token: pairing.daemonToken,
+        });
+    }
+    catch (err) {
+        console.error(`[${source}] reclaim rpc failed:`, err.message);
+        return;
+    }
+    if (!rows || rows.length === 0)
+        return;
+    const requeued = rows.filter(r => r.requeued).length;
+    const failed = rows.length - requeued;
+    console.log(`[${source}] reclaimed ${rows.length} orphaned request(s)`
+        + (requeued ? ` · ${requeued} requeued for retry` : '')
+        + (failed ? ` · ${failed} failed (retry budget exhausted)` : ''));
+    // Only notify flows for the failure-final case. Requeued rows will
+    // notify normally via setStatus when they reach a terminal state.
+    for (const r of rows) {
+        if (r.requeued)
+            continue;
+        void (0, session_runner_1.notifyFlowsIfFlowRequest)(r.request_id).catch(err => console.error(`[${source}] reclaim notify [reqId=${r.request_id}] error: ${err.message}`));
+    }
+}

package/dist/install.d.ts

@@ -0,0 +1,63 @@
+/** Hidden per-session MCP config written next to the agent's working dir. */
+export declare const MCP_CONFIG_FILENAME = ".ainode.mcp.json";
+/** Pre-rename filename; removed when found so agents don't read a stale copy. */
+export declare const LEGACY_MCP_CONFIG_FILENAME = ".entities-runtime.mcp.json";
+export interface InstallSet {
+    /** Registry MCP ids to install (packages are expanded server-side). */
+    mcpIds: string[];
+    /** Registry skill ids to install. */
+    skillIds: string[];
+    /** Registry package ids to expand into their member MCPs + skills. */
+    packageIds: string[];
+}
+interface ResolvedMcp {
+    id: string;
+    name: string;
+    slug: string;
+    command: string;
+    args: string[] | null;
+    /** Resolved env values from the user's vault credential for this MCP.
+     *  Empty object when the MCP doesn't need credentials or the user
+     *  hasn't picked one. */
+    env: Record<string, string> | null;
+    /** Spec from codeflows_mcps.env_vars — what credentials the MCP wants.
+     *  Surface for future UI; not used by the daemon directly. */
+    env_spec: Array<{
+        key: string;
+        label?: string;
+        required?: boolean;
+        help?: string;
+    }> | null;
+    npm_package: string | null;
+    version: string | null;
+}
+export interface InstallResult {
+    /** Path to a written .mcp.json file (suitable for --mcp-config). null = no MCPs installed. */
+    mcpConfigPath: string | null;
+    /** Slugs of skills written to <cwd>/.claude/skills/. */
+    skillSlugs: string[];
+    /** Resolved MCP rows (with env merged) so non-claude agents (codex)
+     *  can build their own MCP config from the same source of truth. */
+    mcps: ResolvedMcp[];
+    /** Cleanup callback — removes everything this install wrote. */
+    dispose: () => Promise<void>;
+}
+/**
+ * Run install side-effects against `cwd` and return paths to clean up
+ * later. Safe to call with an empty set — returns a no-op result.
+ */
+export declare function install(cwd: string, set: InstallSet, credentials?: Record<string, unknown>, 
+/** Per-session env overrides keyed by MCP slug. Merged into each resolved
+ *  MCP's env BEFORE writing .mcp.json, overriding credential-supplied
+ *  values for the same env var. Used by widgetstudio for dynamic
+ *  streaming auth tokens that can't live in a static vault credential. */
+envOverrides?: Record<string, Record<string, string>>, 
+/** Per-skill variable values keyed by skill id → { varName: value }.
+ *  Overlaid onto each skill's variable defaults and substituted into the
+ *  skill content via {{var.<name>}} tokens before SKILL.md is written. */
+skillVarValues?: Record<string, Record<string, string>>, 
+/** The entity_runtime_requests row being installed. Passed to the server
+ *  so credential resolution is scoped to THIS request instead of the
+ *  latest in-flight request on the runtime. */
+requestId?: string): Promise<InstallResult>;
+export {};