@getrift/rift 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/src/providers/claude-cli-runner.js

@@ -0,0 +1,598 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+/**
+ * Claude Code (`claude`) CLI runner — the structured-JSON sibling of
+ * codex-cli-runner.ts. It shells out to `claude -p` (headless/print mode) and
+ * returns a schema-validated object, so a Claude Code user can back triage
+ * without installing or authenticating Codex.
+ *
+ * Why the `claude` CLI and not the Anthropic API: same trust model as Codex —
+ * the run inherits the operator's own logged-in subscription, so Rift holds NO
+ * API key and content egress is on the user's own account.
+ *
+ * Isolation choices (parallel to Codex's clean CODEX_HOME), all verified
+ * against the installed `claude --help` contract:
+ *  - `--safe-mode`: disables the user's CLAUDE.md, hooks, plugins, skills, MCP
+ *    servers, custom agents — so captured content is classified by a CLEAN
+ *    Claude, never one steered by the operator's personal config (which would
+ *    pollute the decision and waste tokens). Crucially, auth/model/built-in
+ *    tools still work normally, so it preserves the no-API-key subscription
+ *    trust model — unlike `--bare`, which forces ANTHROPIC_API_KEY.
+ *  - `--no-session-persistence`: the captured conversation is NOT written to
+ *    `~/.claude` session history. Without it, triage would duplicate every
+ *    captured conversation onto disk and risk re-capturing its own triage
+ *    sessions (a feedback loop). Only valid with `--print`, which we use.
+ *  - `--strict-mcp-config` with no `--mcp-config`: belt-and-suspenders with
+ *    safe-mode — load ZERO MCP servers, so a triage subprocess never connects
+ *    to (or sends content to) the user's MCP servers, nor pays their startup
+ *    cost. (Loading them was observed to stall the process for tens of seconds.)
+ *  - `--tools ""`: disable ALL built-in tools (the CLI's own "none" sentinel).
+ *    A classification needs none; this keeps the run deterministic and is
+ *    robust to tool renames — unlike a deny-list, which `claude` rejects when a
+ *    listed name is not a known tool.
+ *  - `--json-schema <inline JSON>`: the CLI validates structured output and
+ *    re-prompts internally on mismatch. The schema is passed INLINE (the CLI's
+ *    documented form; a file path is parsed as a literal schema and hangs).
+ *  - prompt piped via STDIN (not argv): handles large conversations without
+ *    hitting ARG_MAX, and avoids `claude -p`'s 3s "no stdin data" stall.
+ */
+let claudeVersionPromise = null;
+let testFallbackDirs;
+// Dirs searched in ADDITION to $PATH when resolving `claude`. The scheduled
+// daemon runs under launchd with a minimal PATH (`/usr/bin:/bin:/usr/sbin:/sbin`)
+// that contains neither Homebrew nor the official installer's `~/.local/bin`, so
+// without these fallbacks the daemon could find no `claude` (or only an older
+// Homebrew one). `~/.local/bin` is listed FIRST because the official installer
+// puts the current build there — ahead of a possibly-stale `/opt/homebrew/bin`.
+const CLAUDE_EXECUTABLE_FALLBACK_DIRS = [
+    path.join(os.homedir(), ".local", "bin"),
+    path.join(os.homedir(), ".claude", "local"),
+    path.join(os.homedir(), "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+];
+/**
+ * Default model for triage classification. A cheap, fast model is the right
+ * default for a background classifier that runs over every captured session;
+ * we pin it explicitly rather than inherit the user's interactive default
+ * (which could be Opus — slow and costly per session). An alias (not a dated
+ * id) so it tracks the current Haiku without code changes. Overridable per run.
+ */
+export const DEFAULT_CLAUDE_TRIAGE_MODEL = "haiku";
+/**
+ * Thrown ONLY when the runner's own timeout timer fires and kills the `claude`
+ * process. A signal termination we did NOT initiate is reported separately so
+ * it is never treated as a (retryable) timeout. Mirrors CodexCliTimeoutError.
+ */
+export class ClaudeCliTimeoutError extends Error {
+    timeoutMs;
+    signal;
+    constructor(timeoutMs, signal, detail = "") {
+        const signalPart = signal ? ` by ${signal}` : "";
+        super(`Claude CLI timed out after ${timeoutMs}ms (process terminated${signalPart})${detail}`);
+        this.name = "ClaudeCliTimeoutError";
+        this.timeoutMs = timeoutMs;
+        this.signal = signal;
+    }
+}
+/** One bounded retry on timeout/termination — see runClaudeCliJson. */
+const CLAUDE_TIMEOUT_RETRY_LIMIT = 1;
+const CLAUDE_TIMEOUT_RETRY_BACKOFF_MS = 500;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function runClaudeCliJson(options) {
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const cwd = options.cwd ?? process.cwd();
+    const model = options.model ?? DEFAULT_CLAUDE_TRIAGE_MODEL;
+    // Resolve — and capability-probe — a COMPATIBLE headless `claude` BEFORE any
+    // captured content is sent. This throws an actionable, leak-free error when no
+    // candidate can run our headless contract (too-old CLI missing `--safe-mode`,
+    // a PATH wrapper/PTY shim that can't pipe stdin, missing install). The probe
+    // uses only an innocuous fixed prompt, never conversation content.
+    const executable = await resolveCompatibleClaudeExecutable(cwd, model);
+    // One bounded retry, ONLY for timeout/termination — same rationale as the
+    // Codex runner: a SIGTERM'd headless call is overwhelmingly a transient cold
+    // start, and a single retry recovers it inside the same run. Auth/binary/
+    // malformed failures are NOT transient and are surfaced unretried.
+    let lastTimeout = null;
+    for (let attempt = 0; attempt <= CLAUDE_TIMEOUT_RETRY_LIMIT; attempt++) {
+        try {
+            const { stdout } = await runClaudeCommand(executable, [
+                "-p",
+                "--output-format",
+                "json",
+                // Schema is passed INLINE (the CLI's documented form); a file path is
+                // parsed as a literal schema string and stalls.
+                "--json-schema",
+                JSON.stringify(options.schema),
+                // Clean run: no personal config (CLAUDE.md/hooks/plugins/MCP), no
+                // session persistence of captured content. Auth/model still work.
+                "--safe-mode",
+                "--no-session-persistence",
+                "--strict-mcp-config",
+                "--model",
+                model,
+                // `--tools` is variadic — kept LAST so its single "" (the CLI's
+                // "disable all tools" sentinel) is the only value it consumes.
+                "--tools",
+                "",
+            ], { cwd, timeoutMs, stdinText: options.prompt });
+            const output = parseClaudeJsonEnvelope(stdout);
+            return { output, model, cliTag: await resolveClaudeCliTag(executable, cwd) };
+        }
+        catch (error) {
+            if (error instanceof ClaudeCliTimeoutError &&
+                attempt < CLAUDE_TIMEOUT_RETRY_LIMIT) {
+                lastTimeout = error;
+                await delay(CLAUDE_TIMEOUT_RETRY_BACKOFF_MS);
+                continue;
+            }
+            throw error;
+        }
+    }
+    // Unreachable: the loop either returns or throws on the final attempt.
+    throw lastTimeout ?? new Error("Claude CLI failed after retries");
+}
+/**
+ * Extract the schema-validated object from the `--output-format json` envelope.
+ *
+ * Defensive on purpose (I could not verify the exact envelope live from inside
+ * a nested Claude Code session): prefer `structured_output` (populated by
+ * `--json-schema`), and fall back to parsing the `result` text as JSON for any
+ * version that surfaces the object only there. Errors NEVER include model
+ * output or the prompt — only structural facts — so conversation content is
+ * never written to logs or error strings.
+ */
+export function parseClaudeJsonEnvelope(stdout) {
+    const raw = stdout.trim();
+    if (raw.length === 0) {
+        throw new Error("Claude CLI returned empty output");
+    }
+    let envelope;
+    try {
+        envelope = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error("Claude CLI returned a malformed JSON envelope", {
+            cause: error,
+        });
+    }
+    if (envelope.is_error === true) {
+        throw new Error(`Claude CLI reported an error (subtype: ${envelope.subtype ?? "unknown"})`);
+    }
+    if (envelope.subtype === "error_max_structured_output_retries") {
+        throw new Error("Claude CLI could not produce schema-valid output after retries");
+    }
+    if (envelope.structured_output != null) {
+        return envelope.structured_output;
+    }
+    // Fallback: object lives in the `result` text. Strip markdown fences and
+    // slice to the outermost object, mirroring the OpenAI provider's parser.
+    if (typeof envelope.result === "string") {
+        return parseJsonObjectFromText(envelope.result);
+    }
+    if (envelope.result != null && typeof envelope.result === "object") {
+        return envelope.result;
+    }
+    throw new Error("Claude CLI envelope had no structured_output or result");
+}
+function parseJsonObjectFromText(text) {
+    let cleaned = text
+        .replace(/^```json\s*/i, "")
+        .replace(/^```\s*/i, "")
+        .replace(/\s*```$/i, "")
+        .trim();
+    const start = cleaned.indexOf("{");
+    const end = cleaned.lastIndexOf("}");
+    if (start === -1 || end === -1) {
+        throw new Error("Claude CLI result contained no JSON object");
+    }
+    cleaned = cleaned.slice(start, end + 1);
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch (error) {
+        throw new Error("Claude CLI result was not valid JSON", { cause: error });
+    }
+}
+/**
+ * Headless flags `runClaudeCliJson` depends on. A candidate `claude` whose
+ * `--help` does not advertise EVERY one of these is rejected structurally — for
+ * free, before any conversation content is sent. `--safe-mode` is the load-
+ * bearing discriminator: it was added in a later Claude Code build, so an older
+ * CLI (which lacks it; `--bare` is NOT an acceptable substitute because it forces
+ * ANTHROPIC_API_KEY, breaking the subscription trust model) is filtered here.
+ */
+const REQUIRED_CLAUDE_FLAGS = [
+    "--safe-mode",
+    "--no-session-persistence",
+    "--output-format",
+    "--json-schema",
+    "--tools",
+    "--print",
+];
+/**
+ * Innocuous probe payload — NEVER conversation content. Used by the behavioral
+ * probe to confirm a candidate can actually complete a headless `-p` run with
+ * piped stdin (the only reliable way to reject a wrapper/PTY shim that forwards
+ * `--help` faithfully but cannot pipe stdin to a real `-p` invocation).
+ */
+const CLAUDE_PROBE_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["ok"],
+    properties: { ok: { type: "boolean" } },
+};
+const CLAUDE_PROBE_PROMPT = 'Return the JSON {"ok": true} and nothing else.';
+/**
+ * Cached SUCCESSFUL resolution — the path of a binary that passed both probe
+ * stages. We cache ONLY success, never failure: a probe can fail for transient
+ * reasons (not signed in yet, network blip, rate/usage limit, an overloaded
+ * model), and caching that would freeze the daemon at "Claude is broken" until
+ * restart, long after the user logged in or the network recovered. A successful
+ * binary, by contrast, stays valid for the process, so re-probing it per triage
+ * is pure waste. On failure we throw fresh each call and re-probe next time —
+ * structural rejects (e.g. missing `--safe-mode`) are cheap (no model call), and
+ * the only model-costing re-probe is a compatible-but-transiently-failing
+ * binary, which is exactly the case we WANT to retry.
+ */
+let resolvedCompatibleClaude;
+/** Test seam: replace the spawn-based per-candidate probe so selection +
+ *  rejection-aggregation logic can be unit-tested without spawning `claude`.
+ *  Returns null when the candidate is acceptable, else a leak-free reason. */
+let claudeProbeOverride;
+export function setClaudeProbeForTests(fn) {
+    claudeProbeOverride = fn;
+    resolvedCompatibleClaude = undefined;
+}
+/**
+ * Ordered, de-duplicated list of `claude` candidates to probe. An explicit
+ * `RIFT_CLAUDE_CLI_PATH` override is the SOLE candidate (an operator who names a
+ * binary expects that one used, or a clear error — never a silent fallback).
+ * Otherwise: every `$PATH` entry in order, then the install-location fallbacks.
+ * De-duped by realpath so the same binary reached via several PATH entries is
+ * probed once — but a wrapper and the real binary have different realpaths, so
+ * both are kept and the wrapper can be skipped in favour of the real one.
+ */
+export function listClaudeCandidatePaths(pathEnv = process.env["PATH"], override = process.env["RIFT_CLAUDE_CLI_PATH"], fallbackDirs = testFallbackDirs ??
+    CLAUDE_EXECUTABLE_FALLBACK_DIRS) {
+    if (override && override.trim()) {
+        return [override.trim()];
+    }
+    const dirs = [
+        ...(pathEnv ? pathEnv.split(path.delimiter) : []),
+        ...fallbackDirs,
+    ];
+    const seenReal = new Set();
+    const out = [];
+    for (const dir of dirs) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, "claude");
+        if (!fs.existsSync(candidate))
+            continue;
+        let real;
+        try {
+            real = fs.realpathSync(candidate);
+        }
+        catch {
+            real = candidate;
+        }
+        if (seenReal.has(real))
+            continue;
+        seenReal.add(real);
+        // Keep the stable entry, not the version-stamped realpath, so an upgrade
+        // that rotates the target is not pinned into a long-running daemon.
+        out.push(candidate);
+    }
+    return out;
+}
+/**
+ * Probe one candidate. Two stages, cheapest first:
+ *  1. Structural: `<bin> --help` must advertise every REQUIRED_CLAUDE_FLAG. No
+ *     model call; filters too-old CLIs and bounds a hang via timeout.
+ *  2. Behavioral: run a headless `-p` classification on the innocuous probe
+ *     prompt and require a parseable envelope. This is the only check that
+ *     rejects a wrapper which passes (1) but cannot pipe stdin to `-p` — and it
+ *     fails such a wrapper instantly, before any model call.
+ * Returns null when acceptable, else a leak-free rejection reason.
+ */
+async function probeClaudeCandidate(bin, cwd, model) {
+    if (claudeProbeOverride)
+        return claudeProbeOverride(bin, cwd, model);
+    let help;
+    try {
+        ({ stdout: help } = await runClaudeCommand(bin, ["--help"], {
+            cwd,
+            timeoutMs: 15_000,
+        }));
+    }
+    catch (error) {
+        if (error instanceof ClaudeCliTimeoutError) {
+            return "did not respond to `--help` within 15s (unresponsive CLI or wrapper)";
+        }
+        return "could not run `--help` (not executable, or not the Claude CLI)";
+    }
+    const missing = REQUIRED_CLAUDE_FLAGS.filter((flag) => !help.includes(flag));
+    if (missing.length > 0) {
+        return `Claude CLI too old/incompatible — missing required flag(s): ${missing.join(", ")} (need a build with --safe-mode)`;
+    }
+    try {
+        const { stdout } = await runClaudeCommand(bin, [
+            "-p",
+            "--output-format",
+            "json",
+            "--json-schema",
+            JSON.stringify(CLAUDE_PROBE_SCHEMA),
+            "--safe-mode",
+            "--no-session-persistence",
+            "--strict-mcp-config",
+            "--model",
+            model,
+            "--tools",
+            "",
+        ], { cwd, timeoutMs: 60_000, stdinText: CLAUDE_PROBE_PROMPT });
+        parseClaudeJsonEnvelope(stdout);
+        return null;
+    }
+    catch (error) {
+        if (error instanceof ClaudeCliTimeoutError) {
+            return "timed out running a headless probe classification";
+        }
+        // runClaudeCommand errors are already leak-free (canned classification), so
+        // including the message cannot leak content; it carries the auth/network
+        // bucket when recognized, making the aggregate error actionable.
+        const detail = error instanceof Error ? error.message : String(error);
+        // When the underlying error already classified into a specific bucket
+        // (auth/network/rate/contract/wrapper), surface that reason AS-IS. Appending
+        // the generic "wrapper/PTY shim … or auth" hedge would otherwise let the
+        // preflight classifier — which matches `wrapper` before `auth` — misbucket a
+        // real auth failure as a wrapper and tell a logged-out user to set
+        // RIFT_CLAUDE_CLI_PATH instead of signing in. Only a genuinely unrecognized
+        // failure (a bare exit code, no classified summary) keeps the wrapper/auth
+        // hedge, where a wrapper is the honest best guess.
+        const recognized = /authentication failed|not (logged|signed) in|\bunauthorized\b|\b401\b|flag\/contract error|--safe-mode|wrapper\/pty shim|could not run headless|rate limited|usage limit|network error/.test(detail.toLowerCase());
+        if (recognized) {
+            return `could not complete a headless \`-p\` classification (${detail})`;
+        }
+        return `could not complete a headless \`-p\` classification (${detail}) — likely a wrapper/PTY shim that cannot pipe stdin, or auth is not set up`;
+    }
+}
+function buildNoCompatibleClaudeMessage(rejections) {
+    const lines = rejections.map((r) => `  • ${r.path}: ${r.reason}`).join("\n");
+    return ("No compatible Claude Code CLI found for headless triage. Each candidate was " +
+        "checked BEFORE any conversation content was sent:\n" +
+        lines +
+        "\nFix: upgrade Claude Code to a build that supports `--safe-mode`, set " +
+        "RIFT_CLAUDE_CLI_PATH to a compatible `claude`, or use the Codex worker " +
+        "(capture.triage.provider = codex_cli; enrichment.metadata.provider = codex_cli).");
+}
+/**
+ * Resolve a `claude` that can actually run our headless contract, caching only a
+ * SUCCESSFUL result (see `resolvedCompatibleClaude`). Throws an actionable,
+ * leak-free error when none can — without caching it, so a transient failure is
+ * retried on the next call. The winning binary is probed once per process; a
+ * failing resolution re-probes (cheaply, unless a compatible binary is the one
+ * transiently failing — which we deliberately retry).
+ */
+async function resolveCompatibleClaudeExecutable(cwd, model) {
+    if (resolvedCompatibleClaude)
+        return resolvedCompatibleClaude;
+    const candidates = listClaudeCandidatePaths();
+    if (candidates.length === 0) {
+        throw new Error("Claude Code CLI (`claude`) was not found on PATH or in the usual install " +
+            "locations (~/.local/bin, /opt/homebrew/bin, …). Install it " +
+            "(https://claude.com/claude-code) and sign in once, set RIFT_CLAUDE_CLI_PATH " +
+            "to its path, or set capture.triage.provider = codex_cli.");
+    }
+    const rejections = [];
+    for (const candidate of candidates) {
+        const reason = await probeClaudeCandidate(candidate, cwd, model);
+        if (reason === null) {
+            resolvedCompatibleClaude = candidate;
+            return candidate;
+        }
+        rejections.push({ path: candidate, reason });
+    }
+    // NOT cached: every rejection here may be transient (auth/network/rate limit),
+    // so the next call re-probes and recovers without a daemon restart.
+    throw new Error(buildNoCompatibleClaudeMessage(rejections));
+}
+/**
+ * Cheap synchronous "is a `claude` CLI installed anywhere we'd look?" probe —
+ * the SAME candidate search the resolver uses, so it honors `RIFT_CLAUDE_CLI_PATH`
+ * and the broadened fallback dirs (`~/.local/bin`, …). Detects install only, NOT
+ * compatibility or auth: an old or wrapped `claude` passes here, and the real
+ * compatibility check (and the actionable error) happens in
+ * `resolveCompatibleClaudeExecutable` at call time. Used only as the coarse
+ * metadata-selection gate; a false positive degrades safely to Basic metadata.
+ *
+ * Using the resolver's candidate list (not a separate resolver) is what keeps
+ * the "one `RIFT_CLAUDE_CLI_PATH` override unblocks BOTH triage and metadata"
+ * promise true: an override that lets triage resolve must also let the metadata
+ * gate report available, instead of silently falling back to Basic.
+ */
+export function isClaudeCliAvailable() {
+    return listClaudeCandidatePaths().length > 0;
+}
+export function resetClaudeCliRunnerCacheForTests() {
+    claudeVersionPromise = null;
+    testFallbackDirs = undefined;
+    resolvedCompatibleClaude = undefined;
+}
+/**
+ * Test seam: override the executable fallback dirs so a test can simulate
+ * "claude not installed" even on a dev machine that has it in /opt/homebrew/bin.
+ * Clears the resolution cache.
+ */
+export function setClaudeFallbackDirsForTests(dirs) {
+    testFallbackDirs = dirs;
+    resolvedCompatibleClaude = undefined;
+}
+async function resolveClaudeCliTag(executable, cwd) {
+    if (claudeVersionPromise === null) {
+        claudeVersionPromise = runClaudeCommand(executable, ["--version"], {
+            cwd,
+            timeoutMs: 15_000,
+        })
+            .then(({ stdout }) => stdout.trim() || "claude-cli")
+            .catch(() => "claude-cli");
+    }
+    return claudeVersionPromise;
+}
+async function runClaudeCommand(executable, args, options) {
+    return new Promise((resolve, reject) => {
+        let stdinError = null;
+        let stdout = "";
+        let stderr = "";
+        // We own the timeout so a timeout-kill is distinguishable from any OTHER
+        // signal termination — only the timeout path is retryable upstream.
+        let timedOut = false;
+        let child;
+        try {
+            child = spawn(executable, args, {
+                cwd: options.cwd,
+                stdio: ["pipe", "pipe", "pipe"],
+                env: claudeCliEnv(),
+            });
+        }
+        catch (error) {
+            reject(new Error(`Claude CLI failed to spawn: ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, options.timeoutMs);
+        timer.unref?.();
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(new Error(`Claude CLI failed to start: ${error.message}`));
+        });
+        child.stdout?.setEncoding("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.setEncoding("utf-8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        if (child.stdin) {
+            child.stdin.on("error", (error) => {
+                stdinError = error;
+            });
+            // Pipe the prompt as stdin and close it immediately so `claude -p` does
+            // not stall waiting for more input.
+            child.stdin.end(options.stdinText ?? "");
+        }
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            // Classify stderr into a SAFE, canned token — NEVER the raw bytes. The
+            // captured conversation is delivered via stdin (never echoed back) and
+            // the model output is the stdout JSON envelope (which we never surface),
+            // but stderr is third-party CLI output we don't control: a future
+            // `claude` could write prompt text, result text, a debug dump, or an API
+            // error body there. So we refuse to pass it through verbatim — a
+            // recognized failure mode yields a fixed phrase (carrying keywords the
+            // doctor/friend-status classifier recognizes), an unrecognized one yields
+            // only the exit code. This enforces the "no captured content/model output
+            // in errors" guarantee structurally instead of by assumption.
+            const summary = classifyClaudeStderr(stderr);
+            const detail = summary ? ` — ${summary}` : "";
+            if (code === null) {
+                if (timedOut) {
+                    reject(new ClaudeCliTimeoutError(options.timeoutMs, signal, detail));
+                    return;
+                }
+                reject(new Error(`Claude CLI was terminated by ${signal ?? "an unknown signal"} (not a timeout)${detail}`));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`Claude CLI failed (exit ${code})${detail}`));
+                return;
+            }
+            if (stdinError && !isIgnorableStdinError(stdinError)) {
+                reject(new Error(`Claude CLI stdin failed: ${stdinError.message}`));
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+function isIgnorableStdinError(error) {
+    return ("code" in error &&
+        (error.code === "EPIPE" ||
+            error.code === "ECONNRESET" ||
+            error.code === "ERR_STREAM_DESTROYED"));
+}
+/**
+ * Map `claude` stderr to a SAFE, canned diagnostic token — never the raw text.
+ * The locked guarantee is that runner errors carry NO captured conversation or
+ * model output. Captured content travels via stdin (never echoed) and the
+ * model's output is the stdout JSON envelope (never surfaced); stderr is the
+ * only third-party stream we don't fully control, so we classify it into a
+ * fixed phrase and return ONLY that. A recognized failure mode never leaks the
+ * surrounding bytes; an unrecognized one returns "" (the caller surfaces just
+ * the exit code/signal). The phrases carry keywords `classifyCodexPreflightError`
+ * recognizes (auth/network) so the persisted error still buckets correctly.
+ * Mirrors codex-preflight's "deliberately canned" leak-free summaries.
+ */
+export function classifyClaudeStderr(stderr) {
+    const text = stderr.toLowerCase();
+    // CLI-contract / version mismatch — an unknown/invalid flag means the resolved
+    // `claude` predates a flag we depend on (e.g. --safe-mode) or isn't the Claude
+    // CLI at all. Checked first: it is unambiguous and must not be misread as auth.
+    if (/unknown option|unknown argument|unknown command|invalid option|unrecognized option|--safe-mode|option .* not found/.test(text)) {
+        return "Claude CLI flag/contract error — CLI too old or incompatible (upgrade Claude Code or set RIFT_CLAUDE_CLI_PATH)";
+    }
+    // Headless / PTY-wrapper failure — a wrapper or shim intercepting `claude`
+    // cannot pipe stdin to a real `-p` run, so it complains about missing input or
+    // demands a terminal. Distinct from auth/network so doctor copy can point at
+    // the wrapper, not credentials.
+    if (/input must be provided|when using --print|requires? a (tty|terminal|interactive|raw mode)|not a tty|raw mode is not supported|\/dev\/tty|stdin is not/.test(text)) {
+        return "Claude CLI could not run headless — a PATH wrapper/PTY shim may be intercepting `claude` (set RIFT_CLAUDE_CLI_PATH to the real binary, or use codex_cli)";
+    }
+    if (/not authenticated|not (logged|signed) in|invalid api key|\bunauthorized\b|\b401\b|please (run|sign|log).{0,12}(login|in)|authentication failed|credentials? (expired|invalid)/.test(text)) {
+        return "authentication failed (run `claude` and sign in)";
+    }
+    if (/rate limit|\b429\b|too many requests/.test(text)) {
+        return "rate limited";
+    }
+    if (/usage limit|\bquota\b|out of credits|insufficient (credit|quota|balance)/.test(text)) {
+        return "usage limit reached";
+    }
+    if (/econnrefused|econnreset|enotfound|etimedout|getaddrinfo|socket hang up|connection (refused|reset)|failed to (connect|reach)|\bnetwork\b|http 5\d\d/.test(text)) {
+        return "network error";
+    }
+    return "";
+}
+/** Env vars that route `claude` to API-key auth instead of the subscription. */
+const CLAUDE_API_KEY_ENV_VARS = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+];
+/**
+ * Build the child env for the `claude` subprocess. We strip the API-key auth
+ * vars so triage ALWAYS runs on the operator's logged-in Claude Code
+ * subscription — never silently billing an ambient API key. This is what makes
+ * the "Rift holds no API key / runs on your own subscription" trust model true
+ * in practice rather than by assumption: a user who exported ANTHROPIC_API_KEY
+ * for some other tool would otherwise have every captured session billed to
+ * that key. The common subscription user (OAuth in `~/.claude`, no such var
+ * set) is unaffected — this is a no-op for them. A user whose ONLY claude auth
+ * is an API key gets the honest "authenticate claude or set
+ * capture.triage.provider = codex_cli" failure instead of surprise API spend.
+ * `--safe-mode` keeps auth/model/built-in tools working normally, so the
+ * subscription path is untouched.
+ */
+function claudeCliEnv() {
+    const env = { ...process.env };
+    for (const key of CLAUDE_API_KEY_ENV_VARS) {
+        delete env[key];
+    }
+    return env;
+}
+//# sourceMappingURL=claude-cli-runner.js.map

package/dist/src/providers/claude-cli-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-cli-runner.js","sourceRoot":"","sources":["../../../src/providers/claude-cli-runner.ts"],"names":[],"mappings":"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"}

package/dist/src/providers/codex-cli-metadata-extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-cli-metadata-extraction.d.ts","sourceRoot":"","sources":["../../../src/providers/codex-cli-metadata-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,4BAA4B,EAC7B,MAAM,YAAY,CAAC;AAoDpB,qBAAa,yBAA0B,YAAW,iBAAiB;IAM/D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,SAAS,CAAqB;gBAGnB,OAAO,GAAE;QACxB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;KACzB;IAKF,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAmDlE,aAAa,IAAI,4BAA4B;CAU9C"}
+{"version":3,"file":"codex-cli-metadata-extraction.d.ts","sourceRoot":"","sources":["../../../src/providers/codex-cli-metadata-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,4BAA4B,EAC7B,MAAM,YAAY,CAAC;AAapB,qBAAa,yBAA0B,YAAW,iBAAiB;IAM/D,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,SAAS,CAAqB;gBAGnB,OAAO,GAAE;QACxB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;KACzB;IAKF,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAmDlE,aAAa,IAAI,4BAA4B;CAU9C"}