@addai/node 0.4.0

package/dist/capabilities.js

@@ -0,0 +1,406 @@
+"use strict";
+// Best-effort probe of the binaries the runtime knows about. The result
+// is JSON-shaped and posted up via runtime_heartbeat so the vault /
+// studio UI can show live model lists, login status, and active
+// account. Failures are silent — a missing binary or unauth'd CLI just
+// won't show as an agent option in the pickers.
+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.codexHome = codexHome;
+exports.codexAuthFromStore = codexAuthFromStore;
+exports.probeCapabilities = probeCapabilities;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const claude_binary_1 = require("./claude-binary");
+const kimi_binary_1 = require("./kimi-binary");
+const gemini_binary_1 = require("./gemini-binary");
+const grok_binary_1 = require("./grok-binary");
+const codex_binary_1 = require("./codex-binary");
+const win_1 = require("./win");
+const harness_registry_1 = require("./harness-registry");
+function readDaemonVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const pkg = require('../package.json');
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function runCmd(cmd, args, timeoutMs = 5000) {
+    return new Promise(resolve => {
+        // On win32 the discovered binary may be an npm .cmd shim, which Node
+        // refuses to execFile without a shell (EINVAL, thrown SYNCHRONOUSLY).
+        // Resolve the shim to its node script first, and catch the sync throw —
+        // a single failing probe must not take down the whole heartbeat.
+        try {
+            const inv = (0, win_1.resolveCliInvocation)(cmd, args);
+            (0, child_process_1.execFile)(inv.file, inv.args, { timeout: timeoutMs, maxBuffer: 256 * 1024 }, (err, stdout, stderr) => {
+                resolve({ ok: !err, stdout: (stdout ?? '').trim(), stderr: (stderr ?? '').trim() });
+            });
+        }
+        catch (err) {
+            resolve({ ok: false, stdout: '', stderr: err.message ?? String(err) });
+        }
+    });
+}
+// Curated model lists baked into the daemon. The CLIs don't expose a
+// stable "list models" command; the daemon reports whatever the
+// installed daemon version knows about, so bumping the daemon refreshes
+// the UI's dropdown.
+const CLAUDE_MODELS = [
+    'claude-opus-4-7',
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5',
+    'claude-opus-4-1',
+    'claude-sonnet-4-5',
+];
+const CODEX_MODELS = [
+    'gpt-5',
+    'gpt-5-mini',
+    'o4',
+    'o4-mini',
+];
+const KIMI_MODELS = [
+    'kimi-k2-instruct',
+    'kimi-k2-base',
+    'moonshot-v1-128k',
+    'moonshot-v1-32k',
+];
+const GEMINI_MODELS = [
+    'gemini-2.5-flash',
+    'gemini-2.5-pro',
+    'gemini-2.0-flash',
+    'gemini-2.0-pro',
+];
+const GROK_MODELS = [
+    'grok-4.5',
+    'grok-composer-2.5-fast',
+];
+async function probeClaude() {
+    const bin = (0, claude_binary_1.findClaudeBinary)();
+    if (!bin)
+        return { available: false, authed: false };
+    const ver = await runCmd(bin, ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    const version = ver.stdout.replace(/^claude\s+/i, '').trim() || undefined;
+    // `claude auth status` prints JSON describing the logged-in account.
+    // Example: {"loggedIn":true,"authMethod":"claude.ai","email":"a@b.c","subscriptionType":"max"}
+    const auth = await runCmd(bin, ['auth', 'status']);
+    let authShape = { authed: false };
+    if (auth.ok && auth.stdout) {
+        try {
+            const j = JSON.parse(auth.stdout);
+            authShape = {
+                authed: j.loggedIn === true,
+                account: typeof j.email === 'string' ? j.email : undefined,
+                accountKind: typeof j.authMethod === 'string' ? j.authMethod : undefined,
+                plan: typeof j.subscriptionType === 'string' ? j.subscriptionType : undefined,
+            };
+        }
+        catch { /* fall through unauthed */ }
+    }
+    return { available: true, version, models: CLAUDE_MODELS, ...authShape };
+}
+/** Codex's credential store: $CODEX_HOME (or ~/.codex) + /auth.json. */
+function codexHome() {
+    return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+}
+/**
+ * Read auth state straight out of codex's credential file.
+ *
+ * `codex login status` cannot be trusted as the sole signal: on some
+ * installs it prints its "Logged in using ChatGPT" line only when stdio is
+ * a TTY and stays completely silent (exit 0, both streams empty) when the
+ * daemon runs it with pipes — so a logged-in node reported itself logged
+ * out forever, and remote logins "failed" verification after succeeding
+ * (live incident, Lennys-Mac-mini 2026-07-29). The file is written by the
+ * login flow itself, which makes it the fact rather than the commentary.
+ *
+ * Shape (values redacted):
+ *   { auth_mode: 'chatgpt', OPENAI_API_KEY: null,
+ *     tokens: { id_token, access_token, refresh_token, account_id },
+ *     last_refresh }
+ *
+ * Never throws: an unreadable or malformed store simply isn't proof of a
+ * login. Same approach probeKimi already takes for its OAuth store.
+ */
+function codexAuthFromStore(home) {
+    if (!home)
+        return { authed: false };
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(path.join(home, 'auth.json'), 'utf8'));
+    }
+    catch {
+        return { authed: false };
+    }
+    const tokens = (parsed.tokens ?? null);
+    const nonEmpty = (v) => typeof v === 'string' && v.trim().length > 0;
+    if (tokens && (nonEmpty(tokens.access_token) || nonEmpty(tokens.refresh_token))) {
+        return { authed: true, accountKind: 'ChatGPT' };
+    }
+    if (nonEmpty(parsed.OPENAI_API_KEY))
+        return { authed: true, accountKind: 'api-key' };
+    return { authed: false };
+}
+async function probeCodex() {
+    // Resolve the real binary path — bare 'codex' relies on PATH search,
+    // which misses npm-global dirs under launchd and never finds .cmd shims
+    // on Windows.
+    const bin = (0, codex_binary_1.findCodexBinary)() ?? 'codex';
+    const ver = await runCmd(bin, ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    // `codex login status` is text-only AND writes to stderr (not stdout)
+    // when run headlessly. Logged-in output starts with "Logged in" and
+    // usually mentions how (e.g. "Logged in using ChatGPT"). When it speaks,
+    // it carries the nicest detail — how the account was authenticated — so
+    // prefer it, but never let its silence outvote the credential store.
+    const login = await runCmd(bin, ['login', 'status']);
+    const loginText = `${login.stdout}\n${login.stderr}`;
+    let authShape = { authed: false };
+    if (login.ok && /^\s*logged in/im.test(loginText)) {
+        const via = /using\s+(.+?)(?:[.\s]|$)/i.exec(loginText)?.[1]?.trim();
+        authShape = { authed: true, accountKind: via || 'codex' };
+    }
+    else {
+        authShape = codexAuthFromStore(codexHome());
+    }
+    return { available: true, version: ver.stdout, models: CODEX_MODELS, ...authShape };
+}
+async function probeKimi() {
+    const bin = (0, kimi_binary_1.findKimiBinary)();
+    if (!bin)
+        return { available: false, authed: false };
+    const ver = await runCmd(bin, ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    const version = ver.stdout.replace(/^kimi\s+/i, '').trim() || undefined;
+    // Auth signals, in order: env API key; kimi-code's OAuth credential
+    // store (~/.kimi-code/credentials/*.json with a refresh/access token —
+    // written by `kimi login`'s device-code flow); legacy ~/.kimi/config.
+    const envKey = process.env.MOONSHOT_API_KEY || process.env.KIMI_API_KEY;
+    let hasOauth = false;
+    try {
+        const credDir = path.join(os.homedir(), '.kimi-code', 'credentials');
+        for (const f of fs.readdirSync(credDir)) {
+            if (!f.endsWith('.json'))
+                continue;
+            const cred = JSON.parse(fs.readFileSync(path.join(credDir, f), 'utf-8'));
+            // Require a NON-EMPTY token, not just a present field — a logged-out
+            // CLI can leave the cred file with empty-string tokens.
+            const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+            if (nonEmpty(cred.refresh_token) || nonEmpty(cred.access_token)) {
+                hasOauth = true;
+                break;
+            }
+        }
+    }
+    catch { /* no cred dir = not oauth-authed */ }
+    // Legacy ~/.kimi/config: the actual bug is an EMPTY/whitespace-only file
+    // (logged-out or half-installed CLI) showing the agent green and routing
+    // dispatch to a dead provider. Reject only that. Deliberately NOT
+    // keyword-gated: a working legacy login may store its token under any key
+    // (a bare `sk-…`, `"key":`, `"auth":`), and a keyword allowlist would flip
+    // a VALID config to unauthed and drop kimi off the ladder — a false-negative
+    // worse than the bug. A non-empty, non-empty-container file is trusted.
+    let hasConfig = false;
+    try {
+        const raw = fs.readFileSync(path.join(os.homedir(), '.kimi', 'config'), 'utf-8').trim();
+        hasConfig = raw.length > 0 && raw !== '{}' && raw !== '[]';
+    }
+    catch { /* missing / unreadable = not config-authed */ }
+    const authed = !!envKey || hasOauth || hasConfig;
+    return {
+        available: true, version, models: KIMI_MODELS,
+        authed,
+        accountKind: authed ? (envKey ? 'api-key' : hasOauth ? 'kimi-code' : 'config') : undefined,
+    };
+}
+async function probeGemini() {
+    const bin = (0, gemini_binary_1.findGeminiBinary)();
+    if (!bin)
+        return { available: false, authed: false };
+    const ver = await runCmd(bin, ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    const version = ver.stdout.replace(/^gemini\s+/i, '').trim() || undefined;
+    // Gemini CLI stores creds at ~/.gemini/oauth_creds.json and the
+    // active account email at ~/.gemini/google_accounts.json (`.active`).
+    const home = os.homedir();
+    const credsPath = path.join(home, '.gemini', 'oauth_creds.json');
+    const acctPath = path.join(home, '.gemini', 'google_accounts.json');
+    let authed = false;
+    let account;
+    let accountKind;
+    try {
+        if (fs.existsSync(credsPath)) {
+            const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
+            const accessTok = typeof creds.access_token === 'string' ? creds.access_token : '';
+            const refreshTok = typeof creds.refresh_token === 'string' ? creds.refresh_token : '';
+            // Non-empty access token is the floor. Google oauth_creds carry an
+            // expiry_date (ms epoch); an expired access token is still usable IFF a
+            // refresh_token exists (the CLI refreshes transparently). Only downgrade
+            // to unauthed when expired AND there's nothing to refresh with. Absent /
+            // non-numeric expiry is treated as valid to avoid false-negatives on a
+            // working login.
+            const expiryMs = typeof creds.expiry_date === 'number' ? creds.expiry_date : undefined;
+            const expired = expiryMs !== undefined && expiryMs <= Date.now();
+            authed = accessTok.length > 0 && (!expired || refreshTok.length > 0);
+            if (authed)
+                accountKind = 'google';
+        }
+        if (fs.existsSync(acctPath)) {
+            const accts = JSON.parse(fs.readFileSync(acctPath, 'utf-8'));
+            if (typeof accts.active === 'string')
+                account = accts.active;
+        }
+        // API-key / Vertex logins live in ~/.gemini/.env (the CLI reads it).
+        if (!authed) {
+            const envPath = path.join(home, '.gemini', '.env');
+            if (fs.existsSync(envPath)) {
+                const env = fs.readFileSync(envPath, 'utf-8');
+                const has = (v) => new RegExp(`^${v}=.+`, 'm').test(env);
+                if (has('GOOGLE_API_KEY') && has('GOOGLE_GENAI_USE_VERTEXAI')) {
+                    authed = true;
+                    accountKind = 'vertex';
+                }
+                else if (has('GEMINI_API_KEY')) {
+                    authed = true;
+                    accountKind = 'api-key';
+                }
+            }
+        }
+    }
+    catch { /* unreadable creds = unauthed */ }
+    return {
+        available: true, version, models: GEMINI_MODELS,
+        authed, account, accountKind,
+    };
+}
+async function probeGrok() {
+    const bin = (0, grok_binary_1.findGrokBinary)();
+    if (!bin)
+        return { available: false, authed: false };
+    const ver = await runCmd(bin, ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    // "grok 0.2.101 (5bc4...) [stable]" → keep the semver.
+    const version = /(\d+\.\d+\.\d+)/.exec(ver.stdout)?.[1] ?? ver.stdout;
+    // The account lives in ~/.grok/auth.json, keyed by issuer::user-id. Each
+    // entry carries the OAuth token (`key`), a `refresh_token`, and the
+    // signed-in `email`. Presence of a refresh_token = the CLI can keep the
+    // session alive, so we treat that as authed (mirrors gemini's probe).
+    const authPath = path.join(os.homedir(), '.grok', 'auth.json');
+    let authShape = { authed: false };
+    try {
+        if (fs.existsSync(authPath)) {
+            const obj = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+            // Require a NON-EMPTY token. A logged-out CLI can leave an entry whose
+            // refresh_token/key are empty strings, which the old typeof-string check
+            // accepted → agent shown green and the provider-ladder routed to a dead
+            // provider. refresh_token means the session can be kept alive; a bare
+            // key also counts.
+            const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+            const entry = Object.values(obj).find(e => e && (nonEmpty(e.refresh_token) || nonEmpty(e.key)));
+            if (entry) {
+                authShape = {
+                    authed: true,
+                    account: typeof entry.email === 'string' ? entry.email : undefined,
+                    accountKind: 'grok.com',
+                };
+            }
+        }
+    }
+    catch { /* unreadable creds = unauthed */ }
+    return { available: true, version, models: GROK_MODELS, ...authShape };
+}
+async function probeGit() {
+    const ver = await runCmd('git', ['--version']);
+    if (!ver.ok || !ver.stdout)
+        return { available: false, authed: false };
+    // Git creds live per-repo via helpers — there's no global "logged in"
+    // notion. Mark authed=true so the UI doesn't grey out a working git.
+    return {
+        available: true,
+        version: ver.stdout.replace(/^git version\s+/i, '').trim(),
+        authed: true,
+    };
+}
+async function probeCapabilities() {
+    // Binary lookups cache misses; a CLI installed mid-daemon-life (by the
+    // command runner or by hand) must show up on the next probe, not after
+    // a daemon restart.
+    (0, harness_registry_1.resetBinaryCaches)();
+    // Each probe is individually shielded: one throwing probe (e.g. a broken
+    // CLI install) must not reject the whole Promise.all and kill every
+    // heartbeat — that would report the runtime permanently offline.
+    const shield = (p, fallback) => p.catch(() => fallback);
+    const unavailable = { available: false, authed: false };
+    const [claude, codex, kimi, gemini, grok, git] = await Promise.all([
+        shield(probeClaude(), unavailable),
+        shield(probeCodex(), unavailable),
+        shield(probeKimi(), unavailable),
+        shield(probeGemini(), unavailable),
+        shield(probeGrok(), unavailable),
+        shield(probeGit(), unavailable),
+    ]);
+    // Decorate each harness with its registry facts (efforts, installability,
+    // login strategy) so Studio and the TUI render from one source of truth.
+    const deco = (id, probe) => ({
+        ...probe,
+        efforts: harness_registry_1.HARNESSES[id].efforts,
+        installable: (0, harness_registry_1.isInstallable)(id),
+        login_strategy: harness_registry_1.HARNESSES[id].login.strategy,
+        login_methods: [
+            harness_registry_1.HARNESSES[id].login.strategy,
+            ...(harness_registry_1.HARNESSES[id].extraLogins ?? []).map(m => m.method),
+        ],
+    });
+    return {
+        daemon_version: readDaemonVersion(),
+        claude: deco('claude', claude),
+        codex: deco('codex', codex),
+        kimi: deco('kimi', kimi),
+        gemini: deco('gemini', gemini),
+        grok: deco('grok', grok),
+        git,
+    };
+}

package/dist/claude-binary.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Find the Claude Code CLI binary. Mirrors the resolution strategy
+ * the desktop app uses, so the runtime spawns the same Claude the
+ * user already has installed.
+ *
+ * Returns `null` when claude isn't installed — callers MUST NOT spawn a
+ * bare `'claude'` literal, which throws an async ENOENT with no 'error'
+ * listener attached in time and takes the whole daemon down (observed on
+ * a Windows box with only grok installed: a self-improve/capture distil
+ * request tried to run the Haiku summarizer via claude → crash). Mirrors
+ * findCodexBinary/findGrokBinary, which already return `null`.
+ */
+export declare function findClaudeBinary(): string | null;
+/** Encode a working directory the same way Claude does for its
+ *  per-project transcript folder (`~/.claude/projects/<encoded>/`). */
+export declare function encodeProjectPath(dirPath: string): string;

package/dist/claude-binary.js

@@ -0,0 +1,145 @@
+"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.findClaudeBinary = findClaudeBinary;
+exports.encodeProjectPath = encodeProjectPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const IS_WINDOWS = process.platform === 'win32';
+/**
+ * Find the Claude Code CLI binary. Mirrors the resolution strategy
+ * the desktop app uses, so the runtime spawns the same Claude the
+ * user already has installed.
+ *
+ * Returns `null` when claude isn't installed — callers MUST NOT spawn a
+ * bare `'claude'` literal, which throws an async ENOENT with no 'error'
+ * listener attached in time and takes the whole daemon down (observed on
+ * a Windows box with only grok installed: a self-improve/capture distil
+ * request tried to run the Haiku summarizer via claude → crash). Mirrors
+ * findCodexBinary/findGrokBinary, which already return `null`.
+ */
+function findClaudeBinary() {
+    if (IS_WINDOWS) {
+        try {
+            // `where` lists every match; npm installs three shims side by side
+            // (extensionless bash script, .cmd, .ps1). Prefer a native .exe
+            // (installer builds), then .cmd — never the extensionless one,
+            // which CreateProcess can't run.
+            const lines = (0, child_process_1.execSync)('where claude', { encoding: 'utf-8', timeout: 5000 })
+                .split(/\r?\n/)
+                .map(l => l.trim())
+                .filter(Boolean);
+            const result = lines.find(l => /\.exe$/i.test(l)) ??
+                lines.find(l => /\.cmd$/i.test(l)) ??
+                lines.find(l => /\.bat$/i.test(l));
+            if (result && fs.existsSync(result))
+                return result;
+        }
+        catch { }
+        const appData = process.env.APPDATA || '';
+        const localAppData = process.env.LOCALAPPDATA || '';
+        const userProfile = process.env.USERPROFILE || '';
+        const candidates = [
+            path.join(userProfile, '.local', 'bin', 'claude.exe'), // native installer default
+            path.join(appData, 'npm', 'claude.cmd'),
+            path.join(localAppData, 'npm', 'claude.cmd'),
+            path.join(userProfile, '.npm-global', 'claude.cmd'),
+            path.join(userProfile, 'AppData', 'Roaming', 'npm', 'claude.cmd'),
+        ];
+        for (const p of candidates) {
+            try {
+                if (fs.existsSync(p))
+                    return p;
+            }
+            catch { }
+        }
+    }
+    else {
+        const shell = process.env.SHELL || '/bin/zsh';
+        // Resolve through the user's shell. We try an *interactive* login shell
+        // (`-i -l`) so that a `claude` alias/function defined in the interactive
+        // section of ~/.zshrc is visible — a plain `-l -c` shell is
+        // non-interactive and never sources it, which is how the runtime ended up
+        // spawning the bare `claude` literal (ENOENT) on machines where claude is
+        // only reachable via an alias. `command -v` follows aliases/functions to
+        // their target path; fall back to `which` for older setups.
+        const probes = [
+            `${shell} -i -l -c "command -v claude" 2>/dev/null`,
+            `${shell} -l -c "command -v claude" 2>/dev/null`,
+            `${shell} -l -c "which claude"`,
+        ];
+        for (const cmd of probes) {
+            try {
+                const result = (0, child_process_1.execSync)(cmd, { encoding: 'utf-8', timeout: 5000 })
+                    .trim()
+                    .split('\n')
+                    .pop()
+                    .trim();
+                if (result && result.startsWith('/') && fs.existsSync(result))
+                    return result;
+            }
+            catch { }
+        }
+        const home = process.env.HOME || '';
+        const candidates = [
+            `${home}/.local/bin/claude`, // native installer default
+            `${home}/.claude/local/claude`, // local / migrate-installer install
+            '/usr/local/bin/claude',
+            '/opt/homebrew/bin/claude',
+            `${home}/.npm-global/bin/claude`,
+            `${home}/.bun/bin/claude`,
+            `${home}/.volta/bin/claude`,
+            `${home}/.nvm/current/bin/claude`,
+        ];
+        for (const p of candidates) {
+            try {
+                if (fs.existsSync(p))
+                    return p;
+            }
+            catch { }
+        }
+    }
+    // Not found by any probe. Return null (NOT a bare 'claude' literal): a
+    // bare spawn would ENOENT and crash the daemon. The old fallback never
+    // actually worked — if PATH could run 'claude', the probes above (same
+    // env) would have found it.
+    return null;
+}
+/** Encode a working directory the same way Claude does for its
+ *  per-project transcript folder (`~/.claude/projects/<encoded>/`). */
+function encodeProjectPath(dirPath) {
+    return dirPath.replace(/[^a-zA-Z0-9-]/g, '-');
+}

package/dist/claude-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Make sure ~/.claude/settings.json has skipDangerousModePermissionPrompt: true.
+ * Idempotent: if the key is already true, no write.
+ */
+export declare function ensureBypassPermissionsAccepted(): void;
+/**
+ * Add an entry to ~/.claude.json `.projects[cwd]` marking the cwd as
+ * trusted and onboarding-seen, so claude TUI doesn't block on either
+ * dialog when launched in this directory. Existing fields are preserved.
+ */
+export declare function preTrustProject(cwd: string): void;