@inceptionstack/roundhouse 0.5.1 → 0.5.3

package/src/cli/cli.ts

@@ -14,7 +14,6 @@ import { performUpdate } from "../commands/update";
 import {
   CONFIG_PATH,
   SESSIONS_DIR,
-  SERVICE_NAME,
   fileExists,
   loadConfig,
   resolveEnvFilePath,
@@ -22,14 +21,7 @@ import {
 import { getAgentSdkPackage } from "../agents/registry";
 import { threadIdToDir } from "../util";
 import { parseEnvFile, unquoteEnvValue } from "./env-file";
-import {
-  SERVICE_PATH,
-  systemctl,
-  runSudo,
-  isServiceInstalled,
-  isServiceActive,
-  systemctlShow,
-} from "./systemd";
+import { getServiceManager } from "./service-manager";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -41,7 +33,7 @@ const __dirname = dirname(__filename);
  * Only call with trusted/hardcoded strings. Any dynamic segments must be
  * validated (e.g. `/^\d+$/.test(pid)`) before interpolation.
  */
-function run(cmd: string, opts?: { silent?: boolean }): string {
+function shellExec(cmd: string, opts?: { silent?: boolean }): string {
   try {
     const out = execSync(cmd, { encoding: "utf8", stdio: opts?.silent ? "pipe" : "inherit" });
     return (out ?? "").trim();
@@ -54,31 +46,32 @@ function run(cmd: string, opts?: { silent?: boolean }): string {
 // ── Commands ────────────────────────────────────────
 
 async function cmdStart() {
-  if (isServiceInstalled()) {
-    if (isServiceActive()) {
-      console.log("Roundhouse is already running.");
-      console.log("  Use: roundhouse restart   to restart");
-      console.log("       roundhouse status    to check status");
-      console.log("       roundhouse logs      to tail logs");
-      return;
+  const svc = getServiceManager();
+  const result = await svc.start();
+
+  if (result.message === "no-service") {
+    // No service installed — fall back to foreground
+    if (!(await fileExists(CONFIG_PATH))) {
+      console.error("No config found. Run 'roundhouse setup --telegram' first.");
+      process.exit(1);
     }
-    systemctl("start", "Daemon started.");
+    console.log("No service found. Running in foreground (use Ctrl+C to stop)...");
+    if (process.platform !== "darwin") {
+      console.log("  Tip: run 'roundhouse setup --telegram' to install as systemd daemon.\n");
+    } else {
+      console.log("");
+    }
+    await cmdRun();
     return;
   }
 
-  // No systemd service — fall back to foreground. Check config before launching.
-  if (!(await fileExists(CONFIG_PATH))) {
-    console.error("No config found. Run 'roundhouse setup --telegram' first.");
-    process.exit(1);
-  }
-
-  console.log("No systemd service found. Running in foreground (use Ctrl+C to stop)...");
-  if (process.platform !== "darwin") {
-    console.log("  Tip: run 'roundhouse setup --telegram' to install as systemd daemon.\n");
-  } else {
-    console.log("");
+  console.log(result.message);
+  if (result.started && process.platform === "darwin") {
+    console.log("  Logs: ~/.roundhouse/logs/roundhouse.log");
+  } else if (!result.started) {
+    console.log("  Logs: roundhouse logs");
+    console.log("  Stop: roundhouse stop");
   }
-  await cmdRun();
 }
 
 async function cmdRun() {
@@ -105,7 +98,7 @@ async function cmdRun() {
       env: {
         ...process.env,
         ROUNDHOUSE_CONFIG: CONFIG_PATH,
-        NODE_NO_WARNINGS: "1",  // Suppress npm deprecation spam
+        NODE_NO_WARNINGS: "1",
       },
     });
   }
@@ -146,14 +139,11 @@ async function cmdInstall() {
   console.log("  This sets up config, installs packages, pairs Telegram,");
   console.log("  and installs the systemd service — all in one command.\n");
 }
-async function cmdUninstall() {
 
-  console.log("[roundhouse] Removing systemd daemon...");
-  try { systemctl("stop"); } catch {}
-  try { systemctl("disable"); } catch {}
-  try { runSudo("rm", "-f", SERVICE_PATH); } catch {}
-  runSudo("systemctl", "daemon-reload");
-  console.log("  ✅ Daemon removed. Config preserved at:", CONFIG_PATH);
+async function cmdUninstall() {
+  const svc = getServiceManager();
+  const result = await svc.uninstall();
+  console.log(`  ✅ ${result.message} Config preserved at:`, CONFIG_PATH);
 }
 
 async function cmdUpdate() {
@@ -167,12 +157,16 @@ async function cmdUpdate() {
 
   console.log(`[roundhouse] Updated to v${result.latestVersion}`);
 
-  if (process.platform === "darwin" || !isServiceInstalled()) {
+  const svc = getServiceManager();
+  const status = await svc.status();
+
+  if (!status.installed) {
     console.log("\n  ✅ Update complete. Restart with: roundhouse start");
   } else {
-    console.log("\n[roundhouse] Restarting daemon...");
+    console.log("\n[roundhouse] Restarting service...");
     try {
-      systemctl("restart", "Updated and restarted.");
+      const restartResult = await svc.restart();
+      console.log(`  ✅ ${restartResult.message}`);
     } catch {
       console.log("  ⚠️  Could not restart. Run: roundhouse start");
     }
@@ -180,24 +174,34 @@ async function cmdUpdate() {
 }
 
 async function cmdStatus() {
-  if (!isServiceActive()) {
-    console.log("\n  ❌ Roundhouse is not running.\n");
+  const svc = getServiceManager();
+  const svcStatus = await svc.status();
+
+  if (!svcStatus.running) {
+    const icon = svcStatus.installed ? "⚠️" : "❌";
+    console.log(`\n  ${icon} ${svcStatus.message}\n`);
     console.log("  Start with: roundhouse start\n");
     return;
   }
 
-  // Load config for details
+  // macOS: simple status
+  if (process.platform === "darwin") {
+    console.log("\n  ✅ Roundhouse is running (LaunchAgent).\n");
+    console.log("  Logs: ~/.roundhouse/logs/roundhouse.log");
+    console.log("  Stop: roundhouse stop\n");
+    return;
+  }
+
+  // Linux: detailed systemd status
+  const { systemctlShow } = await import("./systemd");
+
   let config: Awaited<ReturnType<typeof loadConfig>> | null = null;
-  try {
-    config = await loadConfig();
-  } catch {}
+  try { config = await loadConfig(); } catch {}
 
-  // Gather systemd info
   const pid = systemctlShow("MainPID");
   const activeState = systemctlShow("ActiveState");
   const startedAt = systemctlShow("ActiveEnterTimestamp");
 
-  // Compute uptime
   let uptimeStr = "unknown";
   if (startedAt) {
     const startMs = new Date(startedAt).getTime();
@@ -208,17 +212,15 @@ async function cmdStatus() {
     }
   }
 
-  // Memory from PID
   let memStr = "unknown";
   if (pid && pid !== "0" && /^\d+$/.test(pid)) {
-    const rssKb = run(`ps -o rss= -p ${pid}`, { silent: true }).trim();
+    const rssKb = shellExec(`ps -o rss= -p ${pid}`, { silent: true }).trim();
     if (rssKb) {
       const parsed = parseInt(rssKb, 10);
       if (!isNaN(parsed)) memStr = `${(parsed / 1024).toFixed(1)} MB`;
     }
   }
 
-  // Read env file for debug flags
   let debugStream = false;
   const statusEnvPath = await resolveEnvFilePath();
   try {
@@ -226,7 +228,6 @@ async function cmdStatus() {
     debugStream = envContent.includes("ROUNDHOUSE_DEBUG_STREAM=1") || envContent.includes('ROUNDHOUSE_DEBUG_STREAM="1"');
   } catch {}
 
-  // Read versions
   let roundhouseVersion = "unknown";
   let agentVersion = "unknown";
   try {
@@ -235,7 +236,6 @@ async function cmdStatus() {
     roundhouseVersion = pkg.version;
   } catch {}
 
-  // Resolve agent SDK version from registry
   const agentPkg = config ? getAgentSdkPackage(config.agent.type) : undefined;
   if (agentPkg) {
     try {
@@ -268,15 +268,22 @@ async function cmdStatus() {
   console.log();
 }
 
-function cmdLogs() {
-  const child = spawn("journalctl", ["-u", SERVICE_NAME, "-f", "--no-pager", "-n", "100"], {
-    stdio: "inherit",
-  });
-  child.on("error", () => console.log("Could not read logs. Is the daemon installed?"));
+async function cmdStop() {
+  const svc = getServiceManager();
+  const result = await svc.stop();
+  console.log(result.message);
+}
+
+async function cmdRestart() {
+  const svc = getServiceManager();
+  const result = await svc.restart();
+  console.log(result.message);
 }
 
-function cmdStop() { systemctl("stop", "Daemon stopped."); }
-function cmdRestart() { systemctl("restart", "Daemon restarted."); }
+async function cmdLogs() {
+  const svc = getServiceManager();
+  svc.logs();
+}
 
 async function cmdConfig() {
   console.log(`Config path: ${CONFIG_PATH}\n`);
@@ -371,162 +378,9 @@ Environment:
 
 // ── Main ────────────────────────────────────────────
 
-async function cmdAgent() {
-  // Usage: roundhouse agent <message>
-  //        roundhouse agent --thread <id> <message>
-  //        roundhouse agent --ephemeral <message>
-  //        echo "message" | roundhouse agent --stdin
-  const args = process.argv.slice(3);
-  let threadId = "";
-  let messageText = "";
-  let useStdin = false;
-  let timeoutMs = 120_000;
-  let verbose = false;
-  let ephemeral = false;
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--thread" && args[i + 1]) {
-      threadId = args[++i];
-    } else if (args[i] === "--stdin") {
-      useStdin = true;
-    } else if (args[i] === "--timeout" && args[i + 1]) {
-      const val = parseInt(args[++i], 10);
-      if (isNaN(val) || val <= 0) { console.error("--timeout must be a positive number (seconds)"); process.exit(1); }
-      timeoutMs = val * 1000;
-    } else if (args[i] === "--no-timeout") {
-      timeoutMs = 0;
-    } else if (args[i] === "--verbose") {
-      verbose = true;
-    } else if (args[i] === "--ephemeral") {
-      ephemeral = true;
-    } else if (args[i].startsWith("-")) {
-      console.error(`Unknown flag: ${args[i]}`);
-      process.exit(1);
-    } else {
-      messageText = args.slice(i).join(" ");
-      break;
-    }
-  }
-
-  if (useStdin) {
-    const chunks: Buffer[] = [];
-    let totalBytes = 0;
-    const MAX_INPUT = 1024 * 1024; // 1 MB
-    for await (const chunk of process.stdin) {
-      totalBytes += chunk.length;
-      if (totalBytes > MAX_INPUT) {
-        console.error(`Input exceeds ${MAX_INPUT / 1024}KB limit. Use a file instead.`);
-        process.exit(1);
-      }
-      chunks.push(chunk);
-    }
-    // Strip single trailing newline (shell echo adds one)
-    let raw = Buffer.concat(chunks).toString("utf8");
-    if (raw.endsWith("\n")) raw = raw.slice(0, -1);
-    messageText = raw;
-  }
-
-  if (!messageText) {
-    console.error("Usage: roundhouse agent <message>");
-    console.error("       roundhouse agent --thread <id> <message>");
-    console.error("       echo \"message\" | roundhouse agent --stdin");
-    console.error("       roundhouse agent --timeout 60 <message>");
-    console.error("       roundhouse agent --verbose <message>");
-    console.error("       roundhouse agent --ephemeral <message>");
-    process.exit(1);
-  }
-
-  if (threadId && ephemeral) {
-    console.error("--thread and --ephemeral cannot be used together");
-    process.exit(1);
-  }
-
-  // Default: shared main session. --ephemeral restores one-off CLI behavior.
-  if (!threadId) {
-    threadId = ephemeral
-      ? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-      : "main";
-  }
-
-  // Suppress debug/info logs unless --verbose
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const origError = console.error;
-  if (!verbose) {
-    console.log = () => {};
-    console.warn = () => {};
-  }
-
-  let agent: import("../types").AgentAdapter | undefined;
-  let aborted = false;
-
-  // Clean abort on SIGINT/SIGTERM
-  const handleSignal = async () => {
-    if (aborted) return;
-    aborted = true;
-    console.log = origLog;
-    console.warn = origWarn;
-    console.error = origError;
-    try { await agent?.abort?.(threadId); } catch {}
-    try { await agent?.dispose(); } catch {}
-    process.exit(130);
-  };
-  process.on("SIGINT", handleSignal);
-  process.on("SIGTERM", handleSignal);
-
-  // Timeout race
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeoutPromise = timeoutMs > 0
-    ? new Promise<never>((_, reject) => {
-        timer = setTimeout(async () => {
-          aborted = true;
-          try { await agent?.abort?.(threadId); } catch {}
-          reject(new Error(`Timeout after ${timeoutMs / 1000}s`));
-        }, timeoutMs);
-      })
-    : null;
-
-  try {
-    const config = await loadConfig();
-    const { getAgentFactory } = await import("../agents/registry");
-    const factory = getAgentFactory(config.agent.type);
-    agent = factory(config.agent);
-
-    const runAgent = async () => {
-      if (agent!.promptStream) {
-        for await (const event of agent!.promptStream(threadId, { text: messageText })) {
-          if (event.type === "text_delta") {
-            process.stdout.write(event.text);
-          }
-        }
-        process.stdout.write("\n");
-      } else {
-        const response = await agent!.prompt(threadId, { text: messageText });
-        origLog(response.text);
-      }
-    };
-
-    if (timeoutPromise) {
-      await Promise.race([runAgent(), timeoutPromise]);
-    } else {
-      await runAgent();
-    }
-  } catch (err: any) {
-    console.error = origError;
-    console.error(`Error: ${err.message}`);
-    process.exit(aborted ? 124 : 1); // 124 = timeout (like coreutils)
-  } finally {
-    if (timer) clearTimeout(timer);
-    process.off("SIGINT", handleSignal);
-    process.off("SIGTERM", handleSignal);
-    console.log = origLog;
-    console.warn = origWarn;
-    console.error = origError;
-    if (!aborted) await agent?.dispose();
-  }
-}
 
 import { cmdDoctor } from "./doctor";
+import { cmdAgent } from "./agent-command";
 import { cmdCron } from "./cron";
 import { cmdSetup, cmdPair } from "./setup";
 

package/src/cli/cron-commands.ts

@@ -0,0 +1,258 @@
+/**
+ * cli/cron-commands.ts — Individual cron subcommand handlers
+ *
+ * Each handler receives store, positional args, and flags.
+ * Extracted from the monolithic cmdCron switch statement.
+ */
+
+import { CronStore, validateJobId } from "../cron/store";
+import { isBuiltinJob } from "../cron/helpers";
+import { CronRunner } from "../cron/runner";
+import { validateSchedule } from "../cron/schedule";
+import { validateTemplate } from "../cron/template";
+import { parseDuration } from "../cron/durations";
+import type { CronJobConfig, CronSchedule } from "../cron/types";
+import { DEFAULT_TIMEOUT_MS, DEFAULT_TIMEZONE, VALID_NOTIFY_ON, DEFAULT_RUNS_LIMIT } from "../cron/constants";
+import { formatSchedule, formatRunCounts, formatJobSummary, formatJobDetail, formatRunLine, runStatusIcon, jobEnabledIcon } from "../cron/format";
+
+function rejectBuiltin(id: string): void {
+  if (isBuiltinJob(id)) {
+    console.error(`Job ID "${id}" is reserved for built-in jobs.`);
+    process.exit(1);
+  }
+}
+
+function validateNotifyOn(value?: string): "always" | "success" | "failure" {
+  const v = value ?? "always";
+  if (!(VALID_NOTIFY_ON as readonly string[]).includes(v)) {
+    console.error(`Invalid --notify-on: "${v}". Use ${VALID_NOTIFY_ON.join(", ")}.`);
+    process.exit(1);
+  }
+  return v as "always" | "success" | "failure";
+}
+
+export async function cronAdd(store: CronStore, positional: string[], flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron add <id> --prompt '...' --cron '...' --tz '...'"); process.exit(1); }
+  validateJobId(id);
+  rejectBuiltin(id);
+
+  const existing = await store.getJob(id);
+  if (existing && !flags.replace) {
+    console.error(`Job "${id}" already exists. Use --replace to overwrite.`);
+    process.exit(1);
+  }
+
+  const prompt = flags.prompt;
+  if (!prompt) { console.error("--prompt is required"); process.exit(1); }
+
+  const schedCount = [flags.cron, flags.every, flags.at].filter(Boolean).length;
+  if (schedCount > 1) { console.error("Specify only one of --cron, --every, or --at"); process.exit(1); }
+  let schedule: CronSchedule;
+  if (flags.cron) {
+    schedule = { type: "cron", cron: flags.cron, tz: flags.tz ?? DEFAULT_TIMEZONE };
+  } else if (flags.every) {
+    schedule = { type: "interval", every: flags.every };
+  } else if (flags.at) {
+    schedule = { type: "once", at: flags.at, tz: flags.tz };
+  } else {
+    console.error("Schedule required: --cron '...', --every '...', or --at '...'");
+    process.exit(1);
+  }
+
+  validateSchedule(schedule);
+
+  const vars: Record<string, string> = {};
+  if (flags.var) {
+    for (const v of flags.var.split(",")) {
+      const [k, ...rest] = v.split("=");
+      if (k && rest.length) vars[k.trim()] = rest.join("=").trim();
+    }
+  }
+
+  const templateErrors = validateTemplate(prompt, new Set(Object.keys(vars)));
+  if (templateErrors.length) {
+    console.error("Template errors:");
+    templateErrors.forEach((e) => console.error(`  ${e}`));
+    process.exit(1);
+  }
+
+  const notify: CronJobConfig["notify"] = {};
+  if (flags.telegram) {
+    notify.telegram = {
+      chatIds: flags.telegram.split(",").map((s) => s.trim()),
+      onlyOn: validateNotifyOn(flags["notify-on"]),
+    };
+  }
+
+  const now = new Date().toISOString();
+  const job: CronJobConfig = {
+    id,
+    enabled: true,
+    description: flags.description,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    schedule,
+    prompt,
+    vars: Object.keys(vars).length ? vars : undefined,
+    timeoutMs: flags.timeout ? parseDuration(flags.timeout) : undefined,
+    notify: Object.keys(notify).length ? notify : undefined,
+  };
+
+  await store.writeJob(job);
+  console.log(`✅ Cron job "${id}" ${existing ? "updated" : "created"}.`);
+  if (flags.json) console.log(JSON.stringify(job, null, 2));
+}
+
+export async function cronList(store: CronStore, _positional: string[], flags: Record<string, string>): Promise<void> {
+  const jobs = await store.listJobs();
+  if (jobs.length === 0) {
+    console.log("No cron jobs configured.");
+    return;
+  }
+  if (flags.json) {
+    console.log(JSON.stringify(jobs, null, 2));
+  } else {
+    for (const j of jobs) {
+      const state = await store.getState(j.id);
+      console.log(`  ${formatJobSummary(j, state)}`);
+    }
+  }
+}
+
+export async function cronShow(store: CronStore, positional: string[], flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron show <id>"); process.exit(1); }
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+  const state = await store.getState(id);
+  const runs = await store.listRuns(id, 5);
+  if (flags.json) {
+    console.log(JSON.stringify({ job, state, recentRuns: runs }, null, 2));
+  } else {
+    console.log(`\n${formatJobDetail(job, state, runs)}`);
+  }
+}
+
+export async function cronTrigger(store: CronStore, positional: string[], _flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron trigger <id>"); process.exit(1); }
+  rejectBuiltin(id);
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+  console.log(`Triggering ${id}...`);
+  const runner = new CronRunner(store);
+  const record = await runner.runJob(job, new Date(), "manual");
+  console.log(`\nResult: ${record.status} (${record.durationMs}ms)`);
+  if (record.responseText) console.log(`\n${record.responseText.slice(0, 2000)}`);
+  if (record.error) console.log(`\nError: ${record.error}`);
+  process.exit(record.status === "completed" ? 0 : 1);
+}
+
+export async function cronRuns(store: CronStore, positional: string[], flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron runs <id>"); process.exit(1); }
+  const runs = await store.listRuns(id, parseInt(flags.limit ?? String(DEFAULT_RUNS_LIMIT), 10));
+  if (runs.length === 0) {
+    console.log(`No runs for ${id}.`);
+  } else if (flags.json) {
+    console.log(JSON.stringify(runs, null, 2));
+  } else {
+    for (const r of runs) {
+      console.log(`  ${formatRunLine(r)} (${r.kind})`);
+    }
+  }
+}
+
+export async function cronPause(store: CronStore, positional: string[], _flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron pause <id>"); process.exit(1); }
+  rejectBuiltin(id);
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+  job.enabled = false;
+  job.updatedAt = new Date().toISOString();
+  await store.writeJob(job);
+  console.log(`⏸️ Job "${id}" paused.`);
+}
+
+export async function cronResume(store: CronStore, positional: string[], _flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron resume <id>"); process.exit(1); }
+  rejectBuiltin(id);
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+  job.enabled = true;
+  job.updatedAt = new Date().toISOString();
+  await store.writeJob(job);
+  console.log(`▶️ Job "${id}" resumed.`);
+}
+
+export async function cronEdit(store: CronStore, positional: string[], flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron edit <id> [--prompt '...'] [--cron '...'] ..."); process.exit(1); }
+  rejectBuiltin(id);
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+
+  if (flags.prompt) job.prompt = flags.prompt;
+  if (flags.description) job.description = flags.description;
+  if (flags.timeout) job.timeoutMs = parseDuration(flags.timeout);
+  const editSchedCount = [flags.cron, flags.every, flags.at].filter(Boolean).length;
+  if (editSchedCount > 1) { console.error("Specify only one of --cron, --every, or --at"); process.exit(1); }
+  if (flags.cron) job.schedule = { type: "cron", cron: flags.cron, tz: flags.tz ?? (job.schedule.type === "cron" ? job.schedule.tz : DEFAULT_TIMEZONE) };
+  if (flags.every) job.schedule = { type: "interval", every: flags.every };
+  if (flags.at) job.schedule = { type: "once", at: flags.at, tz: flags.tz };
+  if (flags.telegram) {
+    job.notify = { ...job.notify, telegram: { chatIds: flags.telegram.split(",").map((s) => s.trim()), onlyOn: validateNotifyOn(flags["notify-on"]) } };
+  }
+
+  validateSchedule(job.schedule);
+  const editVars = new Set(Object.keys(job.vars ?? {}));
+  const editErrors = validateTemplate(job.prompt, editVars);
+  if (editErrors.length) {
+    console.error("Template errors:");
+    editErrors.forEach((e) => console.error(`  ${e}`));
+    process.exit(1);
+  }
+  job.updatedAt = new Date().toISOString();
+  await store.writeJob(job);
+  console.log(`✅ Job "${id}" updated.`);
+}
+
+export async function cronDelete(store: CronStore, positional: string[], _flags: Record<string, string>): Promise<void> {
+  const id = positional[1];
+  if (!id) { console.error("Usage: roundhouse cron delete <id>"); process.exit(1); }
+  rejectBuiltin(id);
+  const job = await store.getJob(id);
+  if (!job) { console.error(`Job not found: ${id}`); process.exit(1); }
+  await store.deleteJob(id);
+  console.log(`🗑️ Job "${id}" deleted.`);
+}
+
+export function cronHelp(): void {
+  console.log(`roundhouse cron <command>
+
+Commands:
+  add <id> [flags]    Create a cron job
+  list                List all jobs
+  show <id>           Show job details
+  trigger <id>        Run job now
+  runs <id>           Show run history
+  edit <id> [flags]   Edit a job
+  pause <id>          Disable a job
+  resume <id>         Enable a job
+  delete <id>         Delete a job
+
+Flags for add/edit:
+  --prompt "..."      Prompt template (required for add)
+  --cron "..."        Cron expression (e.g. "0 8 * * *")
+  --every "..."       Interval (e.g. "6h")
+  --at "..."          One-shot time (e.g. "30m" or ISO date)
+  --tz "..."          Timezone (e.g. "Asia/Jerusalem")
+  --telegram "..."    Telegram chat IDs (comma-separated)
+  --var "k=v,..."      Template variables (comma-separated)
+  --timeout "..."     Timeout (e.g. "30m")
+  --description "..." Job description
+  --json              JSON output`);
+}