@addai/node 0.4.0

package/dist/pairing.js

@@ -0,0 +1,129 @@
+"use strict";
+// First-run pairing flow. Called when state.json doesn't exist. Walks the
+// user through obtaining a 5-letter code and entering it at
+// vault.add.ai/add/entity. Once finalized, persists the daemon_token.
+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.requestPairCode = requestPairCode;
+exports.awaitPairing = awaitPairing;
+exports.printPairingInstructions = printPairingInstructions;
+const os = __importStar(require("os"));
+const supabase_client_1 = require("./supabase-client");
+const store_1 = require("./store");
+const config_1 = require("./config");
+function platform() {
+    const p = process.platform;
+    if (p === 'darwin' || p === 'linux' || p === 'win32')
+        return p;
+    return 'linux';
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+/**
+ * Request a fresh 5-letter pairing code.
+ * Returns the code; the caller is responsible for displaying it.
+ */
+async function requestPairCode() {
+    return (0, supabase_client_1.rpc)('runtime_pair_request_code', {
+        p_hostname: os.hostname(),
+        p_platform: platform(),
+    });
+}
+/**
+ * Block until the user has claimed the code at vault.add.ai or until the
+ * code expires. Returns the runtime_id + raw daemon_token on success.
+ * Saves the pairing to ~/.ainode/state.json.
+ */
+async function awaitPairing(code) {
+    const deadline = Date.now() + config_1.PAIR_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const rows = await (0, supabase_client_1.rpc)('runtime_pair_finalize', { p_code: code });
+            // PostgREST returns a `setof record` as an array of objects.
+            const row = Array.isArray(rows) ? rows[0] : rows;
+            if (row?.daemon_token) {
+                (0, store_1.writePairing)({
+                    runtimeId: row.runtime_id,
+                    daemonToken: row.daemon_token,
+                    supabaseUrl: config_1.SUPABASE_URL,
+                    supabaseAnonKey: config_1.SUPABASE_ANON_KEY,
+                    pairedAt: Date.now(),
+                });
+                return row;
+            }
+        }
+        catch (err) {
+            if (err instanceof supabase_client_1.RpcError) {
+                // 'code_not_claimed' just means the user hasn't entered it yet.
+                // Anything else is a hard error — surface it.
+                const msg = err.message || '';
+                if (msg.includes('code_not_claimed')) {
+                    // keep waiting
+                }
+                else if (msg.includes('code_expired') || msg.includes('code_not_found')) {
+                    throw new Error('pair_code_expired');
+                }
+                else if (msg.includes('code_already_consumed')) {
+                    // Shouldn't happen mid-poll, but treat as success-after-the-fact.
+                    throw new Error('pair_code_already_consumed');
+                }
+                else {
+                    throw err;
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+        await sleep(config_1.PAIR_POLL_INTERVAL_MS);
+    }
+    throw new Error('pair_timeout');
+}
+/**
+ * Print the human-facing instructions for a fresh pairing.
+ */
+function printPairingInstructions(code) {
+    console.log('');
+    console.log('  ── Setup needed ──');
+    console.log('');
+    console.log(`  1. Open  ${config_1.VAULT_PAIR_URL}`);
+    console.log(`  2. Enter this code:  ${code}`);
+    console.log('');
+    console.log(`  (or click:  ${config_1.VAULT_PAIR_URL}/${code})`);
+    console.log('');
+    console.log('  Waiting for pairing… (expires in 15 minutes)');
+    console.log('');
+}

package/dist/paths.d.ts

@@ -0,0 +1,9 @@
+export declare const RUNTIME_HOME: string;
+/** Pre-rename home. Read once at startup by state-migrate, never written. */
+export declare const LEGACY_RUNTIME_HOME: string;
+export declare const RUNTIME_STATE_FILE: string;
+export declare const RUNTIME_LOCK_FILE: string;
+export declare const RUNTIME_SESSIONS_DIR: string;
+export declare const CLAUDE_HOME: string;
+export declare const CLAUDE_PROJECTS_DIR: string;
+export declare const RELAY_HOST = "codeflows-relay.shaun-395.workers.dev";

package/dist/paths.js

@@ -0,0 +1,48 @@
+"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.RELAY_HOST = exports.CLAUDE_PROJECTS_DIR = exports.CLAUDE_HOME = exports.RUNTIME_SESSIONS_DIR = exports.RUNTIME_LOCK_FILE = exports.RUNTIME_STATE_FILE = exports.LEGACY_RUNTIME_HOME = exports.RUNTIME_HOME = void 0;
+// All on-disk paths the runtime uses.
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.RUNTIME_HOME = path.join(os.homedir(), '.ainode');
+/** Pre-rename home. Read once at startup by state-migrate, never written. */
+exports.LEGACY_RUNTIME_HOME = path.join(os.homedir(), '.entities-runtime');
+exports.RUNTIME_STATE_FILE = path.join(exports.RUNTIME_HOME, 'state.json');
+exports.RUNTIME_LOCK_FILE = path.join(exports.RUNTIME_HOME, 'runtime.json');
+exports.RUNTIME_SESSIONS_DIR = path.join(exports.RUNTIME_HOME, 'sessions');
+exports.CLAUDE_HOME = path.join(os.homedir(), '.claude');
+exports.CLAUDE_PROJECTS_DIR = path.join(exports.CLAUDE_HOME, 'projects');
+exports.RELAY_HOST = 'codeflows-relay.shaun-395.workers.dev';

package/dist/precompact-hook.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Absolute path to the standalone hook script shipped in scripts/
+ * alongside dist/ (package.json "files": ["dist","scripts", ...]).
+ * __dirname is dist/ at runtime in both the repo checkout (npm run build)
+ * and the installed package, so '..','scripts' resolves the same way in
+ * both.
+ */
+export declare function precompactHookScriptPath(): string;
+/**
+ * The settings.json `hooks` fragment for a single PreCompact command hook.
+ * Pure/deterministic — the thing this task's Step 5 asks to unit-test as
+ * "the hook-config builder (settings JSON shape)".
+ */
+export declare function buildPrecompactHookSettings(scriptPath: string): {
+    hooks: {
+        PreCompact: unknown[];
+    };
+};
+/**
+ * Writes <cwd>/.claude/settings.json with the PreCompact hook merged in.
+ * Best-effort and idempotent: a fresh ephemeral session cwd has no prior
+ * settings.json, but this merges (never clobbers) in case a future caller
+ * pre-seeds project settings for some other reason. A write failure is
+ * logged and swallowed — the caller's spawn proceeds hook-less, the exact
+ * same outcome as an entity this function is never called for.
+ */
+export declare function writeSessionPrecompactHook(cwd: string): void;

package/dist/precompact-hook.js

@@ -0,0 +1,136 @@
+"use strict";
+// +Ai Memory Phase 4, T7 — PreCompact capture hook (claude agent only, Q7).
+//
+// Claude Code's PreCompact hook fires just before a session's context is
+// summarized away by compaction — the daemon's one chance to capture the
+// in-flight turn tail (surface:'precompact') that would otherwise be lost
+// before the normal completed-turn capture path (notifyCaptureIfEnabled,
+// session-runner.ts) ever sees it. Wired ONLY for memory_v2-flagged
+// entities, ONLY into the per-request ephemeral working directory's
+// PROJECT-scope settings.json.
+//
+// Why project-scope, not the simpler-looking `~/.claude/settings.json`:
+// unlike the Grok integration's per-session sandboxed HOME (GROK_HOME),
+// claude-spawn.ts spawns claude inheriting the daemon's REAL host HOME
+// (os.homedir(), see paths.ts CLAUDE_HOME / claude-config.ts) — there is
+// no per-session HOME isolation for claude on this runtime. A hook written
+// to the user-scope settings.json would therefore apply to EVERY claude
+// spawn on this host, flagged entity or not, violating the "byte-identical
+// spawn env for non-flagged entities" requirement. claude-spawn.ts already
+// passes `--setting-sources user,project`, so a `<cwd>/.claude/
+// settings.json` file IS read for this session and this session alone
+// (each request gets a fresh ephemeral cwd, session-runner.ts's
+// `path.join(RUNTIME_HOME, 'sessions', requestId)`) — that is the
+// injectable per-session seam this task's recon found. Non-flagged
+// entities and every non-claude agent never call writeSessionPrecompactHook
+// at all, so their spawn env is untouched, not merely "harmless" — the
+// settings.json literally does not exist for them.
+//
+// The gate itself (which entities are memory_v2-flagged) stays server-side
+// per Q7 and the house pattern established for capture/pack: the daemon
+// learns "flagged" only as a side effect of the SAME entity-memory-pack
+// round trip session-runner.ts already makes every turn (memory-pack.ts's
+// onFlagged callback), never by asking a second question of its own.
+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.precompactHookScriptPath = precompactHookScriptPath;
+exports.buildPrecompactHookSettings = buildPrecompactHookSettings;
+exports.writeSessionPrecompactHook = writeSessionPrecompactHook;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const win_1 = require("./win");
+/**
+ * Absolute path to the standalone hook script shipped in scripts/
+ * alongside dist/ (package.json "files": ["dist","scripts", ...]).
+ * __dirname is dist/ at runtime in both the repo checkout (npm run build)
+ * and the installed package, so '..','scripts' resolves the same way in
+ * both.
+ */
+function precompactHookScriptPath() {
+    return path.join(__dirname, '..', 'scripts', 'precompact-capture.js');
+}
+/**
+ * The settings.json `hooks` fragment for a single PreCompact command hook.
+ * Pure/deterministic — the thing this task's Step 5 asks to unit-test as
+ * "the hook-config builder (settings JSON shape)".
+ */
+function buildPrecompactHookSettings(scriptPath) {
+    return {
+        hooks: {
+            PreCompact: [
+                {
+                    matcher: '',
+                    hooks: [
+                        { type: 'command', command: `node ${JSON.stringify(scriptPath)}` },
+                    ],
+                },
+            ],
+        },
+    };
+}
+/**
+ * Writes <cwd>/.claude/settings.json with the PreCompact hook merged in.
+ * Best-effort and idempotent: a fresh ephemeral session cwd has no prior
+ * settings.json, but this merges (never clobbers) in case a future caller
+ * pre-seeds project settings for some other reason. A write failure is
+ * logged and swallowed — the caller's spawn proceeds hook-less, the exact
+ * same outcome as an entity this function is never called for.
+ */
+function writeSessionPrecompactHook(cwd) {
+    try {
+        const dir = path.join(cwd, '.claude');
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const target = path.join(dir, 'settings.json');
+        let current = {};
+        if (fs.existsSync(target)) {
+            try {
+                current = JSON.parse(fs.readFileSync(target, 'utf-8'));
+            }
+            catch {
+                current = {};
+            }
+        }
+        const hookSettings = buildPrecompactHookSettings(precompactHookScriptPath());
+        const currentHooks = (current.hooks && typeof current.hooks === 'object' ? current.hooks : {});
+        const next = { ...current, hooks: { ...currentHooks, ...hookSettings.hooks } };
+        const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+        fs.writeFileSync(tmp, JSON.stringify(next, null, 2), { mode: 0o600 });
+        (0, win_1.safeRenameSync)(tmp, target);
+    }
+    catch (err) {
+        console.error(`[precompact-hook] failed to write session settings for ${cwd}: ${err.message}`);
+    }
+}

package/dist/projects.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strip embedded credentials from URLs before logging / persisting.
+ * Git error output regularly embeds the full remote URL with PAT,
+ * e.g. `fatal: unable to access 'https://x-access-token:ghp_xxxx@github.com/…'`
+ * — and `entity_projects.status_message` is shown verbatim in the UI.
+ */
+export declare function redactSecrets(text: string): string;
+interface ProjectRow {
+    id: string;
+    runtime_id: string;
+    name: string;
+    working_directory: string;
+    git_remote: string | null;
+    git_branch: string | null;
+    enabled_mcps: string[];
+    enabled_skills: string[];
+    enabled_packages: string[];
+    status: 'pending' | 'cloning' | 'installing' | 'ready' | 'failed';
+    status_message: string | null;
+    git_credential_id: string | null;
+}
+export declare function start(): void;
+export declare function stop(): void;
+export declare function fetchProject(projectId: string): Promise<ProjectRow | null>;
+export {};

package/dist/projects.js

@@ -0,0 +1,255 @@
+"use strict";
+// Project lifecycle on the daemon side.
+//
+// Polls for pending projects, clones git remotes into a stable working
+// directory under ~/.ainode/projects/<id>/, and reports
+// status back to Supabase. Session-runner reads project.working_directory
+// at spawn time so requests with project_id pick up the right cwd.
+//
+// Phase 3: just git clone. MCP / skill / package install lands in Phase 4.
+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.redactSecrets = redactSecrets;
+exports.start = start;
+exports.stop = stop;
+exports.fetchProject = fetchProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const supabase_client_1 = require("./supabase-client");
+const store_1 = require("./store");
+const paths_1 = require("./paths");
+// Project pickup polls every 5s (was 3s). Projects are not latency-
+// sensitive: a clone takes seconds anyway, so 2 extra seconds before
+// the daemon notices a new project is fine. Slower interval = less
+// pooler pressure on Supabase.
+const PROJECT_POLL_INTERVAL_MS = 5_000;
+/**
+ * Strip embedded credentials from URLs before logging / persisting.
+ * Git error output regularly embeds the full remote URL with PAT,
+ * e.g. `fatal: unable to access 'https://x-access-token:ghp_xxxx@github.com/…'`
+ * — and `entity_projects.status_message` is shown verbatim in the UI.
+ */
+function redactSecrets(text) {
+    return text
+        // userinfo URL form
+        .replace(/https?:\/\/[^\s/@:]+(?::[^@\s/]+)?@/g, (m) => m.startsWith('https') ? 'https://<redacted>@' : 'http://<redacted>@')
+        // bare GitHub PATs leaking in messages
+        .replace(/\bghp_[A-Za-z0-9]{20,}/g, '<redacted-pat>')
+        .replace(/\bgho_[A-Za-z0-9]{20,}/g, '<redacted-oauth>')
+        .replace(/\bghu_[A-Za-z0-9]{20,}/g, '<redacted-user-oauth>')
+        .replace(/\bghs_[A-Za-z0-9]{20,}/g, '<redacted-server-oauth>');
+}
+let timer = null;
+let stopped = false;
+let inflight = false;
+function token() {
+    return (0, store_1.readPairing)()?.daemonToken ?? null;
+}
+async function setStatus(id, fields) {
+    const t = token();
+    if (!t)
+        return;
+    try {
+        await (0, supabase_client_1.rpc)('runtime_project_status_update', {
+            p_token: t,
+            p_project_id: id,
+            p_status: fields.status ?? null,
+            p_status_message: fields.status_message ?? null,
+            p_working_directory: fields.working_directory ?? null,
+        });
+    }
+    catch (err) {
+        console.error('[projects] status update failed:', err.message);
+    }
+}
+function sanitiseName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'project';
+}
+function projectDir(p) {
+    if (p.working_directory && p.working_directory.trim())
+        return p.working_directory;
+    return path.join(paths_1.RUNTIME_HOME, 'projects', `${sanitiseName(p.name)}-${p.id.slice(0, 8)}`);
+}
+function run(cmd, args, opts = {}) {
+    return new Promise(resolve => {
+        (0, child_process_1.execFile)(cmd, args, { cwd: opts.cwd, timeout: opts.timeoutMs ?? 5 * 60_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+            resolve({ ok: !err, stdout: stdout.toString(), stderr: stderr.toString() });
+        });
+    });
+}
+async function cloneIfNeeded(p, dir) {
+    if (fs.existsSync(path.join(dir, '.git'))) {
+        return { ok: true, message: 'git repo already present' };
+    }
+    if (!p.git_remote) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        return { ok: true, message: 'no git remote; dir created' };
+    }
+    fs.mkdirSync(path.dirname(dir), { recursive: true, mode: 0o700 });
+    // If a github_token credential is linked, fetch the PAT and inject it
+    // into the clone URL. The token only lives in argv for the clone
+    // process — we strip it from .git/config immediately after.
+    let remote = p.git_remote;
+    if (p.git_credential_id) {
+        try {
+            const pairing = (0, store_1.readPairing)();
+            if (pairing) {
+                const gitToken = await (0, supabase_client_1.rpc)('runtime_get_git_token', {
+                    p_token: pairing.daemonToken,
+                    p_project_id: p.id,
+                });
+                if (gitToken) {
+                    // https://x-access-token:<PAT>@github.com/... works for both
+                    // classic and fine-grained tokens.
+                    const u = new URL(remote);
+                    if (u.hostname === 'github.com') {
+                        u.username = 'x-access-token';
+                        u.password = gitToken;
+                        remote = u.toString();
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[projects] failed to resolve git token, will try anonymous clone:', err.message);
+        }
+    }
+    // Shallow + single-branch by default. Big repos otherwise time out.
+    // core.longpaths lifts Windows' 260-char MAX_PATH; no-op elsewhere.
+    const args = process.platform === 'win32' ? ['-c', 'core.longpaths=true'] : [];
+    args.push('clone', '--depth', '1', '--single-branch');
+    if (p.git_branch)
+        args.push('--branch', p.git_branch);
+    args.push(remote, dir);
+    const r = await run('git', args, { timeoutMs: 30 * 60_000 });
+    if (!r.ok) {
+        // Git error output often embeds the full remote URL with credentials
+        // (e.g. "fatal: unable to access 'https://x-access-token:ghp_xxx@…'").
+        // Scrub before persisting — we'd otherwise leak the PAT into
+        // entity_projects.status_message and show it in the desktop UI.
+        return { ok: false, message: redactSecrets((r.stderr || r.stdout || 'git clone failed').trim()).slice(0, 1024) };
+    }
+    // Strip the token from the saved remote so it doesn't sit on disk.
+    if (remote !== p.git_remote) {
+        try {
+            await run('git', ['-C', dir, 'remote', 'set-url', 'origin', p.git_remote], { timeoutMs: 10_000 });
+        }
+        catch { /* non-fatal */ }
+    }
+    return { ok: true, message: 'cloned' };
+}
+async function processProject(p) {
+    const dir = projectDir(p);
+    const result = await cloneIfNeeded(p, dir);
+    if (!result.ok) {
+        await setStatus(p.id, {
+            status: 'failed',
+            status_message: result.message ?? 'clone failed',
+            working_directory: dir,
+        });
+        return;
+    }
+    // Phase 4 will run MCP / skill / package install here.
+    await setStatus(p.id, {
+        status: 'ready',
+        status_message: result.message ?? null,
+        working_directory: dir,
+    });
+}
+async function tick() {
+    if (stopped || inflight)
+        return;
+    // Share the daemon-wide circuit breaker — when Supabase is in distress
+    // we don't want this poller piling on either.
+    if ((0, supabase_client_1.rpcShouldSkip)())
+        return;
+    const t = token();
+    if (!t)
+        return;
+    let row = null;
+    try {
+        const r = await (0, supabase_client_1.rpc)('runtime_pick_pending_project', { p_token: t });
+        row = r && r.id ? r : null;
+    }
+    catch (err) {
+        if (!(err instanceof supabase_client_1.RpcError && err.status === 401)) {
+            console.error('[projects] pick failed:', err.message);
+        }
+        return;
+    }
+    if (!row)
+        return;
+    inflight = true;
+    try {
+        await processProject(row);
+    }
+    catch (err) {
+        await setStatus(row.id, { status: 'failed', status_message: err.message ?? 'project setup failed' });
+    }
+    finally {
+        inflight = false;
+    }
+}
+function start() {
+    if (timer || stopped)
+        return;
+    void tick();
+    timer = setInterval(() => { void tick(); }, PROJECT_POLL_INTERVAL_MS);
+}
+function stop() {
+    stopped = true;
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+// Daemon-side helper used by session-runner to resolve a project's cwd
+// at request time (without depending on the project pump having run yet).
+async function fetchProject(projectId) {
+    const t = token();
+    if (!t)
+        return null;
+    try {
+        const r = await (0, supabase_client_1.rpc)('runtime_get_project', { p_token: t, p_project_id: projectId });
+        return r && r.id ? r : null;
+    }
+    catch (err) {
+        if (err instanceof supabase_client_1.RpcError && err.status === 401)
+            return null;
+        console.error('[projects] fetchProject failed:', err.message);
+        return null;
+    }
+}

package/dist/prompt-keystrokes.d.ts

@@ -0,0 +1,3 @@
+export declare const TUI_NEWLINE = "\u001B\r";
+export declare function stripTerminalControls(text: string): string;
+export declare function encodeTuiPromptKeystrokes(prompt: string): string;