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

package/dist/cli/chunk-EW2CKNNZ.js

@@ -0,0 +1,304 @@
+(() => {
+  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/update-notice.ts
+import { spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  utimesSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getCleoStateDir } from "@cleocode/paths";
+var CLEO_PACKAGE_NAME = "@cleocode/cleo";
+var UPDATE_NOTICE_OPT_OUT_ENV = "CLEO_NO_UPDATE_NOTICE";
+var UPDATE_NOTICE_FROM_SOURCE_ENV = "CLEO_UPDATE_NOTICE_FROM_SOURCE";
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_CHECK_RETRY_MS = 60 * 60 * 1e3;
+var UPDATE_NOTICE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_CHECK_LOCK_STALE_MS = 10 * 60 * 1e3;
+var UPDATE_CACHE_FILE = "update-check.json";
+var UPDATE_LOCK_FILE = "update-check.lock";
+var UPDATE_NOTICE_STAMP_FILE = "update-notice.stamp";
+var HOTFIX_NOTICE_INTERVAL_MS = 15 * 60 * 1e3;
+var HOTFIX_NOTICE_STAMP_FILE = "update-notice-hotfix.stamp";
+var UPDATE_CHECK_ENTRY = "update-check-entry.js";
+var CI_ENV_VARS = [
+  "CI",
+  "CONTINUOUS_INTEGRATION",
+  "GITHUB_ACTIONS",
+  "GITLAB_CI",
+  "BUILDKITE",
+  "CIRCLECI",
+  "TF_BUILD",
+  "JENKINS_URL",
+  "TEAMCITY_VERSION",
+  "TRAVIS",
+  "APPVEYOR",
+  "CODEBUILD_BUILD_ID",
+  "BITBUCKET_BUILD_NUMBER",
+  "DRONE"
+];
+var VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
+function flagSet(value) {
+  if (value === void 0) return false;
+  const v = value.trim().toLowerCase();
+  return v !== "" && v !== "0" && v !== "false";
+}
+function isCiEnvironment(env) {
+  return CI_ENV_VARS.some((name) => flagSet(env[name]));
+}
+function parseVersion(version) {
+  const m = VERSION_RE.exec(version.trim());
+  if (!m) return null;
+  return {
+    core: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] === void 0 ? [] : m[4].split(".")
+  };
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 || b.length === 0) return b.length - a.length;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    const x = a[i] ?? "";
+    const y = b[i] ?? "";
+    if (x === y) continue;
+    const xNum = /^\d+$/.test(x);
+    const yNum = /^\d+$/.test(y);
+    if (xNum && yNum) return Number(x) < Number(y) ? -1 : 1;
+    if (xNum !== yNum) return xNum ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  return Math.sign(a.length - b.length);
+}
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return null;
+  for (let i = 0; i < 3; i++) {
+    const x = pa.core[i] ?? 0;
+    const y = pb.core[i] ?? 0;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  const pre = comparePrerelease(pa.pre, pb.pre);
+  return pre === 0 ? 0 : pre < 0 ? -1 : 1;
+}
+function releaseChannelTag(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) return null;
+  if (parsed.pre.length === 0) return "latest";
+  const tag = (parsed.pre[0] ?? "").toLowerCase();
+  if (tag.startsWith("beta") || tag.startsWith("rc")) return "beta";
+  return null;
+}
+function decideUpdateNotice(installed, distTags, hotfix) {
+  const channel = releaseChannelTag(installed);
+  if (channel === null) return null;
+  const target = distTags[channel];
+  if (target === void 0 || compareVersions(target, installed) !== 1) return null;
+  if (hotfix !== void 0 && compareVersions(hotfix, installed) === 1 && (compareVersions(hotfix, target) ?? 1) <= 0) {
+    return { kind: "hotfix", installed, target, hotfix };
+  }
+  return { kind: "update", installed, target };
+}
+function formatUpdateNotice(notice) {
+  const hide = `Set ${UPDATE_NOTICE_OPT_OUT_ENV}=1 to hide this.`;
+  if (notice.kind === "update") {
+    return `[cleo] Update available: ${notice.target} (installed ${notice.installed}). Run \`cleo self-update\`. ${hide}
+`;
+  }
+  const release = notice.hotfix === notice.target ? `${notice.target} is a hotfix release` : `${notice.target} includes hotfix release ${notice.hotfix}`;
+  return `[cleo] HOTFIX available: ${release} for a defect in your installed ${notice.installed}. Run \`cleo self-update\` now. ${hide}
+`;
+}
+function updateNoticeSuppression(argv, env, installedPackage) {
+  if (flagSet(env[UPDATE_NOTICE_OPT_OUT_ENV])) return UPDATE_NOTICE_OPT_OUT_ENV;
+  if (flagSet(env.NO_UPDATE_NOTIFIER)) return "NO_UPDATE_NOTIFIER";
+  if (isCiEnvironment(env)) return "ci";
+  if (!installedPackage && !flagSet(env[UPDATE_NOTICE_FROM_SOURCE_ENV])) return "source-checkout";
+  const command = argv.find((a) => !a.startsWith("-"));
+  if (command === "self-update" || command === "hook") return `command:${command}`;
+  return null;
+}
+function parseUpdateCache(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (record["schemaVersion"] !== 1) return null;
+  const checkedAt = record["checkedAt"];
+  if (typeof checkedAt !== "string" || Number.isNaN(Date.parse(checkedAt))) return null;
+  const tags = record["distTags"];
+  if (typeof tags !== "object" || tags === null || Array.isArray(tags)) return null;
+  const distTags = {};
+  for (const [tag, version] of Object.entries(tags)) {
+    if (typeof version === "string" && parseVersion(version)) distTags[tag] = version;
+  }
+  const hotfix = record["hotfix"];
+  return {
+    schemaVersion: 1,
+    checkedAt,
+    ok: record["ok"] === true,
+    distTags,
+    ...typeof hotfix === "string" && parseVersion(hotfix) ? { hotfix } : {}
+  };
+}
+function updateCheckDue(cache, now) {
+  if (cache === null) return true;
+  const age = now - Date.parse(cache.checkedAt);
+  if (age < 0) return true;
+  return age >= (cache.ok ? UPDATE_CHECK_INTERVAL_MS : UPDATE_CHECK_RETRY_MS);
+}
+function claimUpdateCheck(lockPath, now) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      closeSync(openSync(lockPath, "wx"));
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        if (now - statSync(lockPath).mtimeMs < UPDATE_CHECK_LOCK_STALE_MS) return false;
+        unlinkSync(lockPath);
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function registryFrom(env) {
+  const configured = env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY;
+  if (configured && /^https?:\/\//i.test(configured)) return configured;
+  return DEFAULT_NPM_REGISTRY;
+}
+function runsFromInstalledPackage() {
+  return /[\\/]node_modules[\\/]@cleocode[\\/]cleo[\\/]/.test(fileURLToPath(import.meta.url));
+}
+function spawnUpdateCheck(request, env) {
+  const entry = join(dirname(fileURLToPath(import.meta.url)), UPDATE_CHECK_ENTRY);
+  if (!existsSync(entry)) throw new Error(`update check entry missing: ${entry}`);
+  const childEnv = { ...env };
+  const proxied = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"].some((k) => env[k]);
+  if (proxied && childEnv.NODE_USE_ENV_PROXY === void 0) childEnv.NODE_USE_ENV_PROXY = "1";
+  const child = spawn(
+    process.execPath,
+    [entry, request.cachePath, request.lockPath, request.registry, request.packageName],
+    { detached: true, stdio: "ignore", windowsHide: true, env: childEnv }
+  );
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function showUpdateNotice(options) {
+  const env = options.env ?? process.env;
+  const suppressed = updateNoticeSuppression(
+    options.argv,
+    env,
+    options.installedPackage ?? runsFromInstalledPackage()
+  );
+  if (suppressed !== null) return { suppressed, checkStarted: false, shown: null };
+  let checkStarted = false;
+  let shown = null;
+  try {
+    const now = (options.now ?? Date.now)();
+    const stateDir = options.stateDir ?? getCleoStateDir();
+    const cachePath = join(stateDir, UPDATE_CACHE_FILE);
+    let cache = null;
+    try {
+      cache = parseUpdateCache(readFileSync(cachePath, "utf8"));
+    } catch {
+    }
+    if (updateCheckDue(cache, now)) {
+      mkdirSync(stateDir, { recursive: true });
+      const lockPath = join(stateDir, UPDATE_LOCK_FILE);
+      if (claimUpdateCheck(lockPath, now)) {
+        const request = {
+          cachePath,
+          lockPath,
+          registry: registryFrom(env),
+          packageName: CLEO_PACKAGE_NAME
+        };
+        try {
+          (options.startCheck ?? spawnUpdateCheck)(request, env);
+          checkStarted = true;
+        } catch {
+          try {
+            unlinkSync(lockPath);
+          } catch {
+          }
+        }
+      }
+    }
+    if (cache === null || options.quiet === true) {
+      return { suppressed: null, checkStarted, shown };
+    }
+    const notice = decideUpdateNotice(options.version, cache.distTags, cache.hotfix);
+    if (notice === null) return { suppressed: null, checkStarted, shown };
+    const hotfix = notice.kind === "hotfix";
+    const stampPath = join(stateDir, hotfix ? HOTFIX_NOTICE_STAMP_FILE : UPDATE_NOTICE_STAMP_FILE);
+    const interval = hotfix ? HOTFIX_NOTICE_INTERVAL_MS : UPDATE_NOTICE_INTERVAL_MS;
+    try {
+      const age = now - statSync(stampPath).mtimeMs;
+      if (age >= 0 && age < interval) return { suppressed: null, checkStarted, shown };
+    } catch {
+    }
+    writeFileSync(stampPath, `${notice.target}
+`);
+    utimesSync(stampPath, new Date(now), new Date(now));
+    (options.stderr ?? process.stderr).write(formatUpdateNotice(notice));
+    shown = notice;
+  } catch {
+  }
+  return { suppressed: null, checkStarted, shown };
+}
+
+export {
+  CLEO_PACKAGE_NAME,
+  UPDATE_NOTICE_OPT_OUT_ENV,
+  UPDATE_NOTICE_FROM_SOURCE_ENV,
+  DEFAULT_NPM_REGISTRY,
+  UPDATE_CHECK_INTERVAL_MS,
+  UPDATE_CHECK_RETRY_MS,
+  UPDATE_NOTICE_INTERVAL_MS,
+  UPDATE_CHECK_LOCK_STALE_MS,
+  UPDATE_CACHE_FILE,
+  UPDATE_LOCK_FILE,
+  UPDATE_NOTICE_STAMP_FILE,
+  HOTFIX_NOTICE_INTERVAL_MS,
+  HOTFIX_NOTICE_STAMP_FILE,
+  UPDATE_CHECK_ENTRY,
+  isCiEnvironment,
+  compareVersions,
+  releaseChannelTag,
+  decideUpdateNotice,
+  formatUpdateNotice,
+  updateNoticeSuppression,
+  parseUpdateCache,
+  updateCheckDue,
+  claimUpdateCheck,
+  showUpdateNotice
+};
+//# sourceMappingURL=chunk-EW2CKNNZ.js.map

package/dist/cli/chunk-FSKN4DWC.js

@@ -0,0 +1,108 @@
+(() => {
+  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,
+  humanInfo
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-fk-check.ts
+import { repairForeignKeyViolations, verifyForeignKeyIntegrity } from "@cleocode/core/db";
+var doctorFkCheckCommand = defineCommand({
+  meta: {
+    name: "fk-check",
+    description: "Verify foreign-key integrity of the consolidated project + global cleo.db (PRAGMA foreign_key_check). Read-only; exits non-zero on any violation."
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Limit the check to one scope ('project' or 'global'). Default: both."
+    },
+    fix: {
+      type: "boolean",
+      description: "Delete orphan rows whose foreign key declares ON DELETE CASCADE (the schema already says they should not exist). Other violations are reported, never touched."
+    }
+  },
+  async run({ args }) {
+    const scopeArg = args.scope;
+    if (scopeArg !== void 0 && scopeArg !== "project" && scopeArg !== "global") {
+      cliError(`--scope must be 'project' or 'global' (received: ${scopeArg})`, "E_INVALID_INPUT", {
+        fix: "Run 'cleo doctor fk-check --scope project' or omit --scope to check both."
+      });
+      process.exitCode = 6;
+      return;
+    }
+    const scopeOpt = scopeArg ? { scopes: [scopeArg] } : {};
+    if (args.fix === true) {
+      const fixReport = await repairForeignKeyViolations({ cwd: process.cwd(), ...scopeOpt });
+      humanInfo(
+        `  foreign_key_check --fix: ${fixReport.found.length} found, ${fixReport.repaired.length} repaired, ${fixReport.skipped.length} skipped`
+      );
+      for (const v of fixReport.repaired) {
+        humanInfo(`      repaired [${v.scope}] ${v.table} rowid=${v.rowid} \u2192 ${v.parent}`);
+      }
+      for (const v of fixReport.skipped) {
+        humanInfo(
+          `      SKIPPED  [${v.scope}] ${v.table} rowid=${v.rowid ?? "n/a"} \u2192 ${v.parent} (foreign key is not ON DELETE CASCADE \u2014 repair by hand)`
+        );
+      }
+      cliOutput(
+        { kind: "generic", ...fixReport },
+        {
+          command: "doctor fk-check",
+          message: fixReport.ok ? `foreign_key_check: repaired ${fixReport.repaired.length} orphan(s); 0 violations remain.` : `foreign_key_check: ${fixReport.skipped.length} violation(s) remain after repair.`
+        }
+      );
+      if (!fixReport.ok) process.exitCode = 1;
+      return;
+    }
+    const report = await verifyForeignKeyIntegrity({ cwd: process.cwd(), ...scopeOpt });
+    if (report.ok) {
+      humanInfo(`  foreign_key_check: OK \u2014 0 violations across ${report.scopes.join(" + ")}`);
+    } else {
+      humanInfo(`  foreign_key_check: ${report.violations.length} violation(s)`);
+      for (const v of report.violations) {
+        humanInfo(
+          `      [${v.scope}] ${v.table} rowid=${v.rowid ?? "n/a"} \u2192 missing parent ${v.parent} (fk #${v.fkid})`
+        );
+      }
+    }
+    cliOutput(
+      {
+        kind: "generic",
+        ok: report.ok,
+        scopes: report.scopes,
+        violationCount: report.violations.length,
+        violations: report.violations
+      },
+      {
+        command: "doctor fk-check",
+        message: report.ok ? `foreign_key_check: OK \u2014 0 violations across ${report.scopes.join(" + ")}.` : `foreign_key_check: ${report.violations.length} violation(s) across ${report.scopes.join(" + ")}.`
+      }
+    );
+    if (!report.ok) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorFkCheckCommand
+};
+//# sourceMappingURL=chunk-FSKN4DWC.js.map

package/dist/cli/chunk-FVKLULL7.js

@@ -0,0 +1,48 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-legacy-reaper.ts
+import { scanLegacyReaper } from "@cleocode/core/doctor/legacy-reaper.js";
+var doctorLegacyReaperCommand = defineCommand({
+  meta: {
+    name: "legacy-reaper",
+    description: "Detect the legacy cleo-mcp-reaper user timer that kills processes by generic `MainThread` comm \u2014 it terminates live Codex CLI sessions. --fix disables and masks it."
+  },
+  args: {
+    fix: { type: "boolean", description: "Disable and mask any legacy unit that can still fire" },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  run({ args }) {
+    const report = scanLegacyReaper({ fix: args.fix === true });
+    cliOutput(report, { command: "doctor", operation: "doctor.legacy-reaper.run" });
+    if (report.armed && !report.remediated) {
+      if (process.exitCode === void 0 || process.exitCode === 0) process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorLegacyReaperCommand
+};
+//# sourceMappingURL=chunk-FVKLULL7.js.map