@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/daemon-DV25JQ62.js

@@ -0,0 +1,451 @@
+(() => {
+  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 {
+  resolveStudioStaticDir
+} from "./chunk-GH37QXW5.js";
+import {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  createCliGatewayHandler
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/daemon.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getGCDaemonStatus, spawnGCDaemon, stopGCDaemon } from "@cleocode/core/gc/daemon.js";
+import {
+  bootstrapDaemon as bootstrapSentientDaemon,
+  getSentientDaemonStatus
+} from "@cleocode/core/sentient";
+import { resolveLegacyCleoDir } from "@cleocode/paths";
+import { serveGateway } from "@cleocode/runtime/gateway";
+var DEFAULT_GATEWAY_HTTP_PORT = 7777;
+async function blockUntilSignal(handle) {
+  await new Promise((resolve) => {
+    const onSignal = () => {
+      void handle.close().finally(resolve);
+    };
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+  });
+}
+async function showDaemonStatus(cleoDir, projectRoot) {
+  try {
+    const gcStatus = await getGCDaemonStatus(cleoDir);
+    let hygieneLastRunAt = null;
+    let hygieneSummary = null;
+    let hygieneStats = {
+      projectsChecked: 0,
+      projectsHealthy: 0,
+      tempGcCandidates: 0,
+      duplicateEpicGroups: 0,
+      worktreesPruned: 0
+    };
+    let supervisesStudio = null;
+    let studioStatus = null;
+    try {
+      const sentientStatus = await getSentientDaemonStatus(projectRoot);
+      hygieneLastRunAt = sentientStatus.hygieneLastRunAt;
+      hygieneSummary = sentientStatus.hygieneSummary;
+      hygieneStats = sentientStatus.hygieneStats;
+      supervisesStudio = sentientStatus.supervisesStudio;
+      studioStatus = sentientStatus.studioStatus;
+    } catch {
+    }
+    const data = {
+      gc: gcStatus,
+      hygiene: {
+        lastRunAt: hygieneLastRunAt,
+        summary: hygieneSummary,
+        stats: hygieneStats
+      },
+      studio: {
+        supervises: supervisesStudio,
+        status: studioStatus
+      }
+    };
+    const runningStr = gcStatus.running ? `running (PID ${gcStatus.pid})` : "stopped";
+    const diskStr = gcStatus.lastDiskUsedPct !== null ? `${gcStatus.lastDiskUsedPct.toFixed(1)}%` : "unknown";
+    const escalationNote = gcStatus.escalationNeeded ? " \u2014 WARNING: Disk threshold breached. Run 'cleo gc run' to reclaim space." : "";
+    cliOutput(data, {
+      command: "daemon",
+      operation: "daemon.status",
+      message: `GC Daemon: ${runningStr}, Disk: ${diskStr}${escalationNote}`
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    cliError(
+      `Error reading daemon status: ${message}`,
+      "E_INTERNAL",
+      { name: "E_INTERNAL" },
+      {
+        operation: "daemon.status"
+      }
+    );
+    process.exit(1);
+  }
+}
+function resolveDaemonInstallerScript() {
+  const filePath = fileURLToPath(import.meta.url);
+  const candidate1 = join(filePath, "..", "..", "..", "scripts", "install-daemon-service.mjs");
+  if (existsSync(candidate1)) return candidate1;
+  const candidate2 = join(
+    filePath,
+    "..",
+    "..",
+    "..",
+    "..",
+    "scripts",
+    "install-daemon-service.mjs"
+  );
+  return candidate2;
+}
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Spawn the GC daemon as a detached background process" },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    foreground: {
+      type: "boolean",
+      description: "Run the sentient daemon in the foreground (used by systemd/launchd service units)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    const foreground = args.foreground ?? false;
+    if (foreground) {
+      const projectRoot = process.cwd();
+      cliOutput(
+        {
+          pid: process.pid,
+          mode: "foreground",
+          message: "Starting sentient daemon in foreground mode"
+        },
+        {
+          command: "daemon",
+          operation: "daemon.start",
+          message: `[CLEO DAEMON] Starting sentient daemon in foreground mode (PID ${process.pid})`
+        }
+      );
+      await bootstrapSentientDaemon(projectRoot);
+      return;
+    }
+    try {
+      const status = await getGCDaemonStatus(cleoDir);
+      if (status.running && status.pid) {
+        cliOutput(
+          { running: true, pid: status.pid, message: `Daemon already running (PID ${status.pid})` },
+          {
+            command: "daemon",
+            operation: "daemon.start",
+            message: `Daemon already running (PID ${status.pid})`
+          }
+        );
+        return;
+      }
+      const pid = await spawnGCDaemon(cleoDir);
+      cliOutput(
+        {
+          pid,
+          cleoDir,
+          logs: join(cleoDir, "logs", "gc.log"),
+          message: `GC daemon started (PID ${pid})`
+        },
+        {
+          command: "daemon",
+          operation: "daemon.start",
+          message: `GC daemon started (PID ${pid}) \u2014 Logs: ${join(cleoDir, "logs", "gc.log")}`
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error starting daemon: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "daemon.start"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var stopCommand = defineCommand({
+  meta: { name: "stop", description: "Stop the GC daemon by sending SIGTERM to its PID" },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    try {
+      const stopResult = await stopGCDaemon(cleoDir);
+      cliOutput(stopResult, {
+        command: "daemon",
+        operation: "daemon.stop",
+        message: stopResult.stopped ? `GC daemon stopped (${stopResult.reason})` : stopResult.reason
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error stopping daemon: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        {
+          operation: "daemon.stop"
+        }
+      );
+      process.exit(1);
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show daemon running state, PID, last GC run, disk usage, and cross-project hygiene summary"
+  },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args }) {
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    await showDaemonStatus(cleoDir, process.cwd());
+  }
+});
+var installCommand = defineCommand({
+  meta: {
+    name: "install",
+    description: "Register the CLEO daemon as a user-level system service (systemd / launchd)"
+  },
+  args: {
+    saga: {
+      type: "string",
+      description: "Scope the daemon to tasks within a Saga (sets CLEO_SENTIENT_SAGA in service env)",
+      required: false
+    },
+    epic: {
+      type: "string",
+      description: "Scope the daemon to tasks directly under an Epic (sets CLEO_SENTIENT_EPIC in service env)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args }) {
+    try {
+      const scriptPath = resolveDaemonInstallerScript();
+      const { installDaemonService } = await import(scriptPath);
+      const scopeSagaId = typeof args.saga === "string" && args.saga.length > 0 ? args.saga : void 0;
+      const scopeEpicId = typeof args.epic === "string" && args.epic.length > 0 ? args.epic : void 0;
+      await installDaemonService({ scopeSagaId, scopeEpicId });
+      const scopeNote = scopeEpicId !== void 0 ? ` (scoped to epic ${scopeEpicId})` : scopeSagaId !== void 0 ? ` (scoped to saga ${scopeSagaId})` : "";
+      cliOutput(
+        {
+          platform: process.platform,
+          scopeSagaId,
+          scopeEpicId,
+          message: `Daemon service installation complete${scopeNote}.`
+        },
+        {
+          command: "daemon",
+          operation: "daemon.install",
+          message: `CLEO: Daemon service installation complete${scopeNote}.`
+        }
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error installing daemon service: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "daemon.install" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var uninstallCommand = defineCommand({
+  meta: {
+    name: "uninstall",
+    description: "Disable and remove the user-level system service (systemd unit / launchd plist)"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args: _args }) {
+    try {
+      const scriptPath = resolveDaemonInstallerScript();
+      const { uninstallDaemonService } = await import(scriptPath);
+      const result = await uninstallDaemonService();
+      cliOutput(result, {
+        command: "daemon",
+        operation: "daemon.uninstall",
+        message: `CLEO: ${result.message}`
+      });
+      if (!result.success) process.exit(1);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error uninstalling daemon service: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "daemon.uninstall" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var serveCommand = defineCommand({
+  meta: {
+    name: "serve",
+    description: "Start the HTTP gateway listener (versioned /v1 REST facade, loopback by default)"
+  },
+  args: {
+    port: {
+      type: "string",
+      description: `TCP port to bind (default ${DEFAULT_GATEWAY_HTTP_PORT}; 0 = ephemeral)`
+    },
+    host: {
+      type: "string",
+      description: "Host/interface to bind (default 127.0.0.1 \u2014 loopback only)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  async run({ args }) {
+    try {
+      const portArg = args.port;
+      const port = portArg !== void 0 && portArg.length > 0 ? Number.parseInt(portArg, 10) : DEFAULT_GATEWAY_HTTP_PORT;
+      if (Number.isNaN(port) || port < 0 || port > 65535) {
+        cliError(
+          `Invalid --port '${portArg}'; expected an integer in [0, 65535]`,
+          "E_INVALID_INPUT",
+          { name: "E_INVALID_INPUT" },
+          { operation: "daemon.serve" }
+        );
+        process.exit(2);
+      }
+      const host = args.host ?? "127.0.0.1";
+      const studioStaticDir = resolveStudioStaticDir();
+      const handle = await serveGateway({
+        handler: createCliGatewayHandler(),
+        port,
+        host,
+        studioStaticDir
+      });
+      cliOutput(
+        {
+          pid: process.pid,
+          host: handle.host,
+          port: handle.port,
+          scope: handle.scope,
+          facade: "/v1",
+          studioUrl: studioStaticDir !== void 0 ? `http://${handle.host}:${handle.port}/studio/` : null,
+          message: `HTTP gateway listening on http://${handle.host}:${handle.port}/v1`
+        },
+        {
+          command: "daemon",
+          operation: "daemon.serve",
+          message: studioStaticDir !== void 0 ? `HTTP gateway listening on http://${handle.host}:${handle.port}/v1 (Studio: http://${handle.host}:${handle.port}/studio/, PID ${process.pid})` : `HTTP gateway listening on http://${handle.host}:${handle.port}/v1 (PID ${process.pid})`
+        }
+      );
+      await blockUntilSignal(handle);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(
+        `Error starting HTTP gateway: ${message}`,
+        "E_INTERNAL",
+        { name: "E_INTERNAL" },
+        { operation: "daemon.serve" }
+      );
+      process.exit(1);
+    }
+  }
+});
+var daemonCommand = defineCommand({
+  meta: {
+    name: "daemon",
+    description: "Manage the CLEO GC sidecar daemon for autonomous transcript cleanup"
+  },
+  args: {
+    "cleo-dir": {
+      type: "string",
+      description: "Override .cleo/ directory path"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON"
+    }
+  },
+  subCommands: {
+    start: startCommand,
+    stop: stopCommand,
+    status: statusCommand,
+    serve: serveCommand,
+    install: installCommand,
+    uninstall: uninstallCommand
+  },
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    const cleoDir = resolveLegacyCleoDir(args["cleo-dir"]);
+    await showDaemonStatus(cleoDir, process.cwd());
+  }
+});
+export {
+  daemonCommand
+};
+//# sourceMappingURL=daemon-DV25JQ62.js.map

package/dist/cli/dash-TFU4RLQW.js

@@ -0,0 +1,70 @@
+(() => {
+  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 {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/dash.ts
+var dashCommand = defineCommand({
+  meta: {
+    name: "dash",
+    description: "Project health dashboard: status summary, phase progress, recent activity, high priority tasks. Use for overall project status."
+  },
+  args: {
+    "blocked-limit": {
+      type: "string",
+      description: "Max blocked tasks to show"
+    },
+    "no-hygiene": {
+      type: "boolean",
+      description: "Suppress the hygiene section note"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "dash",
+      {
+        blockedTasksLimit: args["blocked-limit"] !== void 0 ? Number.parseInt(args["blocked-limit"], 10) : void 0
+      },
+      { command: "dash" }
+    );
+    if (!negatedFlag(args, "hygiene")) {
+      humanLine(
+        "\n--- Sentient Hygiene (T1636) ---\nBackground scan runs every 4h (dream cycle). Run `cleo memory digest --hygiene` to see the latest hygiene observations (orphan tasks, top-level tasks without an epic, content defects, premature-close leaks)."
+      );
+    }
+  }
+});
+export {
+  dashCommand
+};
+//# sourceMappingURL=dash-TFU4RLQW.js.map