@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/chunk-GH37QXW5.js

@@ -0,0 +1,280 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/cli/web-subsystem.ts
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ExitCode } from "@cleocode/contracts";
+import { CleoError, getCleoHome } from "@cleocode/core";
+import { defineSubsystem } from "@cleocode/runtime/daemon";
+var WEB_DEFAULT_PORT = 3456;
+var WEB_DEFAULT_HOST = "127.0.0.1";
+var WEB_SUBSYSTEM_NAME = "cleo-web";
+var SIGTERM_GRACE_ITERATIONS = 60;
+var STARTUP_POLL_ITERATIONS = 30;
+function resolveStudioCheckout(moduleUrl) {
+  try {
+    const packageRoot = resolve(dirname(fileURLToPath(moduleUrl)), "..", "..");
+    const checkout = resolve(packageRoot, "..", "..");
+    if (packageRoot !== join(checkout, "packages", "cleo")) return void 0;
+    const markers = [
+      join(packageRoot, "src", "cli", "web-subsystem.ts"),
+      join(checkout, "pnpm-workspace.yaml"),
+      join(checkout, "build.mjs"),
+      join(checkout, "packages", "studio", "package.json"),
+      join(checkout, "packages", "studio", "src", "app.html")
+    ];
+    return markers.every((path) => statSync(path).isFile()) ? checkout : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveStudioDir(moduleUrl = import.meta.url) {
+  const envOverride = process.env["CLEO_STUDIO_DIR"];
+  if (envOverride !== void 0 && envOverride.length > 0 && existsSync(join(envOverride, "index.js"))) {
+    return envOverride;
+  }
+  try {
+    const pkgRoot = resolve(dirname(fileURLToPath(moduleUrl)), "..", "..");
+    const bundled = join(pkgRoot, "studio-dist");
+    if (existsSync(join(bundled, "index.js"))) {
+      return bundled;
+    }
+  } catch {
+  }
+  const checkout = resolveStudioCheckout(moduleUrl);
+  if (checkout) {
+    const devPath = join(checkout, "packages", "studio", "build");
+    if (existsSync(join(devPath, "index.js"))) return devPath;
+  }
+  return void 0;
+}
+function resolveStudioStaticDir() {
+  const buildDir = resolveStudioDir();
+  if (buildDir === void 0) return void 0;
+  const clientDir = join(buildDir, "client");
+  return existsSync(clientDir) ? clientDir : void 0;
+}
+function getWebPaths() {
+  const cleoHome = getCleoHome();
+  return {
+    pidFile: join(cleoHome, "web-server.pid"),
+    configFile: join(cleoHome, "web-server.json"),
+    logDir: join(cleoHome, "logs"),
+    logFile: join(cleoHome, "logs", "web-server.log")
+  };
+}
+function isWebProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getWebStatus() {
+  const { pidFile, configFile } = getWebPaths();
+  try {
+    const pidStr = (await readFile(pidFile, "utf-8")).trim();
+    const pid = Number.parseInt(pidStr, 10);
+    if (Number.isNaN(pid) || !isWebProcessRunning(pid)) {
+      return { running: false, pid: null, port: null, host: null, url: null };
+    }
+    let port = WEB_DEFAULT_PORT;
+    let host = WEB_DEFAULT_HOST;
+    try {
+      const config = JSON.parse(await readFile(configFile, "utf-8"));
+      port = config.port ?? WEB_DEFAULT_PORT;
+      host = config.host ?? WEB_DEFAULT_HOST;
+    } catch {
+    }
+    return { running: true, pid, port, host, url: `http://${host}:${port}` };
+  } catch {
+    return { running: false, pid: null, port: null, host: null, url: null };
+  }
+}
+function createWebSubsystem(opts = {}, moduleUrl = import.meta.url) {
+  const port = opts.port ?? WEB_DEFAULT_PORT;
+  const host = opts.host ?? WEB_DEFAULT_HOST;
+  let live;
+  return defineSubsystem({
+    name: WEB_SUBSYSTEM_NAME,
+    async start() {
+      const { pidFile, configFile, logFile, logDir } = getWebPaths();
+      const existing = await getWebStatus();
+      if (existing.running && existing.pid !== null) {
+        const ctx2 = {
+          pid: existing.pid,
+          pidFile,
+          logFile,
+          port: existing.port ?? port,
+          host: existing.host ?? host
+        };
+        live = ctx2;
+        return ctx2;
+      }
+      const resolvedStudioDir = resolveStudioDir(moduleUrl);
+      const checkout = resolveStudioCheckout(moduleUrl);
+      const studioDir = resolvedStudioDir ?? (checkout ? join(checkout, "packages", "studio", "build") : void 0);
+      if (!studioDir) {
+        throw new CleoError(
+          ExitCode.NOT_FOUND,
+          "Packaged Studio bundle is missing its index.js entry. Reinstall a complete CLEO package or set CLEO_STUDIO_DIR to a built Studio bundle."
+        );
+      }
+      const webIndexPath = join(studioDir, "index.js");
+      await mkdir(logDir, { recursive: true });
+      await writeFile(
+        configFile,
+        JSON.stringify({ port, host, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
+      );
+      try {
+        await stat(webIndexPath);
+      } catch {
+        if (!checkout || studioDir !== join(checkout, "packages", "studio", "build")) {
+          throw new CleoError(ExitCode.NOT_FOUND, `Studio entry is missing: ${webIndexPath}`);
+        }
+        try {
+          execFileSync("pnpm", ["--filter", "@cleocode/studio", "run", "build"], {
+            cwd: checkout,
+            stdio: "ignore",
+            timeout: 12e4
+          });
+        } catch {
+          throw new Error(
+            `Studio build failed. Run: pnpm --filter @cleocode/studio run build
+Logs: ${logFile}`
+          );
+        }
+        await stat(webIndexPath);
+      }
+      const logFileHandle = await open(logFile, "a");
+      const serverProcess = spawn("node", [webIndexPath], {
+        cwd: studioDir,
+        env: {
+          ...process.env,
+          HOST: host,
+          PORT: String(port),
+          CLEO_ROOT: process.env["CLEO_ROOT"] ?? process.cwd()
+        },
+        detached: true,
+        stdio: ["ignore", logFileHandle.fd, logFileHandle.fd]
+      });
+      serverProcess.unref();
+      const pidFileTmp = `${pidFile}.tmp`;
+      await writeFile(pidFileTmp, String(serverProcess.pid));
+      await rm(pidFile, { force: true });
+      await writeFile(pidFile, String(serverProcess.pid));
+      await rm(pidFileTmp, { force: true });
+      await logFileHandle.close();
+      let started = false;
+      for (let i = 0; i < STARTUP_POLL_ITERATIONS; i++) {
+        try {
+          const response = await fetch(`http://${host}:${port}/api/health`);
+          if (response.ok) {
+            started = true;
+            break;
+          }
+        } catch {
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+      }
+      if (!started) {
+        try {
+          process.kill(serverProcess.pid, "SIGTERM");
+        } catch {
+        }
+        await rm(pidFile, { force: true });
+        throw new Error("Studio web server failed to start within 15 seconds");
+      }
+      const ctx = {
+        pid: serverProcess.pid,
+        pidFile,
+        logFile,
+        port,
+        host
+      };
+      live = ctx;
+      return ctx;
+    },
+    healthProbe() {
+      if (live === void 0) {
+        const stopped = "stopped";
+        return {
+          child_id: WEB_SUBSYSTEM_NAME,
+          pid: 0,
+          state: stopped,
+          restart_count: 0,
+          detail: "not started"
+        };
+      }
+      const alive = isWebProcessRunning(live.pid);
+      const state = alive ? "running" : "stopped";
+      return {
+        child_id: WEB_SUBSYSTEM_NAME,
+        pid: alive ? live.pid : 0,
+        state,
+        restart_count: 0,
+        detail: alive ? `url=http://${live.host}:${live.port} pid=${live.pid}` : `pid=${live.pid} exited`
+      };
+    },
+    async shutdown(context) {
+      const { pidFile } = context;
+      if (!isWebProcessRunning(context.pid)) {
+        await rm(pidFile, { force: true });
+        live = void 0;
+        return;
+      }
+      try {
+        if (process.platform === "win32") {
+          spawn("taskkill", ["/PID", String(context.pid), "/T"], { stdio: "ignore" });
+        } else {
+          process.kill(context.pid, "SIGTERM");
+        }
+      } catch {
+      }
+      for (let i = 0; i < SIGTERM_GRACE_ITERATIONS; i++) {
+        if (!isWebProcessRunning(context.pid)) break;
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+      }
+      if (isWebProcessRunning(context.pid)) {
+        try {
+          if (process.platform === "win32") {
+            spawn("taskkill", ["/PID", String(context.pid), "/F", "/T"], { stdio: "ignore" });
+          } else {
+            process.kill(context.pid, "SIGKILL");
+          }
+        } catch {
+        }
+      }
+      await rm(pidFile, { force: true });
+      live = void 0;
+    }
+  });
+}
+
+export {
+  WEB_DEFAULT_PORT,
+  WEB_DEFAULT_HOST,
+  resolveStudioStaticDir,
+  getWebPaths,
+  getWebStatus,
+  createWebSubsystem
+};
+//# sourceMappingURL=chunk-GH37QXW5.js.map

package/dist/cli/chunk-GZFVDR44.js

@@ -0,0 +1,320 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/cli/lib/readline-wizard-io.ts
+import { stdin as input, stdout as output } from "node:process";
+import * as readline from "node:readline/promises";
+import { Writable } from "node:stream";
+import { WizardFatalError, WizardInterruptError } from "@cleocode/core/setup";
+function stripBracketedPaste(raw) {
+  return raw.replace(/\x1b\[200~/g, "").replace(/\x1b\[201~/g, "").trim();
+}
+var SETUP_STDIN_CLOSED_CODE = "E_SETUP_STDIN_CLOSED";
+var StdinClosedError = class _StdinClosedError extends WizardFatalError {
+  codeName = SETUP_STDIN_CLOSED_CODE;
+  constructor() {
+    super("stdin closed before section completed");
+    this.name = "StdinClosedError";
+  }
+  /**
+   * Type-guard so callers can identify this error without `instanceof`.
+   *
+   * @param err - Value caught from a `catch` block.
+   */
+  static is(err) {
+    return err instanceof _StdinClosedError;
+  }
+};
+var SECRET_ECHO_REFUSED_MESSAGE = 'Refusing to read a secret: stdin is a terminal but terminal mode is off, so the key would be echoed. Pipe it instead: printf %s "$KEY" | cleo decide config --provider layahost --key-stdin (or cleo llm add <provider> --api-key-stdin).';
+var SECRET_MASK_CHAR = "\u2022";
+function streamIsTTY(stream) {
+  return "isTTY" in stream && stream.isTTY === true;
+}
+var MutableOutput = class extends Writable {
+  /** @param target - Stream that receives writes while unmuted. */
+  constructor(target) {
+    super();
+    this.target = target;
+    this.isTTY = "isTTY" in target && target.isTTY === true;
+  }
+  target;
+  /** When true, writes are dropped. */
+  muted = false;
+  /** Mirrors the wrapped stream: readline enables terminal mode (and echo) from it. */
+  isTTY;
+  /** Terminal width of the wrapped stream, when it reports one. */
+  get columns() {
+    return "columns" in this.target && typeof this.target.columns === "number" ? this.target.columns : void 0;
+  }
+  /** Forward a chunk unless muted. */
+  _write(chunk, encoding, callback) {
+    if (this.muted) {
+      callback();
+      return;
+    }
+    const done = () => callback();
+    if (typeof chunk === "string") this.target.write(chunk, encoding, done);
+    else this.target.write(chunk, done);
+  }
+  /** Write straight to the wrapped stream, bypassing the mute. */
+  writeUnmuted(text) {
+    this.target.write(text);
+  }
+};
+var ReadlineWizardIO = class {
+  /**
+   * Underlying readline interface.
+   *
+   * Exposed as `protected` (not `private`) so tests can emit `'SIGINT'` on it
+   * to simulate Ctrl-C without requiring a real TTY. Production code MUST NOT
+   * access this field directly.
+   *
+   * @internal
+   */
+  rl;
+  /** The stream readline echoes into; muted while a secret is typed. */
+  output;
+  /** Whether the input stream is a TTY (the terminal echoes unless readline owns it). */
+  inputIsTTY;
+  /** The input stream (its keypress events drive the secret mask). */
+  inStream;
+  /** AbortController aborted when stdin closes — surfaced as {@link StdinClosedError}. */
+  eofController;
+  /**
+   * Whether a SIGINT was received. Set before throwing so `rethrowEof` does
+   * not mistakenly wrap the AbortError as a `StdinClosedError`.
+   */
+  sigintReceived = false;
+  /**
+   * Construct a readline interface bound to the supplied streams.
+   *
+   * The defaults (`process.stdin` / `process.stdout`) are correct for
+   * production use; tests inject in-memory streams.
+   *
+   * @param inStream - Input stream; defaults to `process.stdin`.
+   * @param outStream - Output stream passed to readline for terminal-echo
+   *   purposes only; informational output goes to stderr. CLI commands pass
+   *   `process.stderr` so prompts never reach a redirected stdout.
+   * @param options - See {@link ReadlineWizardIOOptions}; terminal mode
+   *   defaults to the input stream's `isTTY`.
+   */
+  constructor(inStream = input, outStream = output, options = {}) {
+    this.eofController = new AbortController();
+    this.output = new MutableOutput(outStream);
+    this.inStream = inStream;
+    this.inputIsTTY = streamIsTTY(inStream);
+    this.rl = readline.createInterface({
+      input: inStream,
+      output: this.output,
+      terminal: options.terminal ?? this.inputIsTTY,
+      // No history: a secret must never be recallable with Up-arrow.
+      historySize: 0
+    });
+    this.rl.on("close", () => {
+      if (!this.eofController.signal.aborted) {
+        this.eofController.abort(new StdinClosedError());
+      }
+    });
+    this.rl.on("SIGINT", () => {
+      this.sigintReceived = true;
+      if (!this.eofController.signal.aborted) {
+        this.eofController.abort(new WizardInterruptError("interrupted by user"));
+      }
+    });
+  }
+  /**
+   * Release the underlying readline interface.
+   *
+   * Safe to call multiple times — `readline.Interface.close()` is
+   * idempotent.
+   */
+  close() {
+    this.rl.close();
+  }
+  /**
+   * Wrap an AbortError thrown by `rl.question()` into the appropriate
+   * typed error.
+   *
+   * - SIGINT received → throw {@link WizardInterruptError}
+   * - Stdin EOF → throw {@link StdinClosedError}
+   * - Any other error → re-throw as-is.
+   *
+   * @internal
+   */
+  rethrowEof(err) {
+    if (err instanceof Error && (err.name === "AbortError" || err.name === "AbortSignal") && this.eofController.signal.aborted) {
+      if (this.sigintReceived) {
+        throw new WizardInterruptError("interrupted by user");
+      }
+      throw new StdinClosedError();
+    }
+    throw err;
+  }
+  async prompt(question) {
+    try {
+      const raw = await this.rl.question(`${question} `, {
+        signal: this.eofController.signal
+      });
+      return stripBracketedPaste(raw);
+    } catch (err) {
+      this.rethrowEof(err);
+    }
+  }
+  /**
+   * Ask for a secret without echoing it: the question is written, then the
+   * output stream is muted until the answer is submitted. Bracketed-paste
+   * markers are stripped like {@link prompt}. The answer is removed from
+   * readline's history afterwards.
+   *
+   * @param question - The question, e.g. `API key:`.
+   * @returns The trimmed answer; `''` when none was given.
+   * @throws Error with {@link SECRET_ECHO_REFUSED_MESSAGE} when stdin is a
+   *   terminal but terminal mode is off (the terminal would echo the key).
+   * @task T12714
+   */
+  async secret(question) {
+    if (this.inputIsTTY && !this.rl.terminal) throw new Error(SECRET_ECHO_REFUSED_MESSAGE);
+    this.output.writeUnmuted(`${question} `);
+    this.output.muted = true;
+    const stopMask = this.echoMask();
+    let raw;
+    try {
+      raw = await this.rl.question("", { signal: this.eofController.signal });
+      return stripBracketedPaste(raw);
+    } catch (err) {
+      return this.rethrowEof(err);
+    } finally {
+      stopMask();
+      this.output.muted = false;
+      this.output.writeUnmuted("\n");
+      if (raw !== void 0) this.scrubHistory(raw);
+    }
+  }
+  /**
+   * While a secret is typed (readline's echo muted), echo one
+   * {@link SECRET_MASK_CHAR} per character in the line and erase one per
+   * deleted character. Runs after readline's own keypress handler (registered
+   * first), so `rl.line` is already updated; only its LENGTH is read. The
+   * submitting key (Enter) is ignored, since readline clears the line then.
+   *
+   * @returns A function that stops the echo.
+   */
+  echoMask() {
+    if (!this.rl.terminal) return () => {
+    };
+    let shown = 0;
+    const onKeypress = (_str, key) => {
+      if (key?.name === "return" || key?.name === "enter") return;
+      const length = this.rl.line.length;
+      if (length > shown) this.output.writeUnmuted(SECRET_MASK_CHAR.repeat(length - shown));
+      else if (length < shown) this.output.writeUnmuted("\b \b".repeat(shown - length));
+      shown = length;
+    };
+    this.inStream.on("keypress", onKeypress);
+    return () => {
+      this.inStream.off("keypress", onKeypress);
+    };
+  }
+  /**
+   * Remove every history entry equal to `line`. `history` is a runtime field
+   * of `readline.Interface` that `@types/node` does not declare, so it is
+   * read reflectively and checked before use.
+   *
+   * @param line - The exact line readline recorded.
+   */
+  scrubHistory(line) {
+    const history = Reflect.get(this.rl, "history");
+    if (!Array.isArray(history)) return;
+    for (let i = history.length - 1; i >= 0; i--) {
+      if (history[i] === line) history.splice(i, 1);
+    }
+  }
+  async confirm(question, defaultValue) {
+    const hint = defaultValue === void 0 ? "[y/n]" : defaultValue ? "[Y/n]" : "[y/N]";
+    let raw;
+    try {
+      raw = stripBracketedPaste(
+        await this.rl.question(`${question} ${hint} `, { signal: this.eofController.signal })
+      ).toLowerCase();
+    } catch (err) {
+      this.rethrowEof(err);
+    }
+    if (raw === "") {
+      if (defaultValue === void 0) {
+        return this.confirm(question, defaultValue);
+      }
+      return defaultValue;
+    }
+    if (raw === "y" || raw === "yes") return true;
+    if (raw === "n" || raw === "no") return false;
+    return this.confirm(question, defaultValue);
+  }
+  async select(question, options) {
+    if (options.length === 0) {
+      throw new Error(`ReadlineWizardIO.select: option list is empty for '${question}'`);
+    }
+    process.stderr.write(`${question}
+`);
+    options.forEach((opt, idx) => {
+      process.stderr.write(`  ${idx + 1}) ${opt}
+`);
+    });
+    const MAX_RETRIES = 10;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      let raw;
+      try {
+        raw = stripBracketedPaste(
+          await this.rl.question(`Choose [1-${options.length}]: `, {
+            signal: this.eofController.signal
+          })
+        );
+      } catch (err) {
+        this.rethrowEof(err);
+      }
+      if (/^\d+$/.test(raw)) {
+        const idx = Number.parseInt(raw, 10) - 1;
+        if (idx >= 0 && idx < options.length) return options[idx];
+      }
+      if (options.includes(raw)) return raw;
+      process.stderr.write(`Invalid choice '${raw}'. Try again.
+`);
+    }
+    throw new Error(
+      `ReadlineWizardIO.select: gave up after ${MAX_RETRIES} invalid responses for '${question}'`
+    );
+  }
+  /** Informational message — goes to stderr, never stdout. */
+  info(message) {
+    process.stderr.write(`${message}
+`);
+  }
+  /** Non-fatal warning — goes to stderr. */
+  warn(message) {
+    process.stderr.write(`${message}
+`);
+  }
+  /** Error message — goes to stderr. */
+  error(message) {
+    process.stderr.write(`${message}
+`);
+  }
+};
+
+export {
+  StdinClosedError,
+  ReadlineWizardIO
+};
+//# sourceMappingURL=chunk-GZFVDR44.js.map