@inceptionstack/roundhouse 0.5.1 → 0.5.3

package/src/cli/cron.ts

@@ -1,32 +1,14 @@
 /**
- * cli/cron.ts — roundhouse cron CLI subcommands
+ * cli/cron.ts — roundhouse cron CLI dispatcher
+ *
+ * Parses args and dispatches to individual command handlers.
  */
 
-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";
-}
+import { CronStore } from "../cron/store";
+import {
+  cronAdd, cronList, cronShow, cronTrigger, cronRuns,
+  cronPause, cronResume, cronEdit, cronDelete, cronHelp,
+} from "./cron-commands";
 
 function parseArgs(args: string[]): { positional: string[]; flags: Record<string, string> } {
   const positional: string[] = [];
@@ -44,6 +26,19 @@ function parseArgs(args: string[]): { positional: string[]; flags: Record<string
   return { positional, flags };
 }
 
+const COMMANDS: Record<string, (store: CronStore, pos: string[], flags: Record<string, string>) => Promise<void>> = {
+  add: cronAdd,
+  list: cronList,
+  show: cronShow,
+  trigger: cronTrigger,
+  run: cronTrigger,
+  runs: cronRuns,
+  pause: cronPause,
+  resume: cronResume,
+  edit: cronEdit,
+  delete: cronDelete,
+};
+
 export async function cmdCron(args: string[]): Promise<void> {
   const { positional, flags } = parseArgs(args);
   const sub = positional[0];
@@ -51,246 +46,10 @@ export async function cmdCron(args: string[]): Promise<void> {
   const store = new CronStore();
   await store.ensureDirs();
 
-  switch (sub) {
-    case "add": {
-      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); }
-
-      // Parse schedule — only one allowed
-      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);
-
-      // Parse vars
-      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();
-        }
-      }
-
-      // Validate template
-      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);
-      }
-
-      // Parse notify
-      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));
-      break;
-    }
-
-    case "list": {
-      const jobs = await store.listJobs();
-      if (jobs.length === 0) {
-        console.log("No cron jobs configured.");
-        break;
-      }
-      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)}`);
-        }
-      }
-      break;
-    }
-
-    case "show": {
-      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)}`);
-      }
-      break;
-    }
-
-    case "trigger":
-    case "run": {
-      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);
-      break;
-    }
-
-    case "runs": {
-      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})`);
-        }
-      }
-      break;
-    }
-
-    case "pause": {
-      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.`);
-      break;
-    }
-
-    case "resume": {
-      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.`);
-      break;
-    }
-
-    case "edit": {
-      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);
-      // Reject multiple schedule flags
-      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);
-      // Validate template after edit
-      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.`);
-      break;
-    }
-
-    case "delete": {
-      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.`);
-      break;
-    }
-
-    default:
-      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`);
+  const handler = sub && Object.hasOwn(COMMANDS, sub) ? COMMANDS[sub] : undefined;
+  if (handler) {
+    await handler(store, positional, flags);
+  } else {
+    cronHelp();
   }
 }

package/src/cli/launchd.ts

@@ -0,0 +1,144 @@
+/**
+ * launchd.ts — macOS launchd service management for roundhouse
+ *
+ * Generates and installs a LaunchAgent plist so roundhouse
+ * auto-starts on login and can be managed via launchctl.
+ */
+
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { whichSync } from "./shell";
+import { ROUNDHOUSE_DIR } from "../config";
+const __dirname = new URL(".", import.meta.url).pathname.replace(/\/$/, "");
+
+const LABEL = "com.inceptionstack.roundhouse";
+const PLIST_DIR = resolve(homedir(), "Library", "LaunchAgents");
+export const PLIST_PATH = resolve(PLIST_DIR, `${LABEL}.plist`);
+/**
+ * Generate a LaunchAgent plist for roundhouse.
+ */
+export function generatePlist(): string {
+  const nodeBin = whichSync("node") || process.execPath;
+  const roundhouseBin = whichSync("roundhouse");
+
+  let programArgs: string[];
+  if (roundhouseBin) {
+    programArgs = [nodeBin, roundhouseBin, "run"];
+  } else {
+    // Fallback: tsx path
+    const tsxBin = whichSync("tsx") || resolve(__dirname, "..", "..", "node_modules", ".bin", "tsx");
+    const cliPath = resolve(__dirname, "cli.ts");
+    programArgs = [nodeBin, tsxBin, cliPath, "run"];
+  }
+
+  const logDir = resolve(ROUNDHOUSE_DIR, "logs");
+  let envSection = "";
+  const envVars: Record<string, string> = {
+    HOME: homedir(),
+    PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin",
+    ROUNDHOUSE_CONFIG: resolve(ROUNDHOUSE_DIR, "gateway.config.json"),
+    NODE_NO_WARNINGS: "1",
+  };
+
+  envSection = Object.entries(envVars)
+    .map(([k, v]) => `      <key>${escapeXml(k)}</key>\n      <string>${escapeXml(v)}</string>`)
+    .join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+${programArgs.map(a => `        <string>${escapeXml(a)}</string>`).join("\n")}
+    </array>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+${envSection}
+    </dict>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>${escapeXml(resolve(logDir, "roundhouse.log"))}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(resolve(logDir, "roundhouse.err"))}</string>
+
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(homedir())}</string>
+
+    <key>ThrottleInterval</key>
+    <integer>5</integer>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Install the plist and load the service.
+ */
+export async function installLaunchAgent(): Promise<void> {
+  await mkdir(PLIST_DIR, { recursive: true });
+  await mkdir(resolve(ROUNDHOUSE_DIR, "logs"), { recursive: true });
+
+  const plist = generatePlist();
+  await writeFile(PLIST_PATH, plist, { mode: 0o644 });
+
+  // Unload first if already loaded (ignore errors)
+  try {
+    execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+  } catch {}
+
+  // Load the agent
+  execFileSync("launchctl", ["load", PLIST_PATH], { stdio: "pipe" });
+}
+
+/**
+ * Unload and remove the launch agent.
+ */
+export async function uninstallLaunchAgent(): Promise<void> {
+  try {
+    execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+  } catch {}
+
+  const { unlink } = await import("node:fs/promises");
+  try {
+    await unlink(PLIST_PATH);
+  } catch {}
+}
+
+/**
+ * Check if the launch agent is loaded and running.
+ */
+export function isLaunchAgentRunning(): boolean {
+  try {
+    const output = execFileSync("launchctl", ["list", LABEL], { encoding: "utf8", stdio: "pipe" });
+    return output.includes(LABEL);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if the plist file exists.
+ */
+export function isLaunchAgentInstalled(): boolean {
+  return existsSync(PLIST_PATH);
+}
+
+function escapeXml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+

package/src/cli/service-manager.ts

@@ -0,0 +1,192 @@
+/**
+ * cli/service-manager.ts — Platform-specific service lifecycle management
+ *
+ * Abstracts the difference between macOS (launchd) and Linux (systemd)
+ * behind a single interface. CLI commands delegate to getServiceManager()
+ * instead of branching on process.platform in every function.
+ */
+
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { SERVICE_NAME } from "../config";
+
+// ── Interface ────────────────────────────────────────
+
+export interface ServiceStatus {
+  running: boolean;
+  installed: boolean;
+  message: string;
+}
+
+export interface ServiceManager {
+  /** Start the service (load agent / start daemon) */
+  start(): Promise<{ started: boolean; message: string }>;
+  /** Stop the service */
+  stop(): Promise<{ message: string }>;
+  /** Restart the service (stop + start) */
+  restart(): Promise<{ message: string }>;
+  /** Get current service status */
+  status(): Promise<ServiceStatus>;
+  /** Tail logs (spawns a child process, returns it) */
+  logs(): void;
+  /** Uninstall the service (remove plist / unit file) */
+  uninstall(): Promise<{ message: string }>;
+}
+
+// ── LaunchdManager (macOS) ───────────────────────────
+
+class LaunchdManager implements ServiceManager {
+  private get plistPath(): string {
+    return resolve(homedir(), "Library", "LaunchAgents", "com.inceptionstack.roundhouse.plist");
+  }
+
+  private get label(): string {
+    return "com.inceptionstack.roundhouse";
+  }
+
+  private isInstalled(): boolean {
+    return existsSync(this.plistPath);
+  }
+
+  private isRunning(): boolean {
+    try {
+      const output = execFileSync("launchctl", ["list", this.label], { encoding: "utf8", stdio: "pipe" });
+      return output.includes(this.label);
+    } catch {
+      return false;
+    }
+  }
+
+  async start(): Promise<{ started: boolean; message: string }> {
+    if (!this.isInstalled()) {
+      return { started: false, message: "no-service" };
+    }
+    if (this.isRunning()) {
+      return { started: false, message: "Roundhouse is already running (LaunchAgent)." };
+    }
+    try {
+      execFileSync("launchctl", ["load", this.plistPath], { stdio: "pipe" });
+      return { started: true, message: "LaunchAgent started." };
+    } catch {
+      return { started: false, message: "Failed to load LaunchAgent." };
+    }
+  }
+
+  async stop(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed. Nothing to stop." };
+    }
+    try {
+      execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" });
+    } catch (e: any) {
+      if (!e.message?.includes("Could not find")) {
+        return { message: `(unload warning: ${e.message?.split("\n")[0]})` };
+      }
+    }
+    return { message: "LaunchAgent stopped." };
+  }
+
+  async restart(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed. Run: roundhouse setup --telegram" };
+    }
+    try { execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" }); } catch {}
+    execFileSync("launchctl", ["load", this.plistPath], { stdio: "pipe" });
+    return { message: "LaunchAgent restarted." };
+  }
+
+  async status(): Promise<ServiceStatus> {
+    if (this.isRunning()) {
+      return { running: true, installed: true, message: "Roundhouse is running (LaunchAgent)." };
+    }
+    if (this.isInstalled()) {
+      return { running: false, installed: true, message: "LaunchAgent installed but not running." };
+    }
+    return { running: false, installed: false, message: "Roundhouse is not running." };
+  }
+
+  logs(): void {
+    const logPath = resolve(homedir(), ".roundhouse", "logs", "roundhouse.log");
+    const child = spawn("tail", ["-f", "-n", "100", logPath], { stdio: "inherit" });
+    child.on("error", () => console.log("Could not read logs. Check ~/.roundhouse/logs/"));
+  }
+
+  async uninstall(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed." };
+    }
+    try { execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" }); } catch {}
+    const { unlink } = await import("node:fs/promises");
+    try { await unlink(this.plistPath); } catch {}
+    return { message: "LaunchAgent removed." };
+  }
+}
+
+// ── SystemdManager (Linux) ───────────────────────────
+
+class SystemdManager implements ServiceManager {
+  async start(): Promise<{ started: boolean; message: string }> {
+    const { isServiceInstalled, isServiceActive, systemctl } = await import("./systemd");
+    if (!isServiceInstalled()) {
+      return { started: false, message: "no-service" }; // Signal to caller: fall through to foreground
+    }
+    if (isServiceActive()) {
+      return { started: false, message: "Roundhouse is already running." };
+    }
+    systemctl("start", "Daemon started.");
+    return { started: true, message: "Daemon started." };
+  }
+
+  async stop(): Promise<{ message: string }> {
+    const { systemctl } = await import("./systemd");
+    systemctl("stop", "Daemon stopped.");
+    return { message: "Daemon stopped." };
+  }
+
+  async restart(): Promise<{ message: string }> {
+    const { systemctl } = await import("./systemd");
+    systemctl("restart", "Daemon restarted.");
+    return { message: "Daemon restarted." };
+  }
+
+  async status(): Promise<ServiceStatus> {
+    const { isServiceActive, isServiceInstalled } = await import("./systemd");
+    if (isServiceActive()) {
+      return { running: true, installed: true, message: "Roundhouse is running." };
+    }
+    if (isServiceInstalled()) {
+      return { running: false, installed: true, message: "Service installed but not running." };
+    }
+    return { running: false, installed: false, message: "Roundhouse is not running." };
+  }
+
+  logs(): void {
+    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 uninstall(): Promise<{ message: string }> {
+    const { systemctl, runSudo, SERVICE_PATH } = await import("./systemd");
+    try { systemctl("stop"); } catch {}
+    try { systemctl("disable"); } catch {}
+    try { runSudo("rm", "-f", SERVICE_PATH); } catch {}
+    runSudo("systemctl", "daemon-reload");
+    return { message: "Daemon removed." };
+  }
+}
+
+// ── Factory ──────────────────────────────────────────
+
+/**
+ * Get the appropriate service manager for the current platform.
+ */
+export function getServiceManager(): ServiceManager {
+  if (process.platform === "darwin") {
+    return new LaunchdManager();
+  }
+  return new SystemdManager();
+}