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

package/dist/cli/status-XLKYLN42.js

@@ -0,0 +1,157 @@
+(() => {
+  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 {
+  BOLD,
+  CYAN,
+  DIM,
+  GREEN,
+  NC,
+  RED,
+  YELLOW
+} from "./chunk-VB3LDPL5.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import {
+  isJsonFormat
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/status.ts
+import { getCleoStatus } from "@cleocode/core/status";
+function formatEpoch(epoch) {
+  if (epoch == null) return "";
+  const d = new Date(epoch);
+  if (Number.isNaN(d.getTime())) return "";
+  return d.toISOString().replace("T", " ").slice(0, 19) + "Z";
+}
+function renderCredentialLine(c) {
+  const badges = [];
+  if (c.lastStatus === "invalid") badges.push(`${RED}${BOLD}[INVALID]${NC}`);
+  if (c.isExpired === true) badges.push(`${YELLOW}${BOLD}[EXPIRED]${NC}`);
+  const label = c.label ?? "(no label)";
+  const head = `${BOLD}${c.provider}${NC} ${DIM}${label}${NC}`;
+  const meta = [];
+  meta.push(`source=${c.source}`);
+  if (c.authType !== void 0) meta.push(`authType=${c.authType}`);
+  if (c.lastStatus !== void 0) meta.push(`lastStatus=${c.lastStatus}`);
+  if (c.expiresAt != null) meta.push(`expiresAt=${formatEpoch(c.expiresAt)}`);
+  const metaLine = `${DIM}${meta.join(" \xB7 ")}${NC}`;
+  const badgeStr = badges.length > 0 ? ` ${badges.join(" ")}` : "";
+  return `    ${head}${badgeStr}
+      ${metaLine}`;
+}
+function renderStatusHuman(status) {
+  const lines = [];
+  if (status.config.hasSecretsInProjectConfig) {
+    lines.push(`${RED}${BOLD}WARNING: Secrets detected in project config${NC}`);
+    for (const w of status.config.secretsWarnings) {
+      lines.push(`  ${RED}${w}${NC}`);
+    }
+    lines.push("");
+  }
+  lines.push(`${BOLD}Identity${NC}`);
+  lines.push(`  ${DIM}agentId:${NC}      ${status.identity.agentId ?? "(none)"}`);
+  lines.push(`  ${DIM}identityFile:${NC} ${status.identity.identityFile ?? "(none)"}`);
+  const loggedInBadge = status.identity.loggedIn ? `${GREEN}yes${NC}` : `${YELLOW}no \u2014 run \`cleo setup\`${NC}`;
+  lines.push(`  ${DIM}loggedIn:${NC}     ${loggedInBadge}`);
+  lines.push("");
+  lines.push(`${BOLD}Credentials${NC} ${DIM}(${status.credentials.length} entries)${NC}`);
+  if (status.credentials.length === 0) {
+    lines.push(`  ${DIM}(no credentials \u2014 run \`cleo auth list\` after \`cleo setup\`)${NC}`);
+  } else {
+    for (const c of status.credentials) {
+      lines.push(renderCredentialLine(c));
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}Config${NC}`);
+  lines.push(`  ${DIM}globalConfigPath:${NC}  ${status.config.globalConfigPath}`);
+  lines.push(`  ${DIM}projectConfigPath:${NC} ${status.config.projectConfigPath ?? "(none)"}`);
+  lines.push(`  ${DIM}activeConfigPath:${NC}  ${status.config.activeConfigPath}`);
+  lines.push("");
+  lines.push(`${BOLD}Session${NC}`);
+  const sessionState = status.session.active ? `${GREEN}active${NC}` : `${DIM}inactive${NC}`;
+  lines.push(`  ${DIM}state:${NC}       ${sessionState}`);
+  lines.push(`  ${DIM}sessionId:${NC}   ${status.session.sessionId ?? "(none)"}`);
+  lines.push(`  ${DIM}focusedTask:${NC} ${status.session.focusedTask ?? "(none)"}`);
+  lines.push("");
+  lines.push(`${BOLD}Harness${NC}`);
+  lines.push(`  ${DIM}active:${NC}  ${CYAN}${status.harness.active}${NC}`);
+  lines.push(
+    `  ${DIM}healthy:${NC} ${status.harness.healthy ? `${GREEN}yes${NC}` : `${RED}no${NC}`}`
+  );
+  if (status.harness.issues.length > 0) {
+    for (const issue of status.harness.issues) {
+      lines.push(`    ${YELLOW}- ${issue}${NC}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}Daemon${NC}`);
+  const daemonState = status.daemon.running ? `${GREEN}running${NC}` : `${DIM}stopped${NC}`;
+  lines.push(`  ${DIM}state:${NC}            ${daemonState}`);
+  lines.push(`  ${DIM}pid:${NC}              ${status.daemon.pid ?? "(none)"}`);
+  lines.push(
+    `  ${DIM}lastTickAt:${NC}       ${status.daemon.lastTickAt != null ? formatEpoch(status.daemon.lastTickAt) : "(never)"}`
+  );
+  const killSwitchBadge = status.daemon.killSwitchActive ? `${RED}${BOLD}ACTIVE${NC}` : `${DIM}inactive${NC}`;
+  lines.push(`  ${DIM}killSwitchActive:${NC} ${killSwitchBadge}`);
+  lines.push("");
+  lines.push(`${BOLD}Cleo Nexus account${NC}`);
+  for (const n of status.nexusAccount) {
+    const color = n.state === "signed-in" ? GREEN : n.state === "not-signed-in" ? DIM : YELLOW;
+    lines.push(`  ${DIM}${n.apiUrl}:${NC} ${color}${n.summary}${NC}`);
+  }
+  return lines.join("\n");
+}
+function computeExitCode(status) {
+  const hasInvalid = status.credentials.some((c) => c.lastStatus === "invalid");
+  return hasInvalid ? 1 : 0;
+}
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Unified config + credential + session + harness + daemon snapshot. Use --json for the full LAFS envelope (CleoStatus interface). Exits non-zero when any credential is in invalid state."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON envelope (CleoStatus interface)"
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const forceJson = a["json"] === true;
+    const status = await getCleoStatus();
+    if (forceJson || isJsonFormat()) {
+      cliOutput(status, {
+        command: "status",
+        operation: "status.show"
+      });
+    } else {
+      process.stdout.write(`${renderStatusHuman(status)}
+`);
+    }
+    const exitCode = computeExitCode(status);
+    if (exitCode !== 0) process.exit(exitCode);
+  }
+});
+export {
+  statusCommand
+};
+//# sourceMappingURL=status-XLKYLN42.js.map

package/dist/cli/sticky-VSTQ2I2O.js

@@ -0,0 +1,264 @@
+(() => {
+  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 {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  dispatchMeta,
+  handleErrorResult,
+  unsupportedOp
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/sticky.ts
+import { getLogger, getProjectRoot } from "@cleocode/core";
+import {
+  stickyAdd,
+  stickyArchive,
+  stickyConvertToMemory,
+  stickyConvertToSessionNote,
+  stickyConvertToTask,
+  stickyConvertToTaskNote,
+  stickyListFiltered,
+  stickyPurge,
+  stickyShow
+} from "@cleocode/core/internal";
+var log = getLogger("domain:sticky");
+async function stickyListOp(params) {
+  return stickyListFiltered(
+    getProjectRoot(),
+    {
+      status: params.status,
+      color: params.color,
+      priority: params.priority,
+      tags: params.tags
+    },
+    params.limit,
+    params.offset
+  );
+}
+async function stickyShowOp(params) {
+  return stickyShow(getProjectRoot(), params.stickyId);
+}
+async function stickyAddOp(params) {
+  return stickyAdd(getProjectRoot(), {
+    content: params.content,
+    tags: params.tags,
+    color: params.color,
+    priority: params.priority
+  });
+}
+async function stickyArchiveOp(params) {
+  return stickyArchive(getProjectRoot(), params.stickyId);
+}
+async function stickyPurgeOp(params) {
+  return stickyPurge(getProjectRoot(), params.stickyId);
+}
+async function stickyConvertTaskOp(params) {
+  const result = await stickyConvertToTask(getProjectRoot(), params.stickyId, params.title);
+  if (!result.success) return { taskId: void 0 };
+  return { taskId: result.data.taskId };
+}
+async function stickyConvertMemoryOp(params) {
+  const result = await stickyConvertToMemory(getProjectRoot(), params.stickyId, params.memoryType);
+  if (!result.success) return { memoryId: void 0 };
+  return { memoryId: result.data.memoryId };
+}
+async function stickyConvertSessionNoteOp(params) {
+  const result = await stickyConvertToSessionNote(
+    getProjectRoot(),
+    params.stickyId,
+    params.sessionId
+  );
+  if (!result.success) return { sessionId: void 0 };
+  return { sessionId: result.data.sessionId };
+}
+function convertSessionNoteWithError(params) {
+  return stickyConvertToSessionNote(getProjectRoot(), params.stickyId, params.sessionId);
+}
+async function stickyConvertTaskNoteOp(params) {
+  const result = await stickyConvertToTaskNote(getProjectRoot(), params.stickyId, params.taskId);
+  if (!result.success) return { taskId: void 0 };
+  return { taskId: result.data.taskId };
+}
+var stickyCoreOps = {
+  list: stickyListOp,
+  show: stickyShowOp,
+  add: stickyAddOp,
+  archive: stickyArchiveOp,
+  purge: stickyPurgeOp,
+  "convert.task": stickyConvertTaskOp,
+  "convert.memory": stickyConvertMemoryOp,
+  "convert.session_note": stickyConvertSessionNoteOp,
+  "convert.task_note": stickyConvertTaskNoteOp
+};
+var _stickyTypedHandler = defineTypedHandler("sticky", {
+  list: async (params) => {
+    const result = await stickyCoreOps.list(params);
+    if (!result.success) {
+      return lafsError(result.error.code, result.error.message, "list");
+    }
+    return lafsSuccess(result.data, "list", result.page ? { page: result.page } : void 0);
+  },
+  show: async (params) => {
+    if (!params.stickyId) return lafsError("E_INVALID_INPUT", "stickyId is required", "show");
+    const result = await stickyCoreOps.show(params);
+    return result.success ? lafsSuccess(result.data, "show") : lafsError(result.error?.code ?? "E_INTERNAL", result.error?.message ?? "", "show");
+  },
+  add: async (params) => {
+    if (!params.content) return lafsError("E_INVALID_INPUT", "content is required", "add");
+    const result = await stickyCoreOps.add(params);
+    return result.success ? lafsSuccess(result.data, "add") : lafsError(result.error?.code ?? "E_INTERNAL", result.error?.message ?? "", "add");
+  },
+  archive: async (params) => {
+    if (!params.stickyId) return lafsError("E_INVALID_INPUT", "stickyId is required", "archive");
+    const result = await stickyCoreOps.archive(params);
+    return result.success ? lafsSuccess(result.data, "archive") : lafsError(result.error?.code ?? "E_INTERNAL", result.error?.message ?? "", "archive");
+  },
+  purge: async (params) => {
+    if (!params.stickyId) return lafsError("E_INVALID_INPUT", "stickyId is required", "purge");
+    const result = await stickyCoreOps.purge(params);
+    return result.success ? lafsSuccess(result.data, "purge") : lafsError(result.error?.code ?? "E_INTERNAL", result.error?.message ?? "", "purge");
+  },
+  "convert.task": async (params) => {
+    if (!params.stickyId)
+      return lafsError("E_INVALID_INPUT", "stickyId is required", "convert.task");
+    const data = await stickyCoreOps["convert.task"](params);
+    return data.taskId ? lafsSuccess(data, "convert.task") : lafsError("E_CONVERT_FAILED", "convert to task failed", "convert.task");
+  },
+  "convert.memory": async (params) => {
+    if (!params.stickyId)
+      return lafsError("E_INVALID_INPUT", "stickyId is required", "convert.memory");
+    const data = await stickyCoreOps["convert.memory"](params);
+    return data.memoryId ? lafsSuccess(data, "convert.memory") : lafsError("E_CONVERT_FAILED", "convert to memory failed", "convert.memory");
+  },
+  "convert.session_note": async (params) => {
+    if (!params.stickyId)
+      return lafsError("E_INVALID_INPUT", "stickyId is required", "convert.session_note");
+    const result = await convertSessionNoteWithError(params);
+    if (!result.success) {
+      return lafsError(
+        result.error?.code ?? "E_CONVERT_FAILED",
+        result.error?.message ?? "convert to session note failed",
+        "convert.session_note"
+      );
+    }
+    return lafsSuccess({ sessionId: result.data.sessionId }, "convert.session_note");
+  },
+  "convert.task_note": async (params) => {
+    if (!params.stickyId)
+      return lafsError("E_INVALID_INPUT", "stickyId is required", "convert.task_note");
+    if (!params.taskId)
+      return lafsError(
+        "E_INVALID_INPUT",
+        "taskId is required for task_note conversion",
+        "convert.task_note"
+      );
+    const data = await stickyCoreOps["convert.task_note"](params);
+    return data.taskId ? lafsSuccess(data, "convert.task_note") : lafsError("E_CONVERT_FAILED", "convert to task note failed", "convert.task_note");
+  }
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["list", "show"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["add", "convert", "archive", "purge"]);
+var CONVERT_TARGET_TO_KEY = {
+  task: "convert.task",
+  memory: "convert.memory",
+  session_note: "convert.session_note",
+  task_note: "convert.task_note"
+};
+function envelopeToDispatch(envelope, gateway, operation, startTime) {
+  if (envelope.success) {
+    const withPage = envelope;
+    return {
+      meta: dispatchMeta(gateway, "sticky", operation, startTime),
+      success: true,
+      data: envelope.data,
+      ...withPage.page ? { page: withPage.page } : {}
+    };
+  }
+  return {
+    meta: dispatchMeta(gateway, "sticky", operation, startTime),
+    success: false,
+    error: {
+      code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+      message: envelope.error?.message ?? "Unknown error"
+    }
+  };
+}
+var StickyHandler = class {
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "sticky", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _stickyTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return envelopeToDispatch(envelope, "query", operation, startTime);
+    } catch (error) {
+      log.error({ gateway: "query", domain: "sticky", operation, err: error }, String(error));
+      return handleErrorResult("query", "sticky", operation, error, startTime);
+    }
+  }
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "sticky", operation, startTime);
+    }
+    try {
+      if (operation === "convert") {
+        const targetType = params?.["targetType"];
+        if (!targetType || !(targetType in CONVERT_TARGET_TO_KEY)) {
+          return {
+            meta: dispatchMeta("mutate", "sticky", operation, startTime),
+            success: false,
+            error: {
+              code: "E_INVALID_INPUT",
+              message: "targetType is required (task, memory, session_note, or task_note)"
+            }
+          };
+        }
+        const subOp = CONVERT_TARGET_TO_KEY[targetType];
+        const envelope2 = await typedDispatch(_stickyTypedHandler, subOp, params ?? {});
+        return envelopeToDispatch(envelope2, "mutate", operation, startTime);
+      }
+      const envelope = await typedDispatch(
+        _stickyTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return envelopeToDispatch(envelope, "mutate", operation, startTime);
+    } catch (error) {
+      log.error({ gateway: "mutate", domain: "sticky", operation, err: error }, String(error));
+      return handleErrorResult("mutate", "sticky", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: ["list", "show"],
+      mutate: ["add", "convert", "archive", "purge"]
+    };
+  }
+};
+export {
+  StickyHandler
+};
+//# sourceMappingURL=sticky-VSTQ2I2O.js.map