@addai/node 0.4.0

package/dist/self-update.d.ts

@@ -0,0 +1,75 @@
+/** How this daemon was launched — decides how to respawn it. */
+export type LaunchMode = 
+/** `npm i -g @addai/node` → a versioned dir under a global prefix. */
+'global'
+/** `npx @addai/node` → a throwaway dir under npm's _npx cache. */
+ | 'npx'
+/** `node dist/cli.js` from a git checkout — restart only, never version-bump. */
+ | 'source';
+export interface RespawnPlan {
+    /** Executable to spawn. */
+    file: string;
+    /** Argv for it. */
+    args: string[];
+    /** Whether a global install must succeed first for the version to change. */
+    installFirst: boolean;
+    /** False when the launch mode cannot change version (source checkouts). */
+    canChangeVersion: boolean;
+}
+export declare const PACKAGE_NAME = "@addai/node";
+/**
+ * Classify the launch from the running script's path.
+ *
+ * npx caches each invocation under `<npm-cache>/_npx/<hash>/node_modules/…`,
+ * so that segment is the reliable npx tell on every platform (checked first:
+ * an npx dir also contains `node_modules`, so a node_modules-based `global`
+ * test would swallow it). A global install lives under a prefix's
+ * `node_modules/@addai/node`. Anything else — most importantly
+ * `node dist/cli.js` in a git worktree — is a source checkout.
+ */
+export declare function detectLaunchMode(entryPath: string): LaunchMode;
+/**
+ * Argv for the replacement daemon.
+ *
+ * - `global`: npm overwrites the package in place, so re-execing the SAME
+ *   entry path picks up the new code. (Re-resolving through the shim would
+ *   also work but adds a Windows .cmd hop for no benefit.)
+ * - `npx`: the current entry lives in a cache dir pinned to the OLD version,
+ *   so re-execing it would relaunch the old code forever. Go back through
+ *   npx with an explicit version spec instead.
+ * - `source`: re-exec the same entry. A checkout's version comes from git,
+ *   not npm, so this is a restart — never a version change.
+ */
+export declare function planRespawn(mode: LaunchMode, entryPath: string, targetVersion: string, execPath?: string, 
+/** Args the daemon was started WITH, after the entry path (process.argv
+ *  slice(2)) — carried across the restart so a node launched as
+ *  `… cli.js run --foo` doesn't silently come back up without them. */
+userArgs?: string[]): RespawnPlan;
+export interface RestartHandoff {
+    command_id: string;
+    from_version: string;
+    target_version: string;
+    mode: LaunchMode;
+    at: string;
+    /** Runs that finished during the drain, and runs still going when the
+     *  drain ceiling expired — carried so the roll reports whether it left
+     *  work unfinished rather than claiming a clean restart either way. */
+    drained?: number;
+    timed_out?: number;
+}
+export declare function handoffPath(runtimeDir: string): string;
+export declare function writeHandoff(runtimeDir: string, h: RestartHandoff): void;
+/** Reads and DELETES the handoff — it must never be replayed twice. */
+export declare function takeHandoff(runtimeDir: string): RestartHandoff | null;
+/**
+ * `npm i -g <pkg>@<version>`. Returns null on success, else the reason.
+ * Never throws — a failed install must leave the CURRENT daemon running
+ * rather than take the node down.
+ */
+export declare function installGlobal(targetVersion: string, timeoutMs?: number): Promise<string | null>;
+/**
+ * Spawn the replacement daemon fully detached, so it survives this process's
+ * exit. stdio is redirected to the daemon log (inheriting our stdio would tie
+ * the child to a terminal that is about to go away).
+ */
+export declare function spawnReplacement(plan: RespawnPlan, logPath: string, cwd?: string): void;

package/dist/self-update.js

@@ -0,0 +1,192 @@
+"use strict";
+// Remote restart / self-update.
+//
+// Until now a runtime change only reached the fleet if somebody walked to
+// each AiNode and restarted the daemon by hand — which is why the fleet sat
+// on 0.2.51/0.2.52/0.2.53 for days after 0.2.55 shipped. This module lets an
+// `update_runtime` command (issued from Entity Studio, executed by
+// command-runner) drain the node gracefully, install the requested version,
+// and re-exec itself.
+//
+// The daemon is NOT supervised on any of our nodes — nothing restarts it if
+// it merely exits. So the restart is a self-respawn: we spawn a DETACHED
+// child that outlives us, then exit. Getting the child's argv right depends
+// on how this daemon was started, hence the launch detection below.
+//
+// Truth contract (same shape as the harness-login flow): the command is NOT
+// completed by the process that exits. It is left `running` with a
+// handoff file on disk, and the NEWLY STARTED daemon completes it on boot
+// with the version it actually came up as. A restart that never comes back
+// therefore never reports success.
+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.PACKAGE_NAME = void 0;
+exports.detectLaunchMode = detectLaunchMode;
+exports.planRespawn = planRespawn;
+exports.handoffPath = handoffPath;
+exports.writeHandoff = writeHandoff;
+exports.takeHandoff = takeHandoff;
+exports.installGlobal = installGlobal;
+exports.spawnReplacement = spawnReplacement;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const win_1 = require("./win");
+exports.PACKAGE_NAME = '@addai/node';
+/**
+ * Classify the launch from the running script's path.
+ *
+ * npx caches each invocation under `<npm-cache>/_npx/<hash>/node_modules/…`,
+ * so that segment is the reliable npx tell on every platform (checked first:
+ * an npx dir also contains `node_modules`, so a node_modules-based `global`
+ * test would swallow it). A global install lives under a prefix's
+ * `node_modules/@addai/node`. Anything else — most importantly
+ * `node dist/cli.js` in a git worktree — is a source checkout.
+ */
+function detectLaunchMode(entryPath) {
+    const p = entryPath.replace(/\\/g, '/');
+    if (/\/_npx\//.test(p))
+        return 'npx';
+    if (p.includes(`/node_modules/${exports.PACKAGE_NAME}/`))
+        return 'global';
+    return 'source';
+}
+/**
+ * Argv for the replacement daemon.
+ *
+ * - `global`: npm overwrites the package in place, so re-execing the SAME
+ *   entry path picks up the new code. (Re-resolving through the shim would
+ *   also work but adds a Windows .cmd hop for no benefit.)
+ * - `npx`: the current entry lives in a cache dir pinned to the OLD version,
+ *   so re-execing it would relaunch the old code forever. Go back through
+ *   npx with an explicit version spec instead.
+ * - `source`: re-exec the same entry. A checkout's version comes from git,
+ *   not npm, so this is a restart — never a version change.
+ */
+function planRespawn(mode, entryPath, targetVersion, execPath = process.execPath, 
+/** Args the daemon was started WITH, after the entry path (process.argv
+ *  slice(2)) — carried across the restart so a node launched as
+ *  `… cli.js run --foo` doesn't silently come back up without them. */
+userArgs = []) {
+    const spec = `${exports.PACKAGE_NAME}@${targetVersion || 'latest'}`;
+    if (mode === 'npx') {
+        const inv = (0, win_1.resolveCliInvocation)('npx', ['-y', spec, ...userArgs]);
+        return { file: inv.file, args: inv.args, installFirst: false, canChangeVersion: true };
+    }
+    return {
+        file: execPath,
+        args: [entryPath, ...userArgs],
+        installFirst: mode === 'global',
+        canChangeVersion: mode === 'global',
+    };
+}
+function handoffPath(runtimeDir) {
+    return path.join(runtimeDir, 'restart.json');
+}
+function writeHandoff(runtimeDir, h) {
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    fs.writeFileSync(handoffPath(runtimeDir), JSON.stringify(h), 'utf8');
+}
+/** Reads and DELETES the handoff — it must never be replayed twice. */
+function takeHandoff(runtimeDir) {
+    const f = handoffPath(runtimeDir);
+    try {
+        const raw = fs.readFileSync(f, 'utf8');
+        try {
+            fs.unlinkSync(f);
+        }
+        catch { /* already gone */ }
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed.command_id === 'string' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `npm i -g <pkg>@<version>`. Returns null on success, else the reason.
+ * Never throws — a failed install must leave the CURRENT daemon running
+ * rather than take the node down.
+ */
+async function installGlobal(targetVersion, timeoutMs = 5 * 60_000) {
+    const spec = `${exports.PACKAGE_NAME}@${targetVersion || 'latest'}`;
+    const inv = (0, win_1.resolveCliInvocation)('npm', ['i', '-g', spec]);
+    return new Promise((resolve) => {
+        let stderr = '';
+        let settled = false;
+        const done = (v) => { if (!settled) {
+            settled = true;
+            resolve(v);
+        } };
+        try {
+            const child = (0, child_process_1.spawn)(inv.file, inv.args, { windowsHide: true, env: process.env });
+            const timer = setTimeout(() => { try {
+                child.kill('SIGKILL');
+            }
+            catch { /* gone */ } done(`npm i -g ${spec} timed out`); }, timeoutMs);
+            timer.unref?.();
+            child.stderr?.on('data', b => { stderr += b.toString('utf8'); });
+            child.on('error', err => { clearTimeout(timer); done(`npm i -g failed to start: ${err.message}`); });
+            child.on('exit', code => {
+                clearTimeout(timer);
+                done(code === 0 ? null : `npm i -g ${spec} exited ${code}: ${stderr.trim().slice(-400)}`);
+            });
+        }
+        catch (err) {
+            done(`npm i -g failed to start: ${err.message}`);
+        }
+    });
+}
+/**
+ * Spawn the replacement daemon fully detached, so it survives this process's
+ * exit. stdio is redirected to the daemon log (inheriting our stdio would tie
+ * the child to a terminal that is about to go away).
+ */
+function spawnReplacement(plan, logPath, cwd) {
+    let out = 'ignore';
+    try {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        out = fs.openSync(logPath, 'a');
+    }
+    catch { /* no log → /dev/null is still better than not restarting */ }
+    const child = (0, child_process_1.spawn)(plan.file, plan.args, {
+        detached: true,
+        windowsHide: true,
+        cwd,
+        env: process.env,
+        stdio: ['ignore', out, out],
+    });
+    child.unref();
+}

package/dist/session-runner.d.ts

@@ -0,0 +1,130 @@
+import type { RuntimePermissionMode, RuntimeEffortLevel } from './types';
+/** Shape of a row returned by runtime_pick_next_request. */
+export interface RuntimeRequestRow {
+    id: string;
+    runtime_id: string;
+    project_id: string | null;
+    agent: 'claude' | 'claude-tui' | 'claude-bypass' | 'codex' | 'kimi' | 'gemini' | 'grok';
+    mode: 'tui' | 'print';
+    model: string | null;
+    effort: RuntimeEffortLevel | null;
+    permission_mode: RuntimePermissionMode | null;
+    prompt: string | null;
+    /** Execution timeout in seconds from the dispatching node. null/0 =
+     *  unlimited — the agent runs until it finishes naturally (print exits /
+     *  TUI goes idle). When set, the daemon kills the agent after this long
+     *  and completes the request with whatever output it produced so far. */
+    timeout_seconds: number | null;
+    resume_session_id: string | null;
+    working_directory: string | null;
+    /** Ephemeral git clone for "one-off repo" chats. When set + project_id
+     *  is null, the daemon clones the repo into the session cwd before
+     *  spawning the agent. No project row created. */
+    ephemeral_git_remote: string | null;
+    ephemeral_git_branch: string | null;
+    ephemeral_git_credential_id: string | null;
+    /** Multi-repo variant: array of { remote, branch?, credential_id? }.
+     *  When this has >=2 entries the daemon creates a session workspace
+     *  cwd and clones each repo into a subdirectory of it (named after
+     *  the repo). When it has 0 or 1 entry the daemon falls back to the
+     *  singular ephemeral_git_remote path above — chats from older
+     *  Studio builds still work unchanged. */
+    ephemeral_git_remotes: Array<{
+        remote: string;
+        branch?: string | null;
+        credential_id?: string | null;
+    }> | null;
+    mcp_mode: 'inherit' | 'none' | 'override';
+    mcps_override: string[];
+    skills_override: string[];
+    packages_override: string[];
+    /** Studio entities (presets) carry a system prompt that the agent should
+     *  honor on each turn. Wired through via chat_send. */
+    system_prompt: string | null;
+    /** Restricted tool list (claude only). Null = use defaults. */
+    allowed_tools: string[] | null;
+    /** Where the request came from. 'flow' = single-turn (auto-close after
+     *  turn_complete so the engine can resume). 'chat' = stay open for
+     *  follow-up turns until the user explicitly ends the session.
+     *  'widgetstudio' = Widget Studio vibecode session (triggers the
+     *  widget-vibecode-resume callback + injects streaming env vars). */
+    issued_via: string | null;
+    /** Per-session env-var overrides keyed by MCP slug. The daemon merges
+     *  these into each MCP's env at install time, taking precedence over
+     *  credential-supplied values. Used by widgetstudio for dynamic streaming
+     *  auth tokens (request id) that can't live in a static vault credential.
+     *  Shape: { "<mcp_slug>": { "<ENV>": "val" } } */
+    mcp_env_overrides: Record<string, Record<string, string>> | null;
+    /** Per-skill variable values keyed by skill id → { varName: value }.
+     *  Forwarded to install() and substituted into each skill's {{var.<name>}}
+     *  tokens before SKILL.md is written. Optional — older rows omit it and
+     *  the daemon defaults to {} (no substitution beyond skill defaults). */
+    skill_var_values?: Record<string, Record<string, string>> | null;
+    /** Self-improve flag for autonomous entities. When truthy AND the run
+     *  reaches a `completed` terminal status, the daemon fires a best-effort
+     *  POST to the `entity-self-improve` edge function so the entity can
+     *  update its own skill based on what just happened in the run. Optional
+     *  on the row — older Studio/flows builds simply omit it and the hook is
+     *  a no-op. Populated by the Studio dispatch side from
+     *  entity_studio_entities.self_improve. */
+    self_improve?: boolean | null;
+    /** The owning Studio entity profile id (= entity_studio_entities.id).
+     *
+     *  Runtime "entity_id alias" fix (final phase-3 review finding): the row
+     *  this daemon actually gets from `runtime_pick_next_request` (studio
+     *  repo, supabase/migrations/20260718101000_memory_v3_pick_member.sql)
+     *  is the BARE `entity_runtime_requests` rowtype — no jsonb aliasing — so
+     *  PostgREST serializes the owning-entity column under its real name,
+     *  `entity_studio_entity_id`. THAT is the field to read at pick-row call
+     *  sites (see resolvePackEntityId in memory-pack.ts). `entity_id` below
+     *  is kept only as a secondary fallback for shapes that DO alias it (e.g.
+     *  `runtime_request_get_meta`, which returns `entity_id` via
+     *  jsonb_build_object — see notifySelfImproveIfEnabled/
+     *  notifyCaptureIfEnabled below, which read it from that RPC's response
+     *  and are unaffected by this fix). Both optional; null for non-entity
+     *  runs. */
+    entity_studio_entity_id?: string | null;
+    entity_id?: string | null;
+    /** user_profiles.id of the requesting member (memory_v3, T2). Stamped by
+     *  the dispatch fns and surfaced by runtime_pick_next_request; null on
+     *  memberless surfaces and rows from older Studio builds. */
+    member_profile_id?: string | null;
+    /** Guardrails recursion guard — true on checker requests and internal
+     *  dispatches. The for-request RPC re-checks server-side; this field just
+     *  saves the RPC round-trip. Optional: older Studio builds omit it. */
+    guardrails_skip?: boolean | null;
+    /** Attempts already burned on this request (shared counter with the
+     *  server-side stale-reclaim). Drives the retry backoff step; the cap is
+     *  enforced server-side in runtime_request_mark_retry. Optional: rows
+     *  from older schemas omit it. */
+    retry_count?: number | null;
+    /** Ladder hops already burned on this request (shared counter with the
+     *  server-side failover RPC). Drives the runtime_request_failover_agent
+     *  decision to hop provider vs. dead-letter. Optional: rows from older
+     *  schemas omit it. */
+    ladder_hops?: number | null;
+    /** Phase 4 T7 — NOT a DB column. Set in-process by runRequest() right
+     *  after the memory-pack fetch resolves (applyMemoryPack's onFlagged
+     *  callback reuses the SAME round trip entity-memory-pack already makes
+     *  every turn — no extra network call, no daemon-side memory_v2 lookup).
+     *  Read by runClaudeTui() to decide whether to write the per-session
+     *  PreCompact capture hook. Undefined for every run where the pack fetch
+     *  never fired (non-entity runs) — those never get the hook, same as
+     *  before this field existed. */
+    memoryV2Flagged?: boolean;
+}
+export declare function notifyFlowsIfFlowRequest(requestId: string): Promise<void>;
+export declare function notifyWidgetstudioIfWidgetRequest(requestId: string): Promise<void>;
+export declare function notifySelfImproveIfEnabled(requestId: string): Promise<void>;
+/** A stored resume id is only valid TOGETHER WITH the cwd it was created in:
+ *  claude looks its transcript up under a cwd-derived project dir, grok buckets
+ *  its session store by cwd. So when the recorded working_directory is gone and
+ *  we could not re-create it (it belongs to another machine, or to this machine
+ *  before the runtime home moved — e.g. ~/.entities-runtime → ~/.ainode), the
+ *  session id is dead: resuming it can only fail with "No conversation found
+ *  with session ID: <id>". Start fresh instead of burning an attempt on a
+ *  guaranteed error and making the user read a failure we already expect.
+ *
+ *  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>;