crontick 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,879 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_node_child_process2 = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_url = require("url");
+var import_node_path3 = require("path");
+var import_node_readline = require("readline");
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/paths.ts
+var import_env_paths = __toESM(require("env-paths"), 1);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function root() {
+  const override = process.env["CRONTICK_HOME"];
+  if (override) return override;
+  return (0, import_env_paths.default)("crontick", { suffix: "" }).data;
+}
+function dataDir() {
+  return root();
+}
+function jobsDir() {
+  return (0, import_node_path.join)(root(), "jobs");
+}
+function logsDir() {
+  return (0, import_node_path.join)(root(), "logs");
+}
+function pidFilePath() {
+  return (0, import_node_path.join)(root(), "daemon.pid");
+}
+function portFilePath() {
+  return (0, import_node_path.join)(root(), "daemon.port");
+}
+function autostartDir() {
+  return (0, import_node_path.join)(root(), "autostart");
+}
+function ensureDirs() {
+  for (const dir of [dataDir(), jobsDir(), logsDir()]) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+}
+
+// src/schemas/job.ts
+var import_zod = require("zod");
+var CronScheduleSchema = import_zod.z.object({
+  kind: import_zod.z.literal("cron"),
+  cron: import_zod.z.string().min(1),
+  tz: import_zod.z.string().optional()
+});
+var IntervalScheduleSchema = import_zod.z.object({
+  kind: import_zod.z.literal("interval"),
+  everySec: import_zod.z.number().positive(),
+  startAt: import_zod.z.string().optional()
+  // ISO-8601
+});
+var OneShotScheduleSchema = import_zod.z.object({
+  kind: import_zod.z.literal("one-shot"),
+  runAt: import_zod.z.string().min(1)
+  // ISO-8601
+});
+var ScheduleSchema = import_zod.z.discriminatedUnion("kind", [
+  CronScheduleSchema,
+  IntervalScheduleSchema,
+  OneShotScheduleSchema
+]);
+var ScriptActionSchema = import_zod.z.object({
+  kind: import_zod.z.literal("script"),
+  script: import_zod.z.string().min(1),
+  shell: import_zod.z.enum(["auto", "bash", "pwsh", "cmd"]).default("auto"),
+  cwd: import_zod.z.string().optional(),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  envFile: import_zod.z.string().optional(),
+  timeoutSec: import_zod.z.number().positive().optional()
+});
+var ExecActionSchema = import_zod.z.object({
+  kind: import_zod.z.literal("exec"),
+  command: import_zod.z.string().min(1),
+  args: import_zod.z.array(import_zod.z.string()).default([]),
+  cwd: import_zod.z.string().optional(),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  envFile: import_zod.z.string().optional(),
+  timeoutSec: import_zod.z.number().positive().optional()
+  // shell is intentionally absent: exec always uses shell=false to prevent injection
+});
+var ActionSchema = import_zod.z.discriminatedUnion("kind", [ScriptActionSchema, ExecActionSchema]);
+var RetrySchema = import_zod.z.object({
+  max: import_zod.z.number().int().min(0).default(0),
+  backoffSec: import_zod.z.number().positive().default(30)
+});
+var BudgetsSchema = import_zod.z.object({
+  maxRunsPerDay: import_zod.z.number().int().positive().nullable().default(null),
+  maxTokensPerRun: import_zod.z.number().int().positive().nullable().default(null)
+});
+var kebabCase = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var JobSchema = import_zod.z.object({
+  id: import_zod.z.string().regex(kebabCase, 'Job ID must be kebab-case (e.g. "my-job")'),
+  description: import_zod.z.string().optional(),
+  enabled: import_zod.z.boolean().default(true),
+  schedule: ScheduleSchema,
+  action: ActionSchema,
+  catchup: import_zod.z.enum(["run-once", "run-all", "skip"]).default("skip"),
+  overlap: import_zod.z.enum(["skip", "queue", "cancel-previous"]).default("skip"),
+  retry: RetrySchema.default({ max: 0, backoffSec: 30 }),
+  budgets: BudgetsSchema.default({ maxRunsPerDay: null, maxTokensPerRun: null })
+});
+
+// src/errors.ts
+var CrontickError = class _CrontickError extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "CrontickError";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, _CrontickError.prototype);
+  }
+  toJSON() {
+    return { code: this.code, message: this.message, details: this.details };
+  }
+};
+
+// src/autostart/win32.ts
+var import_node_child_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var RUN_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+function getValueName() {
+  return process.env["CRONTICK_AUTOSTART_TEST_VALUE"] ?? "crontick-daemon";
+}
+function getVbsPath() {
+  return (0, import_node_path2.join)(autostartDir(), "crontick-daemon.vbs");
+}
+function findDaemonBinary() {
+  const override = process.env["CRONTICK_DAEMON_BINARY"];
+  if (override) return override;
+  const whereResult = (0, import_node_child_process.spawnSync)("where.exe", ["crontick-daemon"], {
+    encoding: "utf-8",
+    timeout: 5e3,
+    windowsHide: true
+  });
+  if (whereResult.status === 0 && whereResult.stdout.trim()) {
+    const first = whereResult.stdout.trim().split(/[\r\n]+/)[0]?.trim();
+    if (first) return first;
+  }
+  const nodeDir = (0, import_node_path2.dirname)(process.execPath);
+  for (const candidate of ["crontick-daemon.cmd", "crontick-daemon"]) {
+    const p = (0, import_node_path2.join)(nodeDir, candidate);
+    if ((0, import_node_fs2.existsSync)(p)) return p;
+  }
+  return null;
+}
+function buildVbsContent(daemonPath) {
+  const safePath = daemonPath.replace(/"/g, "");
+  return [
+    "' crontick-daemon autostart shim \u2014 generated by crontick autostart install",
+    "' Do not edit manually. Run: crontick autostart install to regenerate.",
+    'Set WshShell = CreateObject("WScript.Shell")',
+    `WshShell.Run "cmd /c ""${safePath}""", 0, False`,
+    ""
+  ].join("\r\n");
+}
+function regQuery(valueName) {
+  const result = (0, import_node_child_process.spawnSync)(
+    "reg",
+    ["query", RUN_KEY, "/v", valueName],
+    { encoding: "utf-8", timeout: 5e3, windowsHide: true }
+  );
+  if (result.status !== 0 || !result.stdout) return null;
+  const match = result.stdout.match(/REG_SZ\s+(.+)/i);
+  return match?.[1]?.trim() ?? null;
+}
+function regWrite(valueName, data) {
+  const result = (0, import_node_child_process.spawnSync)(
+    "reg",
+    ["add", RUN_KEY, "/v", valueName, "/t", "REG_SZ", "/d", data, "/f"],
+    { encoding: "utf-8", timeout: 5e3, windowsHide: true }
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      `reg.exe add failed (exit ${result.status ?? "?"}): ${result.stderr?.trim() ?? "unknown error"}`
+    );
+  }
+}
+function regDelete(valueName) {
+  (0, import_node_child_process.spawnSync)(
+    "reg",
+    ["delete", RUN_KEY, "/v", valueName, "/f"],
+    { encoding: "utf-8", timeout: 5e3, windowsHide: true }
+  );
+}
+var Win32Autostart = class {
+  async install() {
+    const daemonPath = findDaemonBinary();
+    if (!daemonPath) {
+      throw new Error(
+        "crontick-daemon binary not found. Ensure crontick is installed globally: npm i -g crontick"
+      );
+    }
+    const vbsPath = getVbsPath();
+    const valueName = getValueName();
+    (0, import_node_fs2.mkdirSync)(autostartDir(), { recursive: true });
+    (0, import_node_fs2.writeFileSync)(vbsPath, buildVbsContent(daemonPath), "utf-8");
+    regDelete(valueName);
+    regWrite(valueName, `wscript.exe "${vbsPath}"`);
+    return { ok: true };
+  }
+  async remove() {
+    const valueName = getValueName();
+    regDelete(valueName);
+    const vbsPath = getVbsPath();
+    if ((0, import_node_fs2.existsSync)(vbsPath)) {
+      try {
+        (0, import_node_fs2.unlinkSync)(vbsPath);
+      } catch {
+      }
+    }
+    return { ok: true };
+  }
+  async status() {
+    const valueName = getValueName();
+    const data = regQuery(valueName);
+    const installed = data !== null;
+    return {
+      installed,
+      backend: "win32",
+      details: installed ? { registryValue: valueName, registryData: data, vbsPath: getVbsPath() } : { registryValue: valueName }
+    };
+  }
+};
+
+// src/autostart/manual.ts
+function instructions() {
+  switch (process.platform) {
+    case "win32":
+      return "Windows: add the following command to your startup folder or HKCU Run key:\n  crontick-daemon\nOr run: crontick autostart install  (uses HKCU Run + hidden VBS shim)";
+    case "darwin":
+      return "macOS (post-v1): create a launchd plist at\n  ~/Library/LaunchAgents/com.crontick.daemon.plist\nwith ProgramArguments pointing to the crontick-daemon binary.\nThen run: launchctl load ~/Library/LaunchAgents/com.crontick.daemon.plist\n\nFor now, add the following to your shell profile (~/.zprofile or ~/.bash_profile):\n  crontick-daemon &";
+    case "linux":
+      return "Linux (post-v1): create a systemd user unit at\n  ~/.config/systemd/user/crontick.service\nThen run: systemctl --user enable --now crontick.service\n\nFor now, add the following to your shell profile (~/.profile or ~/.bashrc):\n  crontick-daemon &\nOr add a @reboot crontab entry: crontab -e\n  @reboot crontick-daemon";
+    default:
+      return "Add `crontick-daemon` to your system startup mechanism.\nThe daemon listens on a random localhost port; the port is written to the data directory.";
+  }
+}
+var ManualAutostart = class {
+  async install() {
+    return { ok: true };
+  }
+  async remove() {
+    return { ok: true };
+  }
+  async status() {
+    return {
+      installed: false,
+      backend: "manual",
+      details: { instructions: instructions() }
+    };
+  }
+};
+
+// src/autostart/darwin.ts
+var DarwinAutostart = class {
+  async install() {
+    throw new NotImplementedInV1Error(
+      "darwin autostart is planned for post-v1; use manual for now. See https://github.com/crontick/crontick for updates."
+    );
+  }
+  async remove() {
+    throw new NotImplementedInV1Error(
+      "darwin autostart is planned for post-v1; use manual for now."
+    );
+  }
+  async status() {
+    throw new NotImplementedInV1Error(
+      "darwin autostart is planned for post-v1; use manual for now."
+    );
+  }
+};
+
+// src/autostart/linux.ts
+var LinuxAutostart = class {
+  async install() {
+    throw new NotImplementedInV1Error(
+      "linux autostart is planned for post-v1; use manual for now. See https://github.com/crontick/crontick for updates."
+    );
+  }
+  async remove() {
+    throw new NotImplementedInV1Error(
+      "linux autostart is planned for post-v1; use manual for now."
+    );
+  }
+  async status() {
+    throw new NotImplementedInV1Error(
+      "linux autostart is planned for post-v1; use manual for now."
+    );
+  }
+};
+
+// src/autostart/index.ts
+var NotImplementedInV1Error = class _NotImplementedInV1Error extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotImplementedInV1Error";
+    Object.setPrototypeOf(this, _NotImplementedInV1Error.prototype);
+  }
+};
+function createAutostart(opts) {
+  const backend = opts?.backend ?? (process.platform === "win32" ? "win32" : "manual");
+  switch (backend) {
+    case "win32":
+      return new Win32Autostart();
+    case "darwin":
+      return new DarwinAutostart();
+    case "linux":
+      return new LinuxAutostart();
+    case "manual":
+    default:
+      return new ManualAutostart();
+  }
+}
+
+// src/cli/index.ts
+var import_meta = {};
+var __dirname = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+function getPort() {
+  const pf = portFilePath();
+  if (!(0, import_node_fs3.existsSync)(pf)) {
+    throw new CrontickError(
+      "DAEMON_NOT_RUNNING",
+      "Daemon is not running. Start it with: crontick daemon start"
+    );
+  }
+  const port = parseInt((0, import_node_fs3.readFileSync)(pf, "utf-8").trim(), 10);
+  if (isNaN(port)) {
+    throw new CrontickError("DAEMON_NOT_RUNNING", "Could not read daemon port file");
+  }
+  return port;
+}
+async function api(method, path, body) {
+  const port = getPort();
+  const url = `http://127.0.0.1:${port}${path}`;
+  const options = {
+    method,
+    headers: { "Content-Type": "application/json" }
+  };
+  if (body !== void 0) options.body = JSON.stringify(body);
+  const res = await fetch(url, options);
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new CrontickError("PARSE_ERROR", `Unexpected response: ${text.slice(0, 200)}`);
+  }
+  if (!res.ok) {
+    const err = data?.error;
+    throw new CrontickError(err?.code ?? "API_ERROR", err?.message ?? `HTTP ${res.status}`);
+  }
+  return data;
+}
+function print(data, useJson) {
+  if (useJson) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log("(no items)");
+      return;
+    }
+    const rows = data;
+    const keys = Object.keys(rows[0]);
+    console.log(keys.join("	"));
+    for (const row of rows) {
+      console.log(
+        keys.map((k) => {
+          const v = row[k];
+          return v !== null && typeof v === "object" ? JSON.stringify(v) : String(v ?? "");
+        }).join("	")
+      );
+    }
+  } else if (data !== null && typeof data === "object") {
+    const obj = data;
+    for (const [key, value] of Object.entries(obj)) {
+      const display = value !== null && typeof value === "object" ? JSON.stringify(value) : String(value ?? "");
+      console.log(`${key}: ${display}`);
+    }
+  } else {
+    console.log(String(data ?? ""));
+  }
+}
+function handleError(err) {
+  if (err instanceof CrontickError) {
+    console.error(`Error [${err.code}]: ${err.message}`);
+  } else {
+    console.error(`Error: ${String(err)}`);
+  }
+  process.exit(1);
+}
+function daemonScript() {
+  return (0, import_node_path3.resolve)(__dirname, "../daemon/index.js");
+}
+function waitForPort(timeout = 1e4) {
+  const start = Date.now();
+  return new Promise((resolve2, reject) => {
+    const check = () => {
+      try {
+        const port = getPort();
+        resolve2(port);
+      } catch {
+        if (Date.now() - start > timeout) {
+          reject(new CrontickError("DAEMON_TIMEOUT", "Timed out waiting for daemon to start"));
+        } else {
+          setTimeout(check, 200);
+        }
+      }
+    };
+    check();
+  });
+}
+var program = new import_commander.Command();
+program.name("crontick").description("A standalone cron daemon, CLI, and MCP server for local scheduled jobs.").version(VERSION).option("--json", "Output as JSON");
+program.command("new <id>").description("Create a new job").option("--cron <expr>", 'Cron expression (e.g. "0 9 * * *")').option("--every <sec>", "Interval in seconds", parseInt).option("--at <iso>", "One-shot run-at ISO-8601 time").option("--tz <tz>", "Timezone for cron schedule").option("--script <body>", "Inline script body").option("--exec <cmd>", "Command to exec (use -- for args)").option("--file <path>", "Load full job from JSON file").option("--shell <shell>", "Shell: auto|bash|pwsh|cmd", "auto").option("--env-file <path>", "Load extra environment variables from a .env file").option("--timeout <sec>", "Timeout in seconds", parseInt).option("--overlap <policy>", "Overlap policy: skip|queue|cancel-previous", "skip").option("--retry <max>", "Retry count", parseInt).option("--desc <description>", "Job description").action(async (id, opts) => {
+  try {
+    let jobData;
+    if (opts.file) {
+      const raw = (0, import_node_fs3.readFileSync)((0, import_node_path3.resolve)(process.cwd(), opts.file), "utf-8");
+      jobData = JSON.parse(raw);
+    } else {
+      let schedule;
+      if (opts.cron) {
+        schedule = { kind: "cron", cron: opts.cron, tz: opts.tz };
+      } else if (opts.every) {
+        schedule = { kind: "interval", everySec: opts.every };
+      } else if (opts.at) {
+        schedule = { kind: "one-shot", runAt: opts.at };
+      } else {
+        throw new CrontickError("MISSING_ARG", "Provide --cron, --every <sec>, or --at <iso>");
+      }
+      let action;
+      if (opts.script) {
+        action = {
+          kind: "script",
+          script: opts.script,
+          shell: opts.shell,
+          envFile: opts.envFile,
+          timeoutSec: opts.timeout
+        };
+      } else if (opts.exec) {
+        const parts = opts.exec.split(/\s+/);
+        action = {
+          kind: "exec",
+          command: parts[0],
+          args: parts.slice(1),
+          envFile: opts.envFile,
+          timeoutSec: opts.timeout
+        };
+      } else {
+        throw new CrontickError("MISSING_ARG", "Provide --script or --exec");
+      }
+      jobData = {
+        id,
+        description: opts.desc,
+        schedule,
+        action,
+        overlap: opts.overlap,
+        retry: opts.retry !== void 0 ? { max: opts.retry, backoffSec: 30 } : void 0
+      };
+    }
+    const parsed = JobSchema.safeParse(jobData);
+    if (!parsed.success) {
+      throw new CrontickError("VALIDATION_ERROR", "Invalid job", parsed.error.format());
+    }
+    const result = await api("POST", "/api/jobs", parsed.data);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("list").description("List all jobs").action(async () => {
+  try {
+    const jobs = await api("GET", "/api/jobs");
+    print(jobs, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("get <id>").description("Get a job by ID").action(async (id) => {
+  try {
+    const job = await api("GET", `/api/jobs/${encodeURIComponent(id)}`);
+    print(job, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("enable <id>").description("Enable a job").action(async (id) => {
+  try {
+    const result = await api("POST", `/api/jobs/${encodeURIComponent(id)}/enable`);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("disable <id>").description("Disable a job").action(async (id) => {
+  try {
+    const result = await api("POST", `/api/jobs/${encodeURIComponent(id)}/disable`);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("delete <id>").description("Delete a job").action(async (id) => {
+  try {
+    const result = await api("DELETE", `/api/jobs/${encodeURIComponent(id)}`);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("run-now <id>").description("Trigger an immediate run of a job").action(async (id) => {
+  try {
+    const result = await api("POST", `/api/jobs/${encodeURIComponent(id)}/run`);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("logs <runId>").description("Get logs for a run").option("--follow", "Follow (SSE stream) \u2014 not implemented in CLI yet; use --tail").option("--tail <n>", "Show last N lines", parseInt).action(async (runId, opts) => {
+  try {
+    const useJson = !!program.opts().json;
+    const logs = await api("GET", `/api/runs/${encodeURIComponent(runId)}/logs`);
+    const lines = Array.isArray(logs) ? logs : [];
+    const tail = opts.tail;
+    const display = tail ? lines.slice(-tail) : lines;
+    if (useJson) {
+      console.log(JSON.stringify(display, null, 2));
+    } else {
+      for (const entry of display) {
+        process.stdout.write(`[${entry.stream}] ${entry.data}`);
+      }
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("export").description("Export all jobs").option("--out <file>", "Output file (default: stdout)").action(async (opts) => {
+  try {
+    const data = await api("GET", "/api/export");
+    const json = JSON.stringify(data, null, 2);
+    if (opts.out) {
+      (0, import_node_fs3.writeFileSync)((0, import_node_path3.resolve)(process.cwd(), opts.out), json, "utf-8");
+      console.log(`Exported to ${opts.out}`);
+    } else {
+      console.log(json);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("import <file>").description("Import jobs from a JSON file").action(async (file) => {
+  try {
+    const raw = (0, import_node_fs3.readFileSync)((0, import_node_path3.resolve)(process.cwd(), file), "utf-8");
+    const data = JSON.parse(raw);
+    const result = await api("POST", "/api/import", data);
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("doctor").description("Check system health").action(async () => {
+  const checks = [];
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  checks.push({
+    name: "Node.js >= 22.5",
+    ok: major >= 22,
+    note: `v${process.versions.node}`
+  });
+  try {
+    const { DatabaseSync } = await import("node:sqlite");
+    new DatabaseSync(":memory:").close();
+    checks.push({ name: "node:sqlite", ok: true });
+  } catch (err) {
+    checks.push({ name: "node:sqlite", ok: false, note: String(err) });
+  }
+  try {
+    ensureDirs();
+    checks.push({ name: "data dir writable", ok: true });
+  } catch (err) {
+    checks.push({ name: "data dir writable", ok: false, note: String(err) });
+  }
+  const portFile = portFilePath();
+  const portFileExists = (0, import_node_fs3.existsSync)(portFile);
+  checks.push({ name: "port file readable", ok: portFileExists, note: portFileExists ? portFile : "not found" });
+  try {
+    await api("GET", "/health");
+    checks.push({ name: "daemon reachable", ok: true });
+  } catch {
+    checks.push({ name: "daemon reachable", ok: false, note: "not running" });
+  }
+  try {
+    const port2 = getPort();
+    const dashRes = await fetch(`http://127.0.0.1:${port2}/dashboard`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    const text = await dashRes.text();
+    checks.push({
+      name: "dashboard reachable",
+      ok: dashRes.status === 200 && text.includes("crontick"),
+      note: dashRes.status === 200 ? "ok" : `HTTP ${dashRes.status}`
+    });
+  } catch {
+    checks.push({ name: "dashboard reachable", ok: false, note: "daemon not running or no dashboard" });
+  }
+  try {
+    const asResult = await api("GET", "/api/autostart/status");
+    const as = asResult;
+    checks.push({
+      name: "autostart",
+      ok: true,
+      note: `backend=${as.backend ?? "?"}, installed=${String(as.installed ?? false)}`
+    });
+  } catch {
+    checks.push({ name: "autostart", ok: false, note: "could not check (daemon not running)" });
+  }
+  const mcpScript = (0, import_node_path3.resolve)(__dirname, "../mcp/index.js");
+  checks.push({
+    name: "MCP server binary",
+    ok: (0, import_node_fs3.existsSync)(mcpScript),
+    note: mcpScript
+  });
+  try {
+    const result = (0, import_node_child_process2.spawnSync)(process.execPath, [mcpScript, "--help"], {
+      timeout: 5e3,
+      encoding: "utf-8",
+      env: { ...process.env, CRONTICK_MCP_NO_AUTOSTART: "1" }
+    });
+    const helpOk = result.status === 0 || (result.stdout ?? "").includes("stdio");
+    checks.push({ name: "MCP server --help", ok: helpOk });
+  } catch (err) {
+    checks.push({ name: "MCP server --help", ok: false, note: String(err) });
+  }
+  for (const c of checks) {
+    const icon = c.ok ? "\u2713" : "\u2717";
+    console.log(`${icon} ${c.name}${c.note ? ` (${c.note})` : ""}`);
+  }
+  const failed = checks.filter((c) => !c.ok);
+  if (failed.length > 0) process.exit(1);
+});
+var daemon = program.command("daemon").description("Manage the crontick daemon");
+daemon.command("start").description("Start the daemon (detached by default)").option("--foreground", "Run in foreground (blocking)").action(async (opts) => {
+  try {
+    const script = daemonScript();
+    if (!(0, import_node_fs3.existsSync)(script)) {
+      throw new CrontickError("NOT_BUILT", `Daemon script not found: ${script}. Run: npm run build`);
+    }
+    if (opts.foreground) {
+      const result = (0, import_node_child_process2.spawnSync)(process.execPath, [script], {
+        stdio: "inherit",
+        env: process.env
+      });
+      process.exit(result.status ?? 0);
+    } else {
+      const child = (0, import_node_child_process2.spawn)(process.execPath, [script], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+      });
+      child.unref();
+      console.log(`Starting daemon (pid will be written to port file)\u2026`);
+      const port = await waitForPort();
+      console.log(`Daemon started on port ${port}`);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+daemon.command("stop").description("Stop the daemon").action(async () => {
+  try {
+    const pidFile = pidFilePath();
+    if (!(0, import_node_fs3.existsSync)(pidFile)) {
+      console.log("Daemon is not running");
+      return;
+    }
+    const pid = parseInt((0, import_node_fs3.readFileSync)(pidFile, "utf-8").trim(), 10);
+    process.kill(pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon (pid ${pid})`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+daemon.command("status").description("Show daemon status").action(async () => {
+  try {
+    const status = await api("GET", "/api/daemon/status");
+    print(status, !!program.opts().json);
+  } catch {
+    console.log("Daemon is not running");
+  }
+});
+daemon.command("reload").description("Reload jobs from disk").action(async () => {
+  try {
+    const result = await api("POST", "/api/daemon/reload");
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+daemon.command("restart").description("Restart the daemon").action(async () => {
+  try {
+    const pidFile = pidFilePath();
+    if ((0, import_node_fs3.existsSync)(pidFile)) {
+      const pid = parseInt((0, import_node_fs3.readFileSync)(pidFile, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, "SIGTERM");
+        await new Promise((r) => setTimeout(r, 1e3));
+      } catch {
+      }
+    }
+    const script = daemonScript();
+    const child = (0, import_node_child_process2.spawn)(process.execPath, [script], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    });
+    child.unref();
+    const port = await waitForPort();
+    console.log(`Daemon restarted on port ${port}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+var autostart = program.command("autostart").description("Manage daemon autostart at login");
+autostart.command("install").description("Register the daemon to start automatically at login").option("--backend <backend>", "Backend: win32|darwin|linux|manual (default: auto-detect)").action(async (opts) => {
+  try {
+    const backend = opts.backend;
+    const as = createAutostart({ backend });
+    const result = await as.install();
+    print(result, !!program.opts().json);
+    if (process.platform !== "win32" && !backend) {
+      const statusResult = await as.status();
+      const details = statusResult.details;
+      const instr = details?.["instructions"];
+      if (instr) console.log("\nManual setup instructions:\n" + instr);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+autostart.command("remove").description("Remove the daemon from automatic startup").option("--backend <backend>", "Backend: win32|darwin|linux|manual (default: auto-detect)").action(async (opts) => {
+  try {
+    const backend = opts.backend;
+    const as = createAutostart({ backend });
+    const result = await as.remove();
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+autostart.command("status").description("Check whether the daemon is registered for automatic startup").option("--backend <backend>", "Backend: win32|darwin|linux|manual (default: auto-detect)").action(async (opts) => {
+  try {
+    const backend = opts.backend;
+    const as = createAutostart({ backend });
+    const result = await as.status();
+    print(result, !!program.opts().json);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("uninstall").description("Remove autostart entry and optionally delete all crontick data").option("--purge", "Also delete the data directory (jobs, runs, config)").option("--yes", "Skip confirmation prompts").action(async (opts) => {
+  try {
+    const as = createAutostart();
+    await as.remove();
+    console.log("\u2713 Autostart entry removed.");
+    if (opts.purge) {
+      const dir = dataDir();
+      let confirmed = opts.yes;
+      if (!confirmed) {
+        confirmed = await new Promise((resolve2) => {
+          const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+          rl.question(`Delete all crontick data at ${dir}? [y/N] `, (answer) => {
+            rl.close();
+            resolve2(answer.trim().toLowerCase() === "y");
+          });
+        });
+      }
+      if (confirmed) {
+        (0, import_node_fs3.rmSync)(dir, { recursive: true, force: true });
+        console.log(`\u2713 Data directory deleted: ${dir}`);
+      } else {
+        console.log("Skipped data directory deletion.");
+      }
+    } else {
+      console.log(
+        "Data directory preserved. Run `crontick uninstall --purge` to also delete it."
+      );
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("dashboard").description("Open the crontick dashboard in a browser").option("--open", "Open in the default browser").action(async (opts) => {
+  try {
+    const port = getPort();
+    const url = `http://127.0.0.1:${port}/dashboard`;
+    if (opts.open) {
+      if (process.platform === "win32") {
+        (0, import_node_child_process2.spawn)("cmd", ["/c", "start", url], { detached: true, stdio: "ignore" }).unref();
+      } else if (process.platform === "darwin") {
+        (0, import_node_child_process2.spawn)("open", [url], { detached: true, stdio: "ignore" }).unref();
+      } else {
+        try {
+          (0, import_node_child_process2.spawn)("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+        } catch {
+        }
+      }
+      console.log(`Dashboard opened: ${url}`);
+    } else {
+      console.log(`Dashboard: ${url}`);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("mcp").description("Start the crontick MCP server on stdio (for use with Claude Desktop, Copilot, Cursor, etc.)").option("--no-autostart", "Do not auto-start the daemon if it is not already running").option("--daemon-url <url>", "Override the daemon URL (default: resolved from port file)").addHelpText(
+  "after",
+  `
+Transport:    stdio (JSON-RPC 2.0 over stdin/stdout)
+Tool prefix:  crontick_
+Autostart:    Daemon is auto-started unless --no-autostart or CRONTICK_MCP_NO_AUTOSTART=1 is set
+
+Example MCP host config (Claude Desktop):
+  {
+    "mcpServers": {
+      "crontick": { "command": "crontick", "args": ["mcp"] }
+    }
+  }`
+).action((opts) => {
+  const mcpScript = (0, import_node_path3.resolve)(__dirname, "../mcp/index.js");
+  if (!(0, import_node_fs3.existsSync)(mcpScript)) {
+    console.error(`MCP server script not found: ${mcpScript}. Run: npm run build`);
+    process.exit(1);
+  }
+  const env = { ...process.env };
+  if (opts.noAutostart) env["CRONTICK_MCP_NO_AUTOSTART"] = "1";
+  if (opts.daemonUrl) env["CRONTICK_DAEMON_URL"] = opts.daemonUrl;
+  const result = (0, import_node_child_process2.spawnSync)(process.execPath, [mcpScript], {
+    stdio: "inherit",
+    env
+  });
+  process.exit(result.status ?? 0);
+});
+program.parse();
+//# sourceMappingURL=index.cjs.map