0sec-cli 0.24.1 → 0.26.0

package/chunks/chunk-ABKUI3QB.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+
+// node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+  let isFirstChunk = true, id, data = "", dataLines = 0, eventType;
+  function feed(chunk) {
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && pendingFragments.push(trailing2);
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk);
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    const trailing = processLines(input);
+    trailing !== "" && pendingFragments.push(trailing);
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+export {
+  EventSourceParserStream
+};

package/chunks/{chunk-5ETI27Q3.js → chunk-AFJ2UMPR.js}

@@ -8,13 +8,13 @@ import {
   parsePatch,
   readEvolutionArtifact,
   resolveScopedPath
-} from "./chunk-YKWARO3T.js";
+} from "./chunk-YGYJ2FTH.js";
 import {
   homeStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
 import {
   external_exports
-} from "./chunk-VIT5ALXF.js";
+} from "./chunk-5XOYTAOK.js";
 
 // packages/core/dist/fix/source-fix.js
 import { execFile } from "node:child_process";

package/chunks/{chunk-XA2IBHPB.js → chunk-B7XL6RON.js}

@@ -3,7 +3,7 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   homeStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
 
 // packages/core/dist/triage/kernel-vm-runner.js
 import { execFileSync, spawn } from "node:child_process";

package/chunks/{chunk-TVS6WVSK.js → chunk-BM6EYP2D.js}

@@ -5,13 +5,13 @@ import {
   makeSkepticVerifier,
   runHuntScan,
   scoreGeometry
-} from "./chunk-YSQWZ67M.js";
+} from "./chunk-SIR7XW2S.js";
 import {
   runReproducerInKernelVm
-} from "./chunk-XA2IBHPB.js";
+} from "./chunk-B7XL6RON.js";
 import {
   LlmApiRuntime
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-HS2NQ7K6.js";
 import {
   __commonJS,
   __require,

package/chunks/{chunk-7UHAXEOV.js → chunk-D4M5WURF.js}

@@ -2,20 +2,237 @@
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
-  spinnerGlyph
-} from "./chunk-OOMBOLAF.js";
+  presentationEventBus
+} from "./chunk-S4DFH2FJ.js";
 import {
   loadLayeredSettings
-} from "./chunk-X2IPO5JO.js";
+} from "./chunk-V2KJQVYE.js";
 import {
+  createPresentationEvent,
   homeStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
+
+// packages/cli/src/presentation/process-output.ts
+import { format } from "node:util";
+var streamBridgeSuppressionDepth = 0;
+var activeStreamBridge = null;
+function currentPresentationTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createProcessPresentationOutput(options = {}) {
+  const stdout = options.stdout ?? { write: process.stdout.write.bind(process.stdout) };
+  const stderr = options.stderr ?? { write: process.stderr.write.bind(process.stderr) };
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const write = (channel, target, text, eventType) => {
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      target.write(text);
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    options.onEvent?.(event);
+    return event;
+  };
+  return {
+    stdout(text, eventType = "output.stdout") {
+      return write("stdout", stdout, text, eventType);
+    },
+    stderr(text, eventType = "output.stderr") {
+      return write("stderr", stderr, text, eventType);
+    }
+  };
+}
+function createConsolePresentationOutput(options = {}) {
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const emit = (channel, text, eventType) => {
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      if (channel === "stdout") {
+        (options.log ?? console.log)(text);
+      } else {
+        (options.error ?? console.error)(text);
+      }
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    options.onEvent?.(event);
+    return event;
+  };
+  return {
+    stdout(text, eventType = "output.stdout") {
+      return emit("stdout", text, eventType);
+    },
+    stderr(text, eventType = "output.stderr") {
+      return emit("stderr", text, eventType);
+    }
+  };
+}
+var consolePresentationOutput = createConsolePresentationOutput({
+  onEvent(event) {
+    presentationEventBus.emit(event);
+  }
+});
+function installConsolePresentationBridge(options = {}) {
+  const target = options.target ?? console;
+  const originals = {
+    log: target.log,
+    info: target.info,
+    warn: target.warn,
+    error: target.error
+  };
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  const emit = (method, channel, args, eventType) => {
+    const text = format(...args);
+    if (streamBridgeSuppressionDepth > 0) {
+      originals[method].call(target, text);
+      return;
+    }
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType,
+      payload: { channel, text }
+    });
+    streamBridgeSuppressionDepth += 1;
+    try {
+      originals[method].call(target, text);
+    } finally {
+      streamBridgeSuppressionDepth -= 1;
+    }
+    presentationEventBus.emit(event);
+    options.onEvent?.(event);
+  };
+  const bridgedLog = (...args) => emit("log", "stdout", args, "output.console.log");
+  const bridgedInfo = (...args) => emit("info", "stdout", args, "output.console.info");
+  const bridgedWarn = (...args) => emit("warn", "stderr", args, "output.console.warn");
+  const bridgedError = (...args) => emit("error", "stderr", args, "output.console.error");
+  target.log = bridgedLog;
+  target.info = bridgedInfo;
+  target.warn = bridgedWarn;
+  target.error = bridgedError;
+  return {
+    restore() {
+      if (target.log === bridgedLog) target.log = originals.log;
+      if (target.info === bridgedInfo) target.info = originals.info;
+      if (target.warn === bridgedWarn) target.warn = originals.warn;
+      if (target.error === bridgedError) target.error = originals.error;
+    }
+  };
+}
+function installProcessPresentationStreamBridge(options = {}) {
+  if (activeStreamBridge) return activeStreamBridge;
+  const source = options.source ?? "cli";
+  const now = options.now ?? currentPresentationTimestamp;
+  let sequence = 0;
+  let suspended = false;
+  const streams = [];
+  const emit = (channel, chunk, encoding) => {
+    const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8") : String(chunk ?? "");
+    if (channel === "stdout" && text.startsWith("ZERO_EVENT_")) return;
+    const event = createPresentationEvent({
+      source,
+      sequence: ++sequence,
+      at: now(),
+      eventType: channel === "stdout" ? "output.stream.stdout" : "output.stream.stderr",
+      payload: { channel, text }
+    });
+    presentationEventBus.emit(event);
+    options.onEvent?.(event);
+  };
+  for (const [channel, stream] of [
+    ["stdout", options.stdout ?? process.stdout],
+    ["stderr", options.stderr ?? process.stderr]
+  ]) {
+    const original = stream.write;
+    const patched = ((chunk, encoding, callback) => {
+      const result = original.call(stream, chunk, encoding, callback);
+      if (!suspended && streamBridgeSuppressionDepth === 0) emit(channel, chunk, encoding);
+      return result;
+    });
+    streams.push({ channel, stream, original, patched });
+  }
+  const bridge = {
+    suspend() {
+      if (suspended) return;
+      suspended = true;
+      for (const item of streams) {
+        if (item.stream.write === item.patched) item.stream.write = item.original;
+      }
+    },
+    resume() {
+      if (!suspended) return;
+      suspended = false;
+      for (const item of streams) {
+        if (item.stream.write === item.original) item.stream.write = item.patched;
+      }
+    },
+    restore() {
+      for (const item of streams) {
+        if (item.stream.write === item.patched) item.stream.write = item.original;
+      }
+      if (activeStreamBridge === bridge) activeStreamBridge = null;
+    }
+  };
+  for (const item of streams) item.stream.write = item.patched;
+  activeStreamBridge = bridge;
+  return bridge;
+}
+var processPresentationOutput = createProcessPresentationOutput({
+  onEvent(event) {
+    presentationEventBus.emit(event);
+  }
+});
+function writePresentationLine(text, eventType = "output.stdout") {
+  return processPresentationOutput.stdout(`${text}
+`, eventType);
+}
 
 // packages/cli/src/utils/update-check.ts
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawn } from "node:child_process";
 
+// packages/cli/src/tui/animations.ts
+function safeFrame(frame) {
+  if (!Number.isFinite(frame)) return 0;
+  const t = Math.trunc(frame);
+  return t < 0 ? 0 : t;
+}
+var SPINNER_PERIOD = 8;
+var TOAST_ENTER_FRAMES = 6;
+var TOAST_HOLD_FRAMES = 28;
+var TOAST_EXIT_FRAMES = 6;
+var TOAST_TOTAL_FRAMES = TOAST_ENTER_FRAMES + TOAST_HOLD_FRAMES + TOAST_EXIT_FRAMES;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827"];
+function spinnerFrame(frame, opts = {}) {
+  if (opts.reduceMotion) return 0;
+  return safeFrame(frame) % SPINNER_PERIOD;
+}
+function spinnerGlyph(frame, opts = {}) {
+  return SPINNER_FRAMES[spinnerFrame(frame, opts)] ?? SPINNER_FRAMES[0];
+}
+
 // packages/cli/src/utils/terminal-progress.ts
 function terminalProgress(label, output = process.stderr, reduceMotion = false) {
   const animated = Boolean(output.isTTY && process.env["TERM"] !== "dumb");
@@ -284,6 +501,11 @@ async function runStartupUpdate(version) {
 }
 
 export {
+  consolePresentationOutput,
+  installConsolePresentationBridge,
+  installProcessPresentationStreamBridge,
+  processPresentationOutput,
+  writePresentationLine,
   performAutoUpdate,
   runStartupUpdate
 };

package/chunks/{chunk-K74DRDC5.js → chunk-EHNVP6QB.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-O6KPVYOI.js";
 import {
   LlmApiRuntime
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-HS2NQ7K6.js";
 import {
   readCacheUsage
 } from "./chunk-RS4MAN3Q.js";

package/chunks/{chunk-I43YYHDU.js → chunk-FBZBJYZS.js}

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
+import {
+  buildShareUrl
+} from "./chunk-MNK373HF.js";
 import {
   source_default
 } from "./chunk-HLFS6WV2.js";
@@ -8,59 +11,14 @@ import {
   formatHtml,
   formatMarkdown,
   formatSarif
-} from "./chunk-H5QURBBK.js";
+} from "./chunk-YP2DHYNI.js";
 import {
   compareFindingsByBusinessPriority,
   createAuditReportDocument,
   createReviewReportDocument,
   createScanReportDocument,
   getFindingPriority
-} from "./chunk-GXXX7AGH.js";
-
-// packages/cli/src/utils.ts
-import { gzipSync } from "zlib";
-async function getRuntimeAvailability() {
-  const { detectAvailableRuntimes, LlmApiRuntime } = await import("./dist-TQMHMSBZ.js");
-  const apiRuntimeDiagnostics = new LlmApiRuntime({ type: "api", timeout: 5e3 }).getConfigurationDiagnostics();
-  const hasApiKey = apiRuntimeDiagnostics.valid;
-  const availableRuntimes = [...await detectAvailableRuntimes()];
-  return {
-    hasApiKey,
-    availableRuntimes,
-    apiRuntime: {
-      configured: apiRuntimeDiagnostics.reason !== "missing_key",
-      valid: apiRuntimeDiagnostics.valid,
-      providerLabel: apiRuntimeDiagnostics.providerLabel,
-      error: apiRuntimeDiagnostics.fatalError
-    }
-  };
-}
-async function checkRuntimeAvailability(runtime) {
-  const availability = await getRuntimeAvailability();
-  const { hasApiKey, availableRuntimes, apiRuntime } = availability;
-  if (hasApiKey) return;
-  console.log("");
-  if ((runtime === "api" || runtime === "auto") && apiRuntime.configured && apiRuntime.error) {
-    console.log(source_default.red(`  ${apiRuntime.providerLabel} config error: ${apiRuntime.error.split("\n")[0]}`));
-  }
-  if (runtime === "api") {
-    console.log(source_default.yellow(
-      apiRuntime.configured ? "  Warning: `--runtime api` needs a valid provider configuration. AI analysis will fail until this is fixed." : "  Warning: `--runtime api` needs provider credentials. AI analysis may be skipped."
-    ));
-  } else if (availableRuntimes.length > 0) {
-    console.log(source_default.cyan(`  Using local runtime(s): ${availableRuntimes.join(", ")}`));
-  } else {
-    console.log(source_default.yellow("  Warning: No API key or local agent runtime detected. AI analysis will be skipped."));
-  }
-  console.log(source_default.gray("  Provider credentials: ZERO_CHATGPT_ACCESS_TOKEN | ZERO_CHATGPT_OAUTH_REFRESH_TOKEN, OPENROUTER_API_KEY, ANTHROPIC_API_KEY, AZURE_OPENAI_API_KEY, OPENAI_API_KEY"));
-  console.log("");
-}
-function buildShareUrl(report) {
-  const json = JSON.stringify(report);
-  const compressed = gzipSync(Buffer.from(json, "utf-8"));
-  const b64 = compressed.toString("base64url");
-  return `https://0.security/r#${b64}`;
-}
+} from "./chunk-GYEYTNHK.js";
 
 // packages/cli/src/formatters/terminal.ts
 var SEVERITY_COUNT_COLOR = {
@@ -554,9 +512,6 @@ function formatReviewReport(report, format) {
 
 export {
   renderReplay,
-  getRuntimeAvailability,
-  checkRuntimeAvailability,
-  buildShareUrl,
   TIMELINE_FORMATS,
   isTimelineFormat,
   formatTimeline,