0sec-cli 0.22.1 → 0.22.4

package/chunks/chunk-FFHRANYC.js

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+import {
+  SETTING_DEFS,
+  isOperatorSetting,
+  loadGlobalSettings,
+  loadLayeredSettings,
+  normalizeSettings,
+  projectSettingsExist,
+  readProjectOverrides,
+  resolveLayeredSettings,
+  saveProjectOverrides,
+  saveSettings
+} from "./chunk-XODDLNBI.js";
+import {
+  expandHomePath,
+  isExistingLocalTargetPath,
+  isExplicitLocalTargetPath
+} from "./chunk-GVY3S5E5.js";
+import {
+  ANALYTICS_LEVEL_ENV,
+  analyticsOptedOut,
+  analyticsPipeline,
+  levelAtLeast,
+  resolveAnalyticsLevel
+} from "./chunk-2WWAPKAW.js";
+import {
+  createPresentationEvent
+} from "./chunk-6KFB6AYN.js";
+
+// packages/cli/src/tui/settings-store.ts
+import { useSyncExternalStore } from "react";
+var cached = null;
+var globalDraft = null;
+var projectDraft = null;
+var homeDir;
+var projectDir;
+var subscribers = /* @__PURE__ */ new Set();
+function notify(settings) {
+  bridgeAnalyticsLevel(settings);
+  for (const fn of [...subscribers]) {
+    try {
+      fn(settings);
+    } catch {
+    }
+  }
+}
+function loadLayered() {
+  return globalDraft === null && projectDraft === null ? loadLayeredSettings({ homeDir, projectDir }) : resolveLayeredSettings(globalDraft ?? loadGlobalSettings(homeDir), projectDraft ?? readProjectOverrides(projectDir));
+}
+function getSettings() {
+  if (cached === null) {
+    cached = loadLayered();
+    bridgeAnalyticsLevel(cached.settings);
+  }
+  return cached.settings;
+}
+function getSettingSources() {
+  getSettings();
+  return cached.sources;
+}
+function getAnalyticsSetupDraft() {
+  const settings = getSettings();
+  const current = process.env[ANALYTICS_LEVEL_ENV];
+  const shellPreference = current !== void 0 && current !== bridgedAnalyticsEnv;
+  if (analyticsOptedOut() || shellPreference && resolveAnalyticsLevel() === "off") return "off";
+  return cached.sources.analyticsLevel === "default" ? "usage" : settings.analyticsLevel;
+}
+function setSettings(next) {
+  const value = normalizeSettings(next);
+  const saved = saveSettings(value, homeDir);
+  globalDraft = saved ? null : value;
+  cached = loadLayered();
+  notify(cached.settings);
+  return saved;
+}
+function defaultWriteLayer() {
+  return projectSettingsExist(projectDir) ? "project" : "global";
+}
+function updateSetting(key, value, opts = {}) {
+  const operatorOnly = isOperatorSetting(key);
+  if (operatorOnly && opts.scope === "project") return false;
+  const layer = operatorOnly ? "global" : opts.scope ?? defaultWriteLayer();
+  if (layer === "global") {
+    return setSettings({ ...globalDraft ?? loadGlobalSettings(homeDir), [key]: value });
+  }
+  const patch = { ...projectDraft ?? readProjectOverrides(projectDir), [key]: value };
+  const saved = saveProjectOverrides(patch, projectDir);
+  projectDraft = saved ? null : patch;
+  cached = loadLayered();
+  notify(cached.settings);
+  return saved;
+}
+function resetSettings(next, keys) {
+  const selected = keys.filter((key) => SETTING_DEFS.some((def) => def.key === key));
+  if (selected.length === 0) return true;
+  const global = { ...globalDraft ?? loadGlobalSettings(homeDir) };
+  const project = { ...projectDraft ?? readProjectOverrides(projectDir) };
+  let projectChanged = false;
+  for (const key of selected) {
+    global[key] = next[key];
+    if (Object.hasOwn(project, key)) {
+      delete project[key];
+      projectChanged = true;
+    }
+  }
+  const value = normalizeSettings(global);
+  const globalSaved = saveSettings(value, homeDir);
+  globalDraft = globalSaved ? null : value;
+  const projectSaved = !projectChanged || saveProjectOverrides(project, projectDir);
+  if (projectChanged) projectDraft = projectSaved ? null : project;
+  cached = loadLayered();
+  notify(cached.settings);
+  return globalSaved && projectSaved;
+}
+function previewSetting(key, value) {
+  if (cached === null) cached = loadLayered();
+  cached = { settings: { ...cached.settings, [key]: value }, sources: cached.sources };
+  notify(cached.settings);
+}
+function subscribeSettings(fn) {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+var bridgedAnalyticsEnv;
+function bridgeAnalyticsLevel(settings) {
+  try {
+    const current = process.env[ANALYTICS_LEVEL_ENV];
+    if (current === void 0 || current === bridgedAnalyticsEnv) {
+      process.env[ANALYTICS_LEVEL_ENV] = settings.analyticsLevel;
+      bridgedAnalyticsEnv = settings.analyticsLevel;
+    } else {
+      bridgedAnalyticsEnv = void 0;
+    }
+    const environmentLevel = resolveAnalyticsLevel();
+    analyticsPipeline.setLevel(levelAtLeast(environmentLevel, settings.analyticsLevel) ? settings.analyticsLevel : environmentLevel);
+  } catch {
+  }
+}
+function reloadSettings() {
+  globalDraft = null;
+  projectDraft = null;
+  cached = loadLayered();
+  notify(cached.settings);
+  return cached.settings;
+}
+function configureSettingsStore(options) {
+  homeDir = options.homeDir;
+  projectDir = options.projectDir;
+  reloadSettings();
+}
+function useSettings() {
+  return useSyncExternalStore(subscribeSettings, getSettings, getSettings);
+}
+
+// packages/cli/src/codex-auth.ts
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var AUTH_FILE_ENV = "ZERO_CHATGPT_AUTH_FILE";
+var LEGACY_AUTH_FILE_ENV = "ZERO_CODEX_AUTH_JSON_PATH";
+function maybeLoadCodexAuth(options = {}) {
+  const env = options.env ?? process.env;
+  if (!options.force && (env["ZERO_CHATGPT_ACCESS_TOKEN"] || env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"])) {
+    return;
+  }
+  const home = options.home ?? homedir();
+  const override = nonEmpty(env[AUTH_FILE_ENV]) ?? nonEmpty(env[LEGACY_AUTH_FILE_ENV]);
+  const path = override ?? join(home, ".codex", "auth.json");
+  if (!existsSync(path)) return;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const accessToken = nonEmpty(asString(raw.tokens?.access_token));
+    const refreshToken = nonEmpty(asString(raw.tokens?.refresh_token));
+    if (!accessToken && !refreshToken) return;
+    if (options.force) {
+      delete env["ZERO_CHATGPT_ACCESS_TOKEN"];
+      delete env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"];
+    }
+    if (accessToken) {
+      env["ZERO_CHATGPT_ACCESS_TOKEN"] = accessToken;
+    }
+    if (refreshToken) {
+      env["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"] = refreshToken;
+    }
+  } catch {
+  }
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// packages/cli/src/presentation/event-bus.ts
+var PresentationEventBus = class {
+  listeners = [];
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index >= 0) this.listeners.splice(index, 1);
+    };
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener.emit(event);
+      } catch {
+      }
+    }
+  }
+  get size() {
+    return this.listeners.length;
+  }
+};
+var presentationEventBus = new PresentationEventBus();
+function createPresentationEmitter(options = {}) {
+  const source = options.source ?? "cli";
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const bus = options.bus ?? presentationEventBus;
+  let sequence = 0;
+  return {
+    emit(eventType, payload, correlation = {}) {
+      const event = createPresentationEvent({
+        source,
+        sequence: ++sequence,
+        at: now(),
+        eventType,
+        payload,
+        ...correlation.scanId ? { scanId: correlation.scanId } : {},
+        ...correlation.sessionId ? { sessionId: correlation.sessionId } : {}
+      });
+      bus.emit(event);
+      return event;
+    }
+  };
+}
+
+// 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;
+}
+function suspendProcessPresentationStreamBridge() {
+  activeStreamBridge?.suspend();
+}
+function resumeProcessPresentationStreamBridge() {
+  activeStreamBridge?.resume();
+}
+var processPresentationOutput = createProcessPresentationOutput({
+  onEvent(event) {
+    presentationEventBus.emit(event);
+  }
+});
+function writePresentationLine(text, eventType = "output.stdout") {
+  return processPresentationOutput.stdout(`${text}
+`, eventType);
+}
+
+// packages/cli/src/engagement-plan.ts
+var PACKAGE_PREFIXES = {
+  "npm:": { ecosystem: "npm", targetType: "npm-package" },
+  "pypi:": { ecosystem: "pypi", targetType: "pypi-package" },
+  "cargo:": { ecosystem: "cargo", targetType: "cargo-package" },
+  "oci:": { ecosystem: "oci", targetType: "oci-image" }
+};
+function resolveEngagement(rawTarget) {
+  const raw = rawTarget.trim();
+  if (raw.length === 0) return { ok: false, message: "Enter a URL, source path, git URL, or ecosystem-prefixed package." };
+  for (const [prefix, packagePlan] of Object.entries(PACKAGE_PREFIXES)) {
+    if (!raw.startsWith(prefix)) continue;
+    const target = raw.slice(prefix.length).trim();
+    if (target.length === 0) return { ok: false, message: `${prefix} requires a package name.` };
+    return {
+      ok: true,
+      plan: {
+        kind: "package",
+        target,
+        targetType: packagePlan.targetType,
+        ecosystem: packagePlan.ecosystem,
+        label: `${packagePlan.ecosystem} package ${target}`
+      }
+    };
+  }
+  if (raw.startsWith("source:")) {
+    const target = raw.slice("source:".length).trim();
+    if (target.length === 0) return { ok: false, message: "source: requires a local path or git URL." };
+    return {
+      ok: true,
+      plan: {
+        kind: "source",
+        target: expandHomePath(target),
+        targetType: "source-code",
+        label: `source review ${target}`
+      }
+    };
+  }
+  if (raw.startsWith("git@") || raw.startsWith("git://") || raw.endsWith(".git") || raw.startsWith("https://github.com/")) {
+    return {
+      ok: true,
+      plan: {
+        kind: "source",
+        target: raw,
+        targetType: "source-code",
+        label: `source review ${raw}`
+      }
+    };
+  }
+  if (raw.startsWith("mcp://") || raw.startsWith("http://") || raw.startsWith("https://")) {
+    return {
+      ok: true,
+      plan: {
+        kind: "web",
+        target: raw,
+        targetType: "url",
+        label: `web target ${raw}`
+      }
+    };
+  }
+  if (isExplicitLocalTargetPath(raw) || isExistingLocalTargetPath(raw)) {
+    const target = expandHomePath(raw);
+    return {
+      ok: true,
+      plan: {
+        kind: "source",
+        target,
+        targetType: "source-code",
+        label: `source review ${target}`
+      }
+    };
+  }
+  return {
+    ok: false,
+    message: "Ambiguous target. Use https://\u2026, ./path, source:\u2026, npm:\u2026, pypi:\u2026, cargo:\u2026, or oci:\u2026."
+  };
+}
+
+export {
+  getSettings,
+  getSettingSources,
+  getAnalyticsSetupDraft,
+  defaultWriteLayer,
+  updateSetting,
+  resetSettings,
+  previewSetting,
+  subscribeSettings,
+  reloadSettings,
+  configureSettingsStore,
+  useSettings,
+  maybeLoadCodexAuth,
+  presentationEventBus,
+  createPresentationEmitter,
+  consolePresentationOutput,
+  installConsolePresentationBridge,
+  installProcessPresentationStreamBridge,
+  suspendProcessPresentationStreamBridge,
+  resumeProcessPresentationStreamBridge,
+  processPresentationOutput,
+  writePresentationLine,
+  resolveEngagement
+};

package/chunks/{chunk-WSDDGFA6.js → chunk-G2BE2FC7.js}

@@ -5,7 +5,7 @@ import {
   CODEX_CLIENT_VERSION,
   CODEX_PROTOCOL_HEADERS,
   getChatGptCodexAccessToken
-} from "./chunk-AV2LG2L7.js";
+} from "./chunk-QVIRWJ45.js";
 
 // packages/core/dist/runtime/codex-models.js
 import { createHash } from "node:crypto";