0sec-cli 0.18.0 → 0.22.0

package/chunks/{chunk-72CISA2D.js → chunk-VNRY6AWF.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { createRequire as __0secCreateRequire } from "node:module";
-const require = __0secCreateRequire(import.meta.url);
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
 import {
   homeStateDir,
   runStateDir
-} from "./chunk-6L26OBWI.js";
+} from "./chunk-76KSBWOQ.js";
 import {
   __export
-} from "./chunk-IR537GON.js";
+} from "./chunk-VCSFCHAJ.js";
 
 // packages/db/dist/wasm-shim.js
 import { BetterSQLiteSession } from "drizzle-orm/better-sqlite3/session";
@@ -99,7 +99,7 @@ var ShimmedDatabase = class {
    * only uses it as a setter ("journal_mode = WAL", "foreign_keys = ON"), so
    * we just `exec()` the pragma and swallow errors — some PRAGMAs (notably
    * WAL journal mode) are not supported by node-sqlite3-wasm's VFS and error
-   * here, but losing them is acceptable for 0sec's single-process workload.
+   * here, but losing them is acceptable for 0's single-process workload.
    */
   pragma(query, _opts) {
     try {
@@ -112,7 +112,7 @@ var ShimmedDatabase = class {
    * better-sqlite3's `db.transaction(fn)` returns a callable object with
    * `.deferred`, `.immediate`, `.exclusive`, and `.default` methods, each
    * running `fn` inside a BEGIN/COMMIT of the corresponding isolation level.
-   * All three variants are functionally equivalent for 0sec's single-writer
+   * All three variants are functionally equivalent for 0's single-writer
    * workload, so we wire them to the same underlying implementation.
    */
   transaction(fn) {
@@ -357,29 +357,29 @@ var findings = sqliteTable("findings", {
   evidenceResponse: text("evidenceResponse").notNull(),
   evidenceAnalysis: text("evidenceAnalysis"),
   /**
-   * JSON-stringified LayerVerdict[] (see @0sec/shared types). NULL until
+   * JSON-stringified LayerVerdict[] (see @0/shared types). NULL until
    * the triage stage runs. Stored as text rather than a join table because
    * the array is read-and-write together at finding-save time and we never
-   * query individual verdict rows. See 0sec#112.
+   * query individual verdict rows. See 0#112.
    */
   layerVerdicts: text("layerVerdicts"),
   impactAssessment: text("impactAssessment"),
   // JSON: ImpactAssessment (reachability/blast/weaponizability/business)
   /**
-   * JSON-stringified PocStep[] (see @0sec/shared types). NULL when the
+   * JSON-stringified PocStep[] (see @0/shared types). NULL when the
    * agent only produced prose evidence (the legacy default). Stored as
    * text rather than a join table because the array is read-and-write
    * together at finding-save time and we never query individual steps.
-   * See 0sec#170.
+   * See 0#170.
    */
   pocSteps: text("pocSteps"),
   /**
-   * JSON-stringified VerificationSpec (see @0sec/shared types). NULL
+   * JSON-stringified VerificationSpec (see @0/shared types). NULL
    * when the agent produced a finding without a deterministic re-check
    * contract — every reader must continue to work in that case. Stored
    * as text because the spec is an opaque blob that the verifier reads
-   * whole; we never query individual predicates. See 0sec#193 /
-   * 0sec-cloud#111.
+   * whole; we never query individual predicates. See 0#193 /
+   * 0-cloud#111.
    */
   verificationSpec: text("verificationSpec"),
   /**
@@ -395,11 +395,11 @@ var findings = sqliteTable("findings", {
   /**
    * JSON-stringified PocExecutionReport written when `disclose --target-url`
    * runs the step graph against a live target. NULL until that runs. See
-   * 0sec#171.
+   * 0#171.
    */
   pocExecution: text("pocExecution"),
   /**
-   * JSON-stringified VerificationResult (see @0sec/shared
+   * JSON-stringified VerificationResult (see @0/shared
    * `VerificationResultSchema`) — the last deterministic-replay result
    * attached to the finding. NULL when the finding was never verified;
    * readers MUST treat NULL / malformed / statusless payloads as
@@ -409,6 +409,12 @@ var findings = sqliteTable("findings", {
    * `verificationSpec`: the blob is read and written whole.
    */
   verificationResult: text("verificationResult"),
+  /**
+   * JSON-stringified safe code-only source-verification summary. NULL when
+   * no scoped source workspace/spec was available or data is unusable; it
+   * never carries canonical replay status.
+   */
+  sourceVerification: text("sourceVerification"),
   /**
    * JSON-stringified Finding["reviewAnnotation"] — the scoped source
    * reference (`path` + line range, optional suggestion / knownMarker)
@@ -609,9 +615,9 @@ var trustGraphEdges = sqliteTable("trust_graph_edges", {
 
 // packages/db/dist/database.js
 var DEFAULT_DB_DIR = homeStateDir();
-var DEFAULT_DB_PATH = join(DEFAULT_DB_DIR, "0sec.db");
+var DEFAULT_DB_PATH = join(DEFAULT_DB_DIR, "0.db");
 function resolveOsecDbPath(dbPath) {
-  const configuredPath = process.env["0SEC_DB_PATH"]?.trim();
+  const configuredPath = process.env["ZERO_DB_PATH"]?.trim();
   return dbPath ?? (configuredPath ? configuredPath : DEFAULT_DB_PATH);
 }
 function resetOsecDatabase(dbPath) {
@@ -725,7 +731,7 @@ function migrateWalHeaderIfNeeded(path) {
     }
   }
   if (hadWalData) {
-    console.warn(`[0sec] Migrated ${path} from WAL mode to rollback mode for WASM engine compatibility. A non-empty WAL sidecar was present and has been removed; any uncommitted transactions from a prior crashed run were discarded.`);
+    console.warn(`[0] Migrated ${path} from WAL mode to rollback mode for WASM engine compatibility. A non-empty WAL sidecar was present and has been removed; any uncommitted transactions from a prior crashed run were discarded.`);
   }
 }
 function clearStaleLockIfAny(path) {
@@ -744,7 +750,7 @@ function clearStaleLockIfAny(path) {
     return;
   try {
     rmSync(lockPath, { recursive: true, force: true });
-    console.warn(`[0sec] Removed stale database lock at ${lockPath} (age ${Math.floor(ageMs / 1e3)}s \u2014 previous holder likely crashed).`);
+    console.warn(`[0] Removed stale database lock at ${lockPath} (age ${Math.floor(ageMs / 1e3)}s \u2014 previous holder likely crashed).`);
   } catch {
   }
 }
@@ -779,7 +785,7 @@ var osecDB = class {
         throw error;
       const backupPath = backupCorruptDatabase(path);
       this.initializeDatabase(path);
-      console.warn(backupPath ? `[0sec] Recovered malformed database at ${path}. Backup saved to ${backupPath}.` : `[0sec] Recovered malformed database state at ${path} by recreating a fresh database.`);
+      console.warn(backupPath ? `[0] Recovered malformed database at ${path}. Backup saved to ${backupPath}.` : `[0] Recovered malformed database state at ${path} by recreating a fresh database.`);
     }
   }
   initializeDatabase(path) {
@@ -787,9 +793,11 @@ var osecDB = class {
     this.sqlite.pragma("foreign_keys = ON");
     ensureDatabaseHealthy(this.sqlite);
     this.db = createDrizzleFromShim(this.sqlite, { schema: schema_exports });
-    this.sqlite.exec(SCHEMA_TABLES_SQL);
-    this.migrate();
-    this.sqlite.exec(SCHEMA_INDEXES_SQL);
+    this.sqlite.transaction(() => {
+      this.sqlite.exec(SCHEMA_TABLES_SQL);
+      this.migrate();
+      this.sqlite.exec(SCHEMA_INDEXES_SQL);
+    })();
   }
   initializeReadOnlyDatabase(path) {
     this.sqlite = createShimmedDatabase(path);
@@ -797,7 +805,7 @@ var osecDB = class {
     this.db = createDrizzleFromShim(this.sqlite, { schema: schema_exports });
   }
   /**
-   * Upgrade databases created by older 0sec versions.
+   * Upgrade databases created by older 0 versions.
    *
    * SCHEMA_TABLES_SQL (above) now contains every table and every column from
    * the drizzle schema, so fresh installs need no patching. This method only
@@ -806,7 +814,7 @@ var osecDB = class {
    * table_info is cached by SQLite) and the ALTERs are no-ops when the
    * column is already present, so running on a fresh DB is harmless.
    *
-   * See: https://github.com/0sec-labs/0sec/issues/420
+   * See: https://github.com/0sec-labs/0/issues/420
    */
   migrate() {
     const cols = this.sqlite.prepare("PRAGMA table_info(findings)").all();
@@ -871,6 +879,9 @@ var osecDB = class {
     if (!colNames.has("reviewAnnotation")) {
       this.sqlite.exec("ALTER TABLE findings ADD COLUMN reviewAnnotation TEXT");
     }
+    if (!colNames.has("sourceVerification")) {
+      this.sqlite.exec("ALTER TABLE findings ADD COLUMN sourceVerification TEXT");
+    }
     this.sqlite.exec("UPDATE findings SET fingerprint = id WHERE fingerprint IS NULL OR fingerprint = ''");
     this.sqlite.exec("UPDATE findings SET triageStatus = 'new' WHERE triageStatus IS NULL OR triageStatus = ''");
     this.sqlite.exec(`
@@ -1362,6 +1373,7 @@ var osecDB = class {
     const semanticDedupeJson = finding.semanticDedupe ? JSON.stringify(finding.semanticDedupe) : null;
     const verificationResultJson = serializeFindingVerificationResult(finding.verification_result);
     const reviewAnnotationJson = serializeFindingReviewAnnotation(finding.reviewAnnotation);
+    const sourceVerificationJson = serializeFindingSourceVerification(finding.sourceVerification);
     const candidateFindingRank = finding.findingRank;
     const findingRank = typeof candidateFindingRank === "number" && Number.isSafeInteger(candidateFindingRank) && candidateFindingRank > 0 ? candidateFindingRank : null;
     const derivedEvidence = deriveEvidenceFromPocSteps(finding);
@@ -1398,6 +1410,7 @@ var osecDB = class {
       findingRank,
       verificationResult: verificationResultJson,
       reviewAnnotation: reviewAnnotationJson,
+      sourceVerification: sourceVerificationJson,
       timestamp: finding.timestamp
     }).onConflictDoUpdate({
       target: findings.id,
@@ -1429,6 +1442,7 @@ var osecDB = class {
         findingRank,
         verificationResult: verificationResultJson,
         reviewAnnotation: reviewAnnotationJson,
+        sourceVerification: sourceVerificationJson,
         timestamp: finding.timestamp
       }
     }).run();
@@ -1438,11 +1452,10 @@ var osecDB = class {
     return this.db.select().from(findings).where(eq(findings.id, findingId)).get();
   }
   /**
-   * Read path for the two source-fix gate fields. Returns the hydrated
-   * `verification_result` / `reviewAnnotation` for a finding, with each key
-   * omitted when the finding has none (including rows written before the
-   * columns existed). Callers building a `Finding` spread this over the row:
-   * `{ ...mapped, ...db.getFindingReviewFields(id) }`.
+   * Read path for the persisted `verification_result`, `reviewAnnotation`,
+   * and `sourceVerification` fields. The first two retain their existing
+   * source-fix gate semantics; a source-only check is never replay evidence.
+   * Each key is omitted when absent, including for pre-migration rows.
    */
   getFindingReviewFields(findingId) {
     return restoreFindingReviewFields(this.getFinding(findingId));
@@ -1949,7 +1962,7 @@ var osecDB = class {
     const result = this.sqlite.prepare(`DELETE FROM workers WHERE status IN (${placeholders})`).run(...values);
     return result.changes;
   }
-  // ── Persistent credential store (0sec#771) ──
+  // ── Persistent credential store (0#771) ──
   /**
    * Upsert a discovered foothold keyed by (credentialKind, valueHash). First
    * write records the discovery attribution (target/finding/scan/turn);
@@ -2019,7 +2032,7 @@ var osecDB = class {
     const limit = query.limit ?? 500;
     return this.sqlite.prepare(`SELECT * FROM persistent_credentials ${whereSql} ORDER BY lastSeenAt DESC LIMIT ${limit}`).all(...params);
   }
-  // ── Trust graph edges (0sec#771) ──
+  // ── Trust graph edges (0#771) ──
   /**
    * Upsert a directed trust edge keyed by
    * (srcKind, srcId, dstKind, dstId, relation). Re-observing an edge refreshes
@@ -2167,6 +2180,38 @@ function parseFindingReviewAnnotation(value) {
     return void 0;
   return parsed;
 }
+function parseFindingSourceVerification(value) {
+  const parsed = parseJsonObjectColumn(value);
+  if (!parsed)
+    return void 0;
+  const status = parsed.status;
+  const totalPredicates = parsed.totalPredicates;
+  const matchedPredicates = parsed.matchedPredicates;
+  const notMatchedPredicates = parsed.notMatchedPredicates;
+  const inconclusivePredicates = parsed.inconclusivePredicates;
+  const behaviorPending = parsed.behaviorPending;
+  if (status !== "matched" && status !== "not_confirmed" && status !== "inconclusive" || typeof totalPredicates !== "number" || !Number.isSafeInteger(totalPredicates) || totalPredicates < 0 || typeof matchedPredicates !== "number" || !Number.isSafeInteger(matchedPredicates) || matchedPredicates < 0 || typeof notMatchedPredicates !== "number" || !Number.isSafeInteger(notMatchedPredicates) || notMatchedPredicates < 0 || typeof inconclusivePredicates !== "number" || !Number.isSafeInteger(inconclusivePredicates) || inconclusivePredicates < 0 || typeof behaviorPending !== "boolean") {
+    return void 0;
+  }
+  const countSum = matchedPredicates + notMatchedPredicates + inconclusivePredicates;
+  if (!Number.isSafeInteger(countSum) || countSum !== totalPredicates)
+    return void 0;
+  if (status === "matched" && (totalPredicates === 0 || matchedPredicates !== totalPredicates || notMatchedPredicates !== 0 || inconclusivePredicates !== 0) || status === "not_confirmed" && (notMatchedPredicates === 0 || inconclusivePredicates !== 0) || status === "inconclusive" && inconclusivePredicates === 0 && totalPredicates !== 0) {
+    return void 0;
+  }
+  return {
+    status,
+    totalPredicates,
+    matchedPredicates,
+    notMatchedPredicates,
+    inconclusivePredicates,
+    behaviorPending
+  };
+}
+function serializeFindingSourceVerification(value) {
+  const usable = parseFindingSourceVerification(value);
+  return usable ? JSON.stringify(usable) : null;
+}
 function serializeFindingVerificationResult(value) {
   const usable = parseFindingVerificationResult(value);
   return usable ? JSON.stringify(usable) : null;
@@ -2180,9 +2225,11 @@ function restoreFindingReviewFields(row) {
     return {};
   const verificationResult = parseFindingVerificationResult(row.verificationResult);
   const reviewAnnotation = parseFindingReviewAnnotation(row.reviewAnnotation);
+  const sourceVerification = parseFindingSourceVerification(row.sourceVerification);
   return {
     ...verificationResult ? { verification_result: verificationResult } : {},
-    ...reviewAnnotation ? { reviewAnnotation } : {}
+    ...reviewAnnotation ? { reviewAnnotation } : {},
+    ...sourceVerification ? { sourceVerification } : {}
   };
 }
 function deriveEvidenceFromPocSteps(finding) {
@@ -2276,6 +2323,7 @@ CREATE TABLE IF NOT EXISTS findings (
   findingRank INTEGER,
   verificationResult TEXT,
   reviewAnnotation TEXT,
+  sourceVerification TEXT,
   timestamp INTEGER NOT NULL
 );
 
@@ -2484,24 +2532,24 @@ var STATE_DB_FILE = "state.db";
 var REPORT_FILE = "report.json";
 function normalizeRunId(value) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)) {
-    throw new Error(`Invalid 0sec run id ${JSON.stringify(value)}.`);
+    throw new Error(`Invalid 0 run id ${JSON.stringify(value)}.`);
   }
   return value;
 }
 function resolveOsecRunStorage(options = {}) {
   const env = options.env ?? process.env;
-  const cloudRunId = env["0SEC_CLOUD_SCAN_ID"]?.trim() || void 0;
+  const cloudRunId = env["ZERO_CLOUD_SCAN_ID"]?.trim() || void 0;
   let runId = normalizeRunId(options.runId ?? cloudRunId ?? randomUUID2());
   const stateDir = homeStateDir(options.homeDir);
-  const configuredRunDir = env["0SEC_RUN_DIR"]?.trim() || void 0;
-  const configuredDbPath = options.dbPath ?? (env["0SEC_DB_PATH"]?.trim() || void 0);
+  const configuredRunDir = env["ZERO_RUN_DIR"]?.trim() || void 0;
+  const configuredDbPath = options.dbPath ?? (env["ZERO_DB_PATH"]?.trim() || void 0);
   let runDir = configuredRunDir ? resolve(configuredRunDir) : runStateDir(runId, options.homeDir);
   if (options.resume && !configuredRunDir && !configuredDbPath && !existsSync2(runDir)) {
     const runsDir = join2(stateDir, "runs");
     if (existsSync2(runsDir)) {
       const matches = readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith(runId));
       if (matches.length > 1) {
-        throw new Error(`0sec run id prefix '${runId}' is ambiguous.`);
+        throw new Error(`0 run id prefix '${runId}' is ambiguous.`);
       }
       const match = matches[0];
       if (match) {
@@ -2511,13 +2559,13 @@ function resolveOsecRunStorage(options = {}) {
     }
   }
   if (!isAbsolute(runDir)) {
-    throw new Error(`0sec run directory must be absolute: ${JSON.stringify(runDir)}.`);
+    throw new Error(`0 run directory must be absolute: ${JSON.stringify(runDir)}.`);
   }
   let dbPath = configuredDbPath ? configuredDbPath === ":memory:" ? configuredDbPath : resolve(configuredDbPath) : join2(runDir, STATE_DB_FILE);
-  const configuredReportPath = env["0SEC_REPORT_PATH"]?.trim() || void 0;
+  const configuredReportPath = env["ZERO_REPORT_PATH"]?.trim() || void 0;
   const reportPath = configuredReportPath ? resolve(configuredReportPath) : !configuredDbPath || configuredRunDir ? join2(runDir, REPORT_FILE) : void 0;
   if (options.resume && !configuredDbPath && !existsSync2(dbPath)) {
-    const legacyDbPath = join2(stateDir, "0sec.db");
+    const legacyDbPath = join2(stateDir, "0.db");
     if (existsSync2(legacyDbPath))
       dbPath = legacyDbPath;
   }

package/chunks/chunk-W6UWZFKL.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+
+// packages/core/dist/runtime/process.js
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { writeFileSync } from "node:fs";
+var dim = (text) => `\x1B[2m${text}\x1B[0m`;
+function formatToolDetail(input) {
+  const inp = input;
+  if (inp?.file_path)
+    return String(inp.file_path).split("/").slice(-2).join("/");
+  if (inp?.command)
+    return String(inp.command).slice(0, 60);
+  if (inp?.pattern)
+    return String(inp.pattern).slice(0, 40);
+  if (inp?.path)
+    return String(inp.path).slice(0, 60);
+  if (inp?.content)
+    return "(writing file)";
+  return "";
+}
+function friendlyToolName(name) {
+  const stripped = name.replace(/^mcp__\w+__/, "");
+  return stripped.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function showToolCall(onToolCall, name, input) {
+  const rawName = name || "tool";
+  if (/^(ToolSearch|Read|Glob|Grep|Write|Edit|Bash|LSP|Agent)$/i.test(rawName))
+    return;
+  const toolName = friendlyToolName(rawName);
+  const detail = formatToolDetail(input);
+  if (onToolCall) {
+    onToolCall(toolName, detail);
+  }
+  if (process.stderr.isTTY && !onToolCall) {
+    process.stderr.write(dim(`    ${toolName}${detail ? ": " + detail : ""}
+`));
+  }
+}
+var RUNTIME_COMMANDS = {
+  claude: "claude",
+  codex: "codex",
+  gemini: "gemini"
+};
+function resolveCliEntrypoint() {
+  return resolve(process.argv[1] ?? join(process.cwd(), "dist", "index.js"));
+}
+function buildOsecMcpCommandArgs(context) {
+  const cliEntrypoint = resolveCliEntrypoint();
+  const args = [
+    cliEntrypoint,
+    "mcp-server",
+    "--target",
+    context.target ?? "",
+    "--scan-id",
+    context.scanId ?? "no-scan-id"
+  ];
+  if (context.mcp?.dbPath) {
+    args.push("--db-path", context.mcp.dbPath);
+  }
+  if (context.mcp?.scopeFile) {
+    args.push("--scope", context.mcp.scopeFile);
+  }
+  if (context.mcp?.rateLimit) {
+    args.push("--rate-limit", context.mcp.rateLimit);
+  }
+  if (context.mcp?.allowScanners) {
+    args.push("--allow-scanners");
+  }
+  return args;
+}
+function buildClaudeMcpConfig(context) {
+  return JSON.stringify({
+    mcpServers: {
+      "0": {
+        command: process.execPath,
+        args: buildOsecMcpCommandArgs(context)
+      }
+    }
+  });
+}
+function describeSpawnFailure(err, command, argv) {
+  const code = err?.code;
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "E2BIG" || message.includes("E2BIG")) {
+    const bytes = argv.reduce((total, arg) => total + Buffer.byteLength(arg, "utf8") + 1, 0);
+    return `${command} could not be started: the prompt is too large for one command line (${bytes} bytes of arguments, over this system's limit). Narrow the run \u2014 a smaller --subsystem or scope, or a lower --batch-size \u2014 so less content is sent in a single request.`;
+  }
+  return message;
+}
+var ProcessRuntime = class {
+  type;
+  config;
+  command;
+  constructor(config) {
+    this.type = config.type;
+    this.config = config;
+    this.command = RUNTIME_COMMANDS[config.type] ?? config.type;
+  }
+  async execute(prompt, context) {
+    const start = Date.now();
+    const args = this.buildArgs(prompt, context);
+    const env = this.buildEnv(context);
+    const onToolCall = this.config.onToolCall;
+    return new Promise((resolve2) => {
+      let stdout = "";
+      let stderr = "";
+      let resultText = "";
+      let timedOut = false;
+      const isJsonStream = args.includes("stream-json") || args.includes("--json");
+      let proc;
+      try {
+        proc = spawn(this.command, args, {
+          cwd: this.config.cwd ?? process.cwd(),
+          env: { ...process.env, ...env },
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (err) {
+        resolve2({
+          output: "",
+          exitCode: 1,
+          timedOut: false,
+          durationMs: Date.now() - start,
+          error: describeSpawnFailure(err, this.command, args)
+        });
+        return;
+      }
+      proc.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        if (isJsonStream) {
+          for (const line of text.split("\n")) {
+            if (!line.trim())
+              continue;
+            try {
+              const event = JSON.parse(line);
+              if (event.type === "assistant" && event.message?.content) {
+                for (const block of event.message.content) {
+                  if (block.type === "text") {
+                    resultText += block.text;
+                    this.config.onThinking?.(block.text);
+                  } else if (block.type === "tool_use") {
+                    showToolCall(onToolCall, block.name, block.input);
+                  }
+                }
+              } else if (event.type === "result") {
+                resultText = event.result || resultText;
+              }
+              if (event.type === "item.started" && event.item?.type === "command_execution") {
+                showToolCall(onToolCall, "shell", { command: event.item.command });
+              }
+              if (event.type === "item.completed" && event.item) {
+                if (event.item.type === "agent_message" && event.item.text) {
+                  resultText += event.item.text;
+                  this.config.onThinking?.(event.item.text);
+                } else if (event.item.type === "command_execution" && event.item.command) {
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      });
+      proc.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderr += text;
+        if (/permission|approve|allow.*tool/i.test(stderr) && stderr.length > 500) {
+          proc.kill("SIGTERM");
+          stderr += "\n[0] Subprocess killed: MCP tools require interactive approval. Use --runtime api instead.";
+        }
+      });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+        setTimeout(() => proc.kill("SIGKILL"), 5e3);
+      }, this.config.timeout);
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const output = isJsonStream ? (resultText || stdout).trim() : stdout.trim();
+        resolve2({
+          output,
+          exitCode: code,
+          timedOut,
+          durationMs: Date.now() - start,
+          error: code !== 0 ? stderr.trim() || void 0 : void 0
+        });
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        resolve2({
+          output: "",
+          exitCode: 1,
+          timedOut: false,
+          durationMs: Date.now() - start,
+          error: describeSpawnFailure(err, this.command, args)
+        });
+      });
+    });
+  }
+  async isAvailable() {
+    const attempt = (timeoutMs) => new Promise((resolve2) => {
+      const proc = spawn(this.command, ["--version"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let settled = false;
+      const finish = (ok) => {
+        if (settled)
+          return;
+        settled = true;
+        resolve2(ok);
+      };
+      proc.on("close", (code) => finish(code === 0));
+      proc.on("error", () => finish(false));
+      setTimeout(() => {
+        proc.kill();
+        finish(false);
+      }, timeoutMs).unref?.();
+    });
+    if (await attempt(5e3))
+      return true;
+    return attempt(15e3);
+  }
+  buildArgs(prompt, context) {
+    switch (this.type) {
+      case "claude": {
+        const args = ["-p", prompt, "--verbose", "--output-format", "stream-json"];
+        if (context?.mcp?.enableTargetTools && context.target && context.scanId) {
+          args.push("--mcp-config", buildClaudeMcpConfig(context), "--dangerously-skip-permissions");
+        }
+        if (context?.systemPrompt) {
+          args.push("--system-prompt", context.systemPrompt);
+        }
+        if (this.config.outputSchema) {
+          args.push("--json-schema", JSON.stringify(this.config.outputSchema));
+        }
+        return args;
+      }
+      case "codex": {
+        const args = [
+          "exec",
+          "--skip-git-repo-check",
+          "--json"
+        ];
+        if (this.config.model) {
+          args.push("--model", this.config.model);
+        }
+        if (context?.mcp?.enableTargetTools && context.target && context.scanId) {
+          throw new Error("Codex CLI MCP target tools are not supported. Use the direct ChatGPT Codex provider for live target scans.");
+        }
+        if (this.config.outputSchema) {
+          const schemaPath = join(tmpdir(), `0-schema-${Date.now()}.json`);
+          writeFileSync(schemaPath, JSON.stringify(this.config.outputSchema));
+          args.push("--output-schema", schemaPath);
+        }
+        args.push(prompt);
+        return args;
+      }
+      case "gemini": {
+        const args = ["-p", prompt, "--output-format", "stream-json"];
+        return args;
+      }
+      default:
+        return ["-p", prompt];
+    }
+  }
+  buildEnv(context) {
+    const env = {
+      ...this.config.env
+    };
+    if (context?.target) {
+      env["ZERO_TARGET"] = context.target;
+    }
+    if (context?.findings) {
+      env["ZERO_FINDINGS"] = context.findings;
+    }
+    if (context?.templateId) {
+      env["ZERO_TEMPLATE_ID"] = context.templateId;
+    }
+    if (context?.mcp?.auth) {
+      env["ZERO_MCP_AUTH_JSON"] = JSON.stringify(context.mcp.auth);
+    }
+    if (context?.mcp?.attributionHeaders) {
+      env["ZERO_MCP_ATTRIBUTION_HEADERS_JSON"] = JSON.stringify(context.mcp.attributionHeaders);
+    }
+    if (context?.mcp?.attributionUaToken) {
+      env["ZERO_MCP_ATTRIBUTION_UA_TOKEN"] = context.mcp.attributionUaToken;
+    }
+    return env;
+  }
+};
+
+export {
+  describeSpawnFailure,
+  ProcessRuntime
+};