@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/chunk-GAGUBU4Z.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/exit-codes.js";
+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-GAGUBU4Z.js.map

package/dist/cli/chunk-GKRFH2YG.js

@@ -0,0 +1,171 @@
+(() => {
+  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);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-twin-collapse.ts
+import {
+  inspectProjectTwinCollapse,
+  recoverTwinCollapse,
+  releaseProjectTwinCollapseSnapshot,
+  retryTwinCollapse,
+  rollbackTwinCollapse
+} from "@cleocode/core/doctor/twin-collapse.js";
+import { CleoError } from "@cleocode/core/errors";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorTwinCollapseCommand = defineCommand({
+  meta: {
+    name: "twin-collapse",
+    description: "Report the twin collapses (bare schema_meta / sticky_tags kept in step with their prefixed twins): state, last failure, snapshot path and space needed. --retry re-runs them; --recover restores what 2026.9.21 dropped; --release-snapshot lets a checked snapshot rotate."
+  },
+  args: {
+    retry: {
+      type: "boolean",
+      description: "Run the collapse once now (after clearing the reported cause)"
+    },
+    recover: {
+      type: "boolean",
+      description: "Restore twin values a 2026.9.21 collapse dropped or replaced, from its pinned pre-collapse snapshot, into twin_collapse_archive:* (T12727). Combine with --dry-run"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --recover: print the plan, write nothing"
+    },
+    "pin-snapshot": {
+      type: "boolean",
+      description: "With --recover: pin an unpinned pre-collapse snapshot (its .meta.json sidecar only) before applying"
+    },
+    rollback: {
+      type: "string",
+      description: "Undo one --recover apply by its receipt id (twin_collapse_recovery:<recoveredAt>)"
+    },
+    "release-snapshot": {
+      type: "string",
+      description: "Release a pre-collapse snapshot (backup id, e.g. migration-20260928-153200) after a verified recovery or a no-recovery-needed check, so it rotates normally. Needs --confirm; --dry-run shows the bytes reclaimed"
+    },
+    confirm: {
+      type: "boolean",
+      description: "With --release-snapshot: the owner's decision to release (obtained by the calling agent; the CLI never prompts)"
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From a git worktree: allow --recover, --rollback or --retry to write the owning project's live store"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const projectRoot = getProjectRoot();
+    const guard = { cwd: process.cwd(), confirmOwnerStore: args["confirm-owner-store"] === true };
+    const actions = twinCollapseActions(args);
+    if (actions.length > 1) {
+      cliError(
+        `E_INVALID_INPUT: ${actions.join(" and ")} are separate actions; run them one at a time (--recover before --release-snapshot)`,
+        "E_INVALID_INPUT",
+        { name: "Error", fix: "cleo doctor twin-collapse --recover --dry-run" }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      if (typeof args.rollback === "string" && args.rollback.length > 0) {
+        const result = await rollbackTwinCollapse(projectRoot, args.rollback, guard);
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.rollback" }
+        );
+        return;
+      }
+      if (typeof args["release-snapshot"] === "string" && args["release-snapshot"].length > 0) {
+        const result = await releaseProjectTwinCollapseSnapshot(
+          projectRoot,
+          args["release-snapshot"],
+          {
+            ...guard,
+            dryRun: args["dry-run"] === true,
+            confirm: args.confirm === true
+          }
+        );
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.release-snapshot" }
+        );
+        return;
+      }
+      if (args.recover === true) {
+        const result = await recoverTwinCollapse(projectRoot, {
+          ...guard,
+          dryRun: args["dry-run"] === true,
+          pinSnapshot: args["pin-snapshot"] === true
+        });
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.recover" }
+        );
+        return;
+      }
+      if (args.retry === true) {
+        const receipts = await retryTwinCollapse(projectRoot, guard);
+        cliOutput(
+          { kind: "generic", receipts },
+          { command: "doctor", operation: "doctor.twin-collapse.retry" }
+        );
+        return;
+      }
+    } catch (error) {
+      reportTwinCollapseError(error, args.retry === true);
+      return;
+    }
+    const report = inspectProjectTwinCollapse(projectRoot);
+    cliOutput(report, { command: "doctor", operation: "doctor.twin-collapse.run" });
+    const failed = report.pairs.some((p) => p.state === "failed") || report.preflight?.ok === false;
+    if (failed && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+function reportTwinCollapseError(error, retry) {
+  if (retry && !(error instanceof CleoError)) throw error;
+  const message = error instanceof Error ? error.message : String(error);
+  const named = /^(E_[A-Z_]+):/.exec(message)?.[1];
+  const code = named ?? (retry ? "E_TWIN_COLLAPSE_FAILED" : "E_TWIN_COLLAPSE_RECOVER");
+  cliError(message, code, {
+    name: error instanceof CleoError ? "CleoError" : "Error",
+    fix: error instanceof CleoError ? error.fix : void 0,
+    details: error instanceof CleoError ? error.details : void 0
+  });
+  process.exitCode = error instanceof CleoError ? error.code : 1;
+}
+function twinCollapseActions(args) {
+  const named = (key) => typeof args[key] === "string" && args[key].length > 0;
+  return [
+    args.recover === true ? "--recover" : "",
+    named("release-snapshot") ? "--release-snapshot" : "",
+    named("rollback") ? "--rollback" : "",
+    args.retry === true ? "--retry" : ""
+  ].filter(Boolean);
+}
+
+export {
+  doctorTwinCollapseCommand
+};
+//# sourceMappingURL=chunk-GKRFH2YG.js.map