crontick 0.1.0

package/dist/daemon/index.cjs

@@ -0,0 +1,1655 @@
+#!/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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/schemas/job.ts
+var job_exports = {};
+__export(job_exports, {
+  ActionSchema: () => ActionSchema,
+  BudgetsSchema: () => BudgetsSchema,
+  CronScheduleSchema: () => CronScheduleSchema,
+  ExecActionSchema: () => ExecActionSchema,
+  IntervalScheduleSchema: () => IntervalScheduleSchema,
+  JobSchema: () => JobSchema,
+  OneShotScheduleSchema: () => OneShotScheduleSchema,
+  RetrySchema: () => RetrySchema,
+  ScheduleSchema: () => ScheduleSchema,
+  ScriptActionSchema: () => ScriptActionSchema
+});
+var import_zod, CronScheduleSchema, IntervalScheduleSchema, OneShotScheduleSchema, ScheduleSchema, ScriptActionSchema, ExecActionSchema, ActionSchema, RetrySchema, BudgetsSchema, kebabCase, JobSchema;
+var init_job = __esm({
+  "src/schemas/job.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    CronScheduleSchema = import_zod.z.object({
+      kind: import_zod.z.literal("cron"),
+      cron: import_zod.z.string().min(1),
+      tz: import_zod.z.string().optional()
+    });
+    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
+    });
+    OneShotScheduleSchema = import_zod.z.object({
+      kind: import_zod.z.literal("one-shot"),
+      runAt: import_zod.z.string().min(1)
+      // ISO-8601
+    });
+    ScheduleSchema = import_zod.z.discriminatedUnion("kind", [
+      CronScheduleSchema,
+      IntervalScheduleSchema,
+      OneShotScheduleSchema
+    ]);
+    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()
+    });
+    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
+    });
+    ActionSchema = import_zod.z.discriminatedUnion("kind", [ScriptActionSchema, ExecActionSchema]);
+    RetrySchema = import_zod.z.object({
+      max: import_zod.z.number().int().min(0).default(0),
+      backoffSec: import_zod.z.number().positive().default(30)
+    });
+    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)
+    });
+    kebabCase = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+    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/daemon/index.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+
+// 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 runsDbPath() {
+  return (0, import_node_path.join)(root(), "runs.db");
+}
+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/daemon/store.ts
+var import_node_sqlite = require("node:sqlite");
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+init_job();
+
+// 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/daemon/store.ts
+var MIGRATIONS = [
+  {
+    name: "001_initial",
+    sql: `
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        json TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        job_id TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        status TEXT NOT NULL,
+        exit_code INTEGER,
+        error TEXT,
+        duration_ms INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS run_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT NOT NULL,
+        stream TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        chunk BLOB NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_runs_job_id ON runs(job_id);
+      CREATE INDEX IF NOT EXISTS idx_runs_started_at ON runs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_run_logs_run_id ON run_logs(run_id);
+    `
+  }
+];
+var Store = class {
+  db;
+  dbPath;
+  jobsPath;
+  constructor(dbPath, jobsPath) {
+    this.dbPath = dbPath ?? runsDbPath();
+    this.jobsPath = jobsPath ?? jobsDir();
+  }
+  open() {
+    this.db = new import_node_sqlite.DatabaseSync(this.dbPath);
+    this.db.exec("PRAGMA journal_mode=WAL;");
+    this.db.exec("PRAGMA foreign_keys=ON;");
+    this.runMigrations();
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+  runMigrations() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        applied_at INTEGER NOT NULL
+      );
+    `);
+    const applied = this.db.prepare("SELECT name FROM migrations").all();
+    const appliedSet = new Set(applied.map((r) => r.name));
+    for (const migration of MIGRATIONS) {
+      if (!appliedSet.has(migration.name)) {
+        this.db.exec(migration.sql);
+        this.db.prepare("INSERT INTO migrations (name, applied_at) VALUES (?, ?)").run(migration.name, Date.now());
+      }
+    }
+  }
+  // ── Job CRUD ────────────────────────────────────────────────────────────────
+  upsertJob(job) {
+    const json = JSON.stringify(job);
+    const now = Date.now();
+    this.db.prepare(
+      "INSERT INTO jobs (id, json, updated_at) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at"
+    ).run(job.id, json, now);
+    const filePath = (0, import_node_path2.join)(this.jobsPath, `${job.id}.json`);
+    (0, import_node_fs2.writeFileSync)(filePath, json, "utf-8");
+  }
+  getJob(id) {
+    const row = this.db.prepare("SELECT json FROM jobs WHERE id = ?").get(id);
+    if (!row) return void 0;
+    return JSON.parse(row.json);
+  }
+  listJobs() {
+    const rows = this.db.prepare("SELECT json FROM jobs ORDER BY id").all();
+    return rows.map((r) => JSON.parse(r.json));
+  }
+  deleteJob(id) {
+    const changes = this.db.prepare("DELETE FROM jobs WHERE id = ?").run(id).changes;
+    const filePath = (0, import_node_path2.join)(this.jobsPath, `${id}.json`);
+    if ((0, import_node_fs2.existsSync)(filePath)) {
+      try {
+        (0, import_node_fs2.unlinkSync)(filePath);
+      } catch {
+      }
+    }
+    return changes > 0;
+  }
+  /** Load jobs from the jobs directory (disk is source of truth on daemon start). */
+  loadJobsFromDisk() {
+    if (!(0, import_node_fs2.existsSync)(this.jobsPath)) return;
+    const files = (0, import_node_fs2.readdirSync)(this.jobsPath).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const raw = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(this.jobsPath, file), "utf-8");
+        const parsed = JobSchema.safeParse(JSON.parse(raw));
+        if (parsed.success) {
+          const json = JSON.stringify(parsed.data);
+          this.db.prepare(
+            "INSERT INTO jobs (id, json, updated_at) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at"
+          ).run(parsed.data.id, json, Date.now());
+        }
+      } catch {
+      }
+    }
+  }
+  // ── Run CRUD ────────────────────────────────────────────────────────────────
+  insertRun(jobId, startedAt) {
+    const id = (0, import_node_crypto.randomUUID)();
+    const now = startedAt ?? Date.now();
+    this.db.prepare(
+      "INSERT INTO runs (id, job_id, started_at, status) VALUES (?, ?, ?, ?)"
+    ).run(id, jobId, now, "queued");
+    return { id, jobId, startedAt: now, status: "queued" };
+  }
+  updateRun(id, update) {
+    const run = this.getRun(id);
+    if (!run) throw new CrontickError("NOT_FOUND", `Run ${id} not found`);
+    const fields = [];
+    const values = [];
+    if (update.status !== void 0) {
+      fields.push("status = ?");
+      values.push(update.status);
+    }
+    if (update.exitCode !== void 0) {
+      fields.push("exit_code = ?");
+      values.push(update.exitCode ?? null);
+    }
+    if (update.error !== void 0) {
+      fields.push("error = ?");
+      values.push(update.error ?? null);
+    }
+    if (update.endedAt !== void 0) {
+      fields.push("ended_at = ?");
+      values.push(update.endedAt ?? null);
+    }
+    if (update.durationMs !== void 0) {
+      fields.push("duration_ms = ?");
+      values.push(update.durationMs ?? null);
+    }
+    if (fields.length === 0) return;
+    values.push(id);
+    this.db.prepare(`UPDATE runs SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  }
+  getRun(id) {
+    const row = this.db.prepare("SELECT * FROM runs WHERE id = ?").get(id);
+    return row ? rowToRun(row) : void 0;
+  }
+  listRuns(opts = {}) {
+    const conditions = [];
+    const params = [];
+    if (opts.jobId) {
+      conditions.push("job_id = ?");
+      params.push(opts.jobId);
+    }
+    if (opts.since !== void 0) {
+      conditions.push("started_at >= ?");
+      params.push(opts.since);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts.limit !== void 0 ? `LIMIT ${opts.limit}` : "";
+    const rows = this.db.prepare(`SELECT * FROM runs ${where} ORDER BY started_at DESC ${limit}`).all(...params);
+    return rows.map(rowToRun);
+  }
+  /** Get the most recent successful run for a job (for catchup calculation). */
+  getLastRun(jobId) {
+    const row = this.db.prepare(
+      "SELECT * FROM runs WHERE job_id = ? AND status IN ('success','failed','timeout') ORDER BY started_at DESC LIMIT 1"
+    ).get(jobId);
+    return row ? rowToRun(row) : void 0;
+  }
+  /** Count runs for a job started after a given epoch ms. */
+  countRunsSince(jobId, since, excludeId) {
+    if (excludeId) {
+      const result2 = this.db.prepare("SELECT COUNT(*) as cnt FROM runs WHERE job_id = ? AND started_at >= ? AND id != ?").get(jobId, since, excludeId);
+      return result2.cnt;
+    }
+    const result = this.db.prepare("SELECT COUNT(*) as cnt FROM runs WHERE job_id = ? AND started_at >= ?").get(jobId, since);
+    return result.cnt;
+  }
+  // ── Log CRUD ────────────────────────────────────────────────────────────────
+  appendLog(runId, stream, chunk) {
+    this.db.prepare("INSERT INTO run_logs (run_id, stream, ts, chunk) VALUES (?, ?, ?, ?)").run(runId, stream, Date.now(), chunk);
+  }
+  getLogs(runId) {
+    const rows = this.db.prepare("SELECT * FROM run_logs WHERE run_id = ? ORDER BY id").all(runId);
+    return rows.map(rowToLog);
+  }
+  tailLogs(runId, sinceTs) {
+    const rows = this.db.prepare("SELECT * FROM run_logs WHERE run_id = ? AND ts > ? ORDER BY id").all(runId, sinceTs);
+    return rows.map(rowToLog);
+  }
+  /** On daemon startup, cancel any runs that were left in 'running' or 'queued' state (daemon crashed). */
+  reconcileOrphanRuns() {
+    const result = this.db.prepare(
+      "UPDATE runs SET status = 'canceled', error = 'daemon-restart', ended_at = ? WHERE status IN ('running', 'queued')"
+    ).run(Date.now());
+    return result.changes;
+  }
+};
+function rowToRun(row) {
+  const r = {
+    id: row.id,
+    jobId: row.job_id,
+    startedAt: row.started_at,
+    status: row.status
+  };
+  if (row.ended_at !== null) r.endedAt = row.ended_at;
+  if (row.exit_code !== null) r.exitCode = row.exit_code;
+  if (row.error !== null) r.error = row.error;
+  if (row.duration_ms !== null) r.durationMs = row.duration_ms;
+  return r;
+}
+function rowToLog(row) {
+  return {
+    runId: row.run_id,
+    stream: row.stream,
+    ts: row.ts,
+    chunk: Buffer.from(row.chunk)
+  };
+}
+
+// src/daemon/scheduler.ts
+var import_node_events = require("events");
+var import_croner = require("croner");
+var CRON_ALIASES = {
+  "@yearly": "0 0 1 1 *",
+  "@annually": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@noon": "0 12 * * *",
+  "@hourly": "0 * * * *",
+  "@every_minute": "* * * * *"
+};
+function expandCronAlias(expr) {
+  return CRON_ALIASES[expr.toLowerCase()] ?? expr;
+}
+var Scheduler = class extends import_node_events.EventEmitter {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Schedule a job, handling catchup based on the last run time from the store.
+   * On daemon start pass `store` so catchup can be resolved; at runtime it's optional.
+   */
+  schedule(job, store) {
+    this.unschedule(job.id);
+    if (!job.enabled) return;
+    const { schedule } = job;
+    const lastRun = store?.getLastRun(job.id);
+    const lastRunAt = lastRun ? new Date(lastRun.startedAt) : void 0;
+    if (schedule.kind === "cron") {
+      this.scheduleCron(job, expandCronAlias(schedule.cron), schedule.tz, lastRunAt);
+    } else if (schedule.kind === "interval") {
+      this.scheduleInterval(job, schedule.everySec, schedule.startAt, lastRunAt);
+    } else if (schedule.kind === "one-shot") {
+      this.scheduleOneShot(job, schedule.runAt);
+    }
+  }
+  unschedule(jobId) {
+    const entry = this.entries.get(jobId);
+    if (entry) {
+      entry.stop();
+      this.entries.delete(jobId);
+    }
+  }
+  unscheduleAll() {
+    for (const jobId of [...this.entries.keys()]) {
+      this.unschedule(jobId);
+    }
+  }
+  // ── Preview / Validate ─────────────────────────────────────────────────────
+  previewNext(schedule, opts = {}) {
+    const n = opts.n ?? 5;
+    if (schedule.kind === "cron") {
+      return cronNextN(expandCronAlias(schedule.cron), opts.tz ?? schedule.tz, n);
+    }
+    if (schedule.kind === "interval") {
+      const now = Date.now();
+      const intervalMs = schedule.everySec * 1e3;
+      const results = [];
+      for (let i = 1; i <= n; i++) {
+        results.push(new Date(now + i * intervalMs).toISOString());
+      }
+      return results;
+    }
+    if (schedule.kind === "one-shot") {
+      const t = new Date(schedule.runAt);
+      if (isNaN(t.getTime())) return [];
+      return t > /* @__PURE__ */ new Date() ? [t.toISOString()] : [];
+    }
+    return [];
+  }
+  validateSchedule(schedule) {
+    if (schedule.kind === "cron") {
+      try {
+        const cron = new import_croner.Cron(expandCronAlias(schedule.cron), { paused: true });
+        cron.stop();
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, error: String(err) };
+      }
+    }
+    if (schedule.kind === "interval") {
+      if (schedule.everySec <= 0) {
+        return { ok: false, error: "everySec must be positive" };
+      }
+      if (schedule.startAt && isNaN(new Date(schedule.startAt).getTime())) {
+        return { ok: false, error: "startAt is not a valid ISO-8601 date" };
+      }
+      return { ok: true };
+    }
+    if (schedule.kind === "one-shot") {
+      const t = new Date(schedule.runAt);
+      if (isNaN(t.getTime())) {
+        return { ok: false, error: "runAt is not a valid ISO-8601 date" };
+      }
+      return { ok: true };
+    }
+    return { ok: false, error: "Unknown schedule kind" };
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  fireTick(jobId, plannedAt) {
+    this.emit("tick", { jobId, plannedAt });
+  }
+  scheduleCron(job, pattern, tz, lastRunAt) {
+    this.handleCronCatchup(job, pattern, tz, lastRunAt);
+    const options = {};
+    if (tz) options.timezone = tz;
+    const cron = new import_croner.Cron(pattern, options, () => {
+      this.fireTick(job.id, /* @__PURE__ */ new Date());
+    });
+    this.entries.set(job.id, { stop: () => cron.stop() });
+  }
+  handleCronCatchup(job, pattern, tz, lastRunAt) {
+    if (job.catchup === "skip" || !lastRunAt) return;
+    const now = /* @__PURE__ */ new Date();
+    const missed = missedCronFires(pattern, tz, lastRunAt, now);
+    if (missed.length === 0) return;
+    if (job.catchup === "run-once") {
+      setImmediate(() => this.fireTick(job.id, missed[missed.length - 1]));
+    } else if (job.catchup === "run-all") {
+      for (const t of missed) {
+        const capturedT = t;
+        setImmediate(() => this.fireTick(job.id, capturedT));
+      }
+    }
+  }
+  scheduleInterval(job, everySec, startAt, lastRunAt) {
+    const intervalMs = everySec * 1e3;
+    if (lastRunAt && job.catchup !== "skip") {
+      const elapsed = Date.now() - lastRunAt.getTime();
+      const missedCount = Math.floor(elapsed / intervalMs);
+      if (missedCount > 0) {
+        if (job.catchup === "run-once") {
+          setImmediate(() => this.fireTick(job.id, /* @__PURE__ */ new Date()));
+        } else if (job.catchup === "run-all") {
+          for (let i = 0; i < missedCount; i++) {
+            setImmediate(() => this.fireTick(job.id, /* @__PURE__ */ new Date()));
+          }
+        }
+      }
+    }
+    let delay = intervalMs;
+    if (startAt) {
+      const startTime = new Date(startAt);
+      if (!isNaN(startTime.getTime())) {
+        const now = Date.now();
+        const startMs = startTime.getTime();
+        if (startMs > now) {
+          delay = startMs - now;
+        } else {
+          const elapsed = now - startMs;
+          delay = intervalMs - elapsed % intervalMs;
+        }
+      }
+    }
+    const timer = safeSetTimeout(() => {
+      this.fireTick(job.id, /* @__PURE__ */ new Date());
+      const interval = setInterval(() => this.fireTick(job.id, /* @__PURE__ */ new Date()), intervalMs);
+      this.entries.set(job.id, { stop: () => clearInterval(interval) });
+    }, delay);
+    this.entries.set(job.id, {
+      stop: () => timer.clear()
+    });
+  }
+  scheduleOneShot(job, runAt) {
+    const t = new Date(runAt);
+    if (isNaN(t.getTime())) return;
+    const delay = t.getTime() - Date.now();
+    if (delay <= 0) {
+      if (job.catchup !== "skip") {
+        setImmediate(() => {
+          this.fireTick(job.id, t);
+          this.entries.delete(job.id);
+        });
+      }
+      return;
+    }
+    const timer = safeSetTimeout(() => {
+      this.fireTick(job.id, t);
+      this.entries.delete(job.id);
+    }, delay);
+    this.entries.set(job.id, { stop: () => timer.clear() });
+  }
+};
+var MAX_SAFE_TIMEOUT_MS = 2e9;
+function safeSetTimeout(cb, ms) {
+  if (ms <= MAX_SAFE_TIMEOUT_MS) {
+    const t2 = setTimeout(cb, ms);
+    return { clear: () => clearTimeout(t2) };
+  }
+  let inner;
+  const t = setTimeout(() => {
+    inner = safeSetTimeout(cb, ms - MAX_SAFE_TIMEOUT_MS);
+  }, MAX_SAFE_TIMEOUT_MS);
+  return {
+    clear: () => {
+      clearTimeout(t);
+      inner?.clear();
+    }
+  };
+}
+function cronNextN(pattern, tz, n) {
+  try {
+    const options = { paused: true };
+    if (tz) options.timezone = tz;
+    const cron = new import_croner.Cron(pattern, options);
+    const results = [];
+    let ref;
+    for (let i = 0; i < n; i++) {
+      const next = cron.nextRun(ref);
+      if (!next) break;
+      results.push(next.toISOString());
+      ref = new Date(next.getTime() + 1);
+    }
+    cron.stop();
+    return results;
+  } catch {
+    return [];
+  }
+}
+function missedCronFires(pattern, tz, from, to) {
+  try {
+    const options = { paused: true };
+    if (tz) options.timezone = tz;
+    const cron = new import_croner.Cron(pattern, options);
+    const missed = [];
+    let ref = from;
+    for (; ; ) {
+      const next = cron.nextRun(ref);
+      if (!next || next > to) break;
+      missed.push(next);
+      ref = new Date(next.getTime() + 1);
+      if (missed.length > 1e3) break;
+    }
+    cron.stop();
+    return missed;
+  } catch {
+    return [];
+  }
+}
+
+// src/daemon/runner.ts
+var import_node_child_process = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_os = require("os");
+var import_node_path3 = require("path");
+var import_node_crypto2 = require("crypto");
+var SECRET_PATTERNS = [
+  /(?:AWS_SECRET_ACCESS_KEY|AWS_SESSION_TOKEN)=[^\s]*/gi,
+  /(?:GITHUB_TOKEN|GH_TOKEN)=[^\s]*/gi,
+  /(?:GCLOUD_SERVICE_KEY|GOOGLE_CREDENTIALS)=[^\s]*/gi,
+  /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi,
+  /ghp_[A-Za-z0-9]{36}/g,
+  /AKIA[0-9A-Z]{16}/g
+];
+function redact(text) {
+  let out = text;
+  for (const pat of SECRET_PATTERNS) {
+    out = out.replace(pat, "[REDACTED]");
+  }
+  return out;
+}
+function safeRedact(chunk) {
+  if (chunk.includes(0)) return chunk;
+  const str = chunk.toString("utf8");
+  if (!Buffer.from(str, "utf8").equals(chunk)) return chunk;
+  const cleaned = redact(str);
+  return Buffer.from(cleaned, "utf8");
+}
+function parseEnvFile(contents) {
+  const result = {};
+  for (const raw of contents.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) result[key] = value;
+  }
+  return result;
+}
+var Runner = class {
+  /** Per-job queues for overlap=queue policy */
+  queues = /* @__PURE__ */ new Map();
+  /** Abort controllers for currently active runs per job */
+  activeAborts = /* @__PURE__ */ new Map();
+  /** Active run IDs per job */
+  activeRunIds = /* @__PURE__ */ new Map();
+  /** Whether a job's queue is currently being drained */
+  draining = /* @__PURE__ */ new Set();
+  /**
+   * Execute a job run, honouring overlap + retry + budget policies.
+   * The run record must already exist in the store (status=queued).
+   */
+  async run(job, runId, store) {
+    const overlap = job.overlap ?? "skip";
+    if (job.budgets?.maxRunsPerDay != null) {
+      const todayStart = /* @__PURE__ */ new Date();
+      todayStart.setUTCHours(0, 0, 0, 0);
+      const count = store.countRunsSince(job.id, todayStart.getTime(), runId);
+      if (count >= job.budgets.maxRunsPerDay) {
+        await this.finalizeRun(store, runId, {
+          status: "canceled",
+          error: `budget: maxRunsPerDay (${job.budgets.maxRunsPerDay}) exceeded`
+        });
+        return;
+      }
+    }
+    const isActive = this.activeRunIds.has(job.id);
+    if (overlap === "skip" && isActive) {
+      await this.finalizeRun(store, runId, {
+        status: "canceled",
+        error: "overlap=skip: another run is already active"
+      });
+      return;
+    }
+    if (overlap === "cancel-previous" && isActive) {
+      const ctrl = this.activeAborts.get(job.id);
+      if (ctrl) ctrl.abort();
+    }
+    if (overlap === "queue") {
+      await this.enqueue(job, runId, store);
+    } else {
+      await this.execute(job, runId, store);
+    }
+  }
+  enqueue(job, runId, store) {
+    return new Promise((resolve) => {
+      const queue = this.queues.get(job.id) ?? [];
+      queue.push(async () => {
+        await this.execute(job, runId, store);
+        resolve();
+      });
+      this.queues.set(job.id, queue);
+      if (!this.draining.has(job.id)) {
+        this.drainQueue(job.id);
+      }
+    });
+  }
+  async drainQueue(jobId) {
+    this.draining.add(jobId);
+    const queue = this.queues.get(jobId);
+    if (!queue || queue.length === 0) {
+      this.draining.delete(jobId);
+      return;
+    }
+    const next = queue.shift();
+    try {
+      await next();
+    } catch {
+    }
+    await this.drainQueue(jobId);
+  }
+  async execute(job, runId, store) {
+    const maxRetries = job.retry?.max ?? 0;
+    const backoffSec = job.retry?.backoffSec ?? 30;
+    let lastResult = { status: "failed", error: "not started" };
+    store.updateRun(runId, { status: "running" });
+    const ctrl = new AbortController();
+    this.activeAborts.set(job.id, ctrl);
+    this.activeRunIds.set(job.id, runId);
+    try {
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        if (attempt > 0) {
+          await sleep(backoffSec * 1e3);
+        }
+        if (ctrl.signal.aborted) {
+          lastResult = { status: "canceled", error: "canceled before retry" };
+          break;
+        }
+        lastResult = await this.spawn(job, runId, store, ctrl.signal);
+        if (lastResult.status === "success") break;
+        if (lastResult.status === "canceled" || lastResult.status === "timeout") break;
+      }
+    } finally {
+      if (this.activeAborts.get(job.id) === ctrl) this.activeAborts.delete(job.id);
+      if (this.activeRunIds.get(job.id) === runId) this.activeRunIds.delete(job.id);
+    }
+    await this.finalizeRun(store, runId, lastResult);
+  }
+  async spawn(job, runId, store, signal) {
+    const { action } = job;
+    let tmpFile;
+    try {
+      let cmd;
+      let args;
+      if (action.kind === "script") {
+        const ext = resolveShellExt(action.shell ?? "auto");
+        const tmpDir = (0, import_node_path3.join)((0, import_node_os.tmpdir)(), "crontick");
+        (0, import_node_fs3.mkdirSync)(tmpDir, { recursive: true });
+        tmpFile = (0, import_node_path3.join)(tmpDir, `${(0, import_node_crypto2.randomUUID)()}${ext}`);
+        (0, import_node_fs3.writeFileSync)(tmpFile, action.script, { encoding: "utf-8", mode: 448 });
+        const resolved = resolveShell(action.shell ?? "auto");
+        if (resolved === "pwsh") {
+          cmd = "pwsh";
+          args = ["-NoProfile", "-NonInteractive", "-File", tmpFile];
+        } else if (resolved === "cmd") {
+          cmd = "cmd";
+          args = ["/c", tmpFile];
+        } else {
+          cmd = "bash";
+          args = [tmpFile];
+        }
+      } else {
+        cmd = action.command;
+        args = action.args ?? [];
+      }
+      const spawnOpts = {
+        cwd: action.cwd ?? process.cwd(),
+        env: { ...process.env, ...action.env ?? {} },
+        signal,
+        shell: false
+      };
+      if (action.envFile) {
+        const envFilePath = (0, import_node_path3.isAbsolute)(action.envFile) ? action.envFile : (0, import_node_path3.join)(action.cwd ?? process.cwd(), action.envFile);
+        try {
+          const fileContents = (0, import_node_fs3.readFileSync)(envFilePath, "utf-8");
+          const envFileVars = parseEnvFile(fileContents);
+          spawnOpts.env = {
+            ...process.env,
+            ...envFileVars,
+            ...action.env ?? {}
+          };
+        } catch (err) {
+          throw new CrontickError("ENV_FILE_ERROR", `Failed to load envFile: ${String(err)}`);
+        }
+      }
+      if (action.timeoutSec) {
+        spawnOpts.timeout = action.timeoutSec * 1e3;
+      }
+      const result = await new Promise((resolve) => {
+        const child = (0, import_node_child_process.spawn)(cmd, args, spawnOpts);
+        const startedAt = Date.now();
+        child.stdout?.on("data", (chunk) => {
+          store.appendLog(runId, "stdout", safeRedact(chunk));
+        });
+        child.stderr?.on("data", (chunk) => {
+          store.appendLog(runId, "stderr", safeRedact(chunk));
+        });
+        child.on("close", (code, sig) => {
+          const durationMs = Date.now() - startedAt;
+          if (sig === "SIGTERM" || sig === "SIGKILL") {
+            resolve({ status: "canceled", error: `killed by signal ${sig}` });
+          } else if (code === null) {
+            resolve({ status: "failed", error: "process exited without code" });
+          } else {
+            resolve({
+              status: code === 0 ? "success" : "failed",
+              exitCode: code
+            });
+          }
+          void durationMs;
+        });
+        child.on("error", (err) => {
+          if (err.code === "ABORT_ERR" || signal.aborted) {
+            resolve({ status: "canceled", error: "aborted" });
+          } else if (err.code === "ETIMEDOUT") {
+            resolve({ status: "timeout", error: "timed out" });
+          } else {
+            resolve({ status: "failed", error: err.message });
+          }
+        });
+      });
+      return result;
+    } finally {
+      if (tmpFile && (0, import_node_fs3.existsSync)(tmpFile)) {
+        try {
+          (0, import_node_fs3.unlinkSync)(tmpFile);
+        } catch {
+        }
+      }
+    }
+  }
+  async finalizeRun(store, runId, result) {
+    const run = store.getRun(runId);
+    const now = Date.now();
+    store.updateRun(runId, {
+      status: result.status,
+      exitCode: result.exitCode,
+      error: result.error,
+      endedAt: now,
+      durationMs: run ? now - run.startedAt : void 0
+    });
+  }
+  /** Cancel any active run for a job. */
+  cancelJob(jobId) {
+    const ctrl = this.activeAborts.get(jobId);
+    if (ctrl) {
+      ctrl.abort();
+      return true;
+    }
+    return false;
+  }
+  /** Cancel an active run by run ID. */
+  cancelRun(runId) {
+    for (const [jobId, rId] of this.activeRunIds.entries()) {
+      if (rId === runId) {
+        return this.cancelJob(jobId);
+      }
+    }
+    return false;
+  }
+};
+function resolveShell(shell) {
+  if (shell === "auto") {
+    return (0, import_node_os.platform)() === "win32" ? "pwsh" : "bash";
+  }
+  if (shell === "pwsh") return "pwsh";
+  if (shell === "cmd") return "cmd";
+  return "bash";
+}
+function resolveShellExt(shell) {
+  const resolved = resolveShell(shell);
+  if (resolved === "pwsh") return ".ps1";
+  if (resolved === "cmd") return ".bat";
+  return ".sh";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/daemon/api.ts
+var import_node_http = __toESM(require("http"), 1);
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var import_node_url = require("url");
+var import_node_url2 = require("url");
+init_job();
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/autostart/win32.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path4 = 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_path4.join)(autostartDir(), "crontick-daemon.vbs");
+}
+function findDaemonBinary() {
+  const override = process.env["CRONTICK_DAEMON_BINARY"];
+  if (override) return override;
+  const whereResult = (0, import_node_child_process2.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_path4.dirname)(process.execPath);
+  for (const candidate of ["crontick-daemon.cmd", "crontick-daemon"]) {
+    const p = (0, import_node_path4.join)(nodeDir, candidate);
+    if ((0, import_node_fs4.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_process2.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_process2.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_process2.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_fs4.mkdirSync)(autostartDir(), { recursive: true });
+    (0, import_node_fs4.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_fs4.existsSync)(vbsPath)) {
+      try {
+        (0, import_node_fs4.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/daemon/api.ts
+var import_meta = {};
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+var SSE_POLL_MS = 200;
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function createApiServer(ctx) {
+  const server = import_node_http.default.createServer((req, res) => {
+    const remote = req.socket.remoteAddress ?? "";
+    if (!LOOPBACK.has(remote)) {
+      return sendError(res, 403, "FORBIDDEN", "Only localhost connections are allowed");
+    }
+    void handleRequest(req, res, ctx);
+  });
+  return server;
+}
+async function handleRequest(req, res, ctx) {
+  const method = req.method ?? "GET";
+  const rawUrl = req.url ?? "/";
+  const baseUrl = `http://127.0.0.1`;
+  const url = new import_node_url.URL(rawUrl, baseUrl);
+  const path = url.pathname;
+  try {
+    if (method === "GET" && path === "/health") {
+      const jobs = ctx.store.listJobs();
+      const since24h = Date.now() - 24 * 60 * 60 * 1e3;
+      const runs24h = ctx.store.listRuns({ since: since24h });
+      return sendJson(res, 200, {
+        ok: true,
+        version: VERSION,
+        uptimeSec: Math.floor((Date.now() - ctx.startedAt.getTime()) / 1e3),
+        pid: process.pid,
+        port: ctx.port,
+        jobs: {
+          total: jobs.length,
+          enabled: jobs.filter((j) => j.enabled).length
+        },
+        runs: {
+          last24h: runs24h.length,
+          failures24h: runs24h.filter((r) => r.status === "failed").length
+        },
+        node: process.versions.node,
+        platform: process.platform
+      });
+    }
+    if (method === "GET" && path === "/api/jobs") {
+      return sendJson(res, 200, ctx.store.listJobs());
+    }
+    if (method === "POST" && path === "/api/jobs") {
+      const body = await readBody(req);
+      const parsed = JobSchema.safeParse(body);
+      if (!parsed.success) {
+        return sendError(res, 400, "VALIDATION_ERROR", "Invalid job", parsed.error.format());
+      }
+      ctx.store.upsertJob(parsed.data);
+      ctx.scheduler.schedule(parsed.data, ctx.store);
+      return sendJson(res, 201, parsed.data);
+    }
+    const jobMatch = path.match(/^\/api\/jobs\/([^/]+)(\/.*)?$/);
+    if (jobMatch) {
+      const id = decodeURIComponent(jobMatch[1]);
+      const sub = jobMatch[2] ?? "";
+      if (method === "GET" && sub === "") {
+        const job = ctx.store.getJob(id);
+        if (!job) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        return sendJson(res, 200, job);
+      }
+      if (method === "PUT" && sub === "") {
+        const existing = ctx.store.getJob(id);
+        if (!existing) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        const body = await readBody(req);
+        const parsed = JobSchema.safeParse({ ...existing, ...body, id });
+        if (!parsed.success) {
+          return sendError(res, 400, "VALIDATION_ERROR", "Invalid job", parsed.error.format());
+        }
+        ctx.store.upsertJob(parsed.data);
+        ctx.scheduler.schedule(parsed.data, ctx.store);
+        return sendJson(res, 200, parsed.data);
+      }
+      if (method === "DELETE" && sub === "") {
+        const deleted = ctx.store.deleteJob(id);
+        if (!deleted) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        ctx.scheduler.unschedule(id);
+        return sendJson(res, 200, { ok: true });
+      }
+      if (method === "POST" && sub === "/enable") {
+        const job = ctx.store.getJob(id);
+        if (!job) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        const updated = { ...job, enabled: true };
+        ctx.store.upsertJob(updated);
+        ctx.scheduler.schedule(updated, ctx.store);
+        return sendJson(res, 200, updated);
+      }
+      if (method === "POST" && sub === "/disable") {
+        const job = ctx.store.getJob(id);
+        if (!job) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        const updated = { ...job, enabled: false };
+        ctx.store.upsertJob(updated);
+        ctx.scheduler.unschedule(id);
+        return sendJson(res, 200, updated);
+      }
+      if (method === "POST" && sub === "/run") {
+        const job = ctx.store.getJob(id);
+        if (!job) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+        const run = ctx.store.insertRun(id);
+        ctx.runner.run(job, run.id, ctx.store).catch(() => {
+        });
+        return sendJson(res, 202, { runId: run.id });
+      }
+    }
+    if (method === "GET" && path === "/api/runs") {
+      const jobId = url.searchParams.get("jobId") ?? void 0;
+      const limit = url.searchParams.has("limit") ? parseInt(url.searchParams.get("limit"), 10) : void 0;
+      const since = url.searchParams.has("since") ? parseInt(url.searchParams.get("since"), 10) : void 0;
+      return sendJson(res, 200, ctx.store.listRuns({ jobId, limit, since }));
+    }
+    const runMatch = path.match(/^\/api\/runs\/([^/]+)(\/.*)?$/);
+    if (runMatch) {
+      const id = decodeURIComponent(runMatch[1]);
+      const sub = runMatch[2] ?? "";
+      if (method === "GET" && sub === "") {
+        const run = ctx.store.getRun(id);
+        if (!run) return sendError(res, 404, "NOT_FOUND", `Run ${id} not found`);
+        return sendJson(res, 200, run);
+      }
+      if (method === "POST" && sub === "/cancel") {
+        const run = ctx.store.getRun(id);
+        if (!run) return sendError(res, 404, "NOT_FOUND", `Run ${id} not found`);
+        const canceled = ctx.runner.cancelRun(id);
+        return sendJson(res, 200, { ok: true, canceled });
+      }
+      if (method === "GET" && sub === "/logs") {
+        const run = ctx.store.getRun(id);
+        if (!run) return sendError(res, 404, "NOT_FOUND", `Run ${id} not found`);
+        const logs = ctx.store.getLogs(id);
+        return sendJson(res, 200, logs.map((l) => ({
+          runId: l.runId,
+          stream: l.stream,
+          ts: l.ts,
+          data: l.chunk.toString("utf-8")
+        })));
+      }
+      if (method === "GET" && sub === "/logs/stream") {
+        const run = ctx.store.getRun(id);
+        if (!run) return sendError(res, 404, "NOT_FOUND", `Run ${id} not found`);
+        return streamLogs(req, res, id, ctx);
+      }
+    }
+    if (method === "POST" && path === "/api/schedules/validate") {
+      const body = await readBody(req);
+      const { ScheduleSchema: ScheduleSchema2 } = await Promise.resolve().then(() => (init_job(), job_exports));
+      const parsed = ScheduleSchema2.safeParse(body);
+      if (!parsed.success) {
+        return sendJson(res, 200, { ok: false, error: JSON.stringify(parsed.error.format()) });
+      }
+      const result = ctx.scheduler.validateSchedule(parsed.data);
+      return sendJson(res, 200, result);
+    }
+    if (method === "POST" && path === "/api/schedules/preview") {
+      const body = await readBody(req);
+      const { ScheduleSchema: ScheduleSchema2 } = await Promise.resolve().then(() => (init_job(), job_exports));
+      const scheduleResult = ScheduleSchema2.safeParse(body?.schedule ?? body);
+      if (!scheduleResult.success) {
+        return sendError(res, 400, "VALIDATION_ERROR", "Invalid schedule");
+      }
+      const n = typeof body?.n === "number" ? body.n : 5;
+      const tz = body?.tz;
+      const next = ctx.scheduler.previewNext(scheduleResult.data, { n, tz });
+      return sendJson(res, 200, { next });
+    }
+    if (method === "GET" && path === "/api/stats/summary") {
+      const jobs = ctx.store.listJobs();
+      const runs = ctx.store.listRuns({ limit: 1e3 });
+      const failed = runs.filter((r) => r.status === "failed").length;
+      const succeeded = runs.filter((r) => r.status === "success").length;
+      return sendJson(res, 200, {
+        totalJobs: jobs.length,
+        enabledJobs: jobs.filter((j) => j.enabled).length,
+        totalRuns: runs.length,
+        succeeded,
+        failed,
+        avgDurationMs: runs.length > 0 ? Math.round(runs.reduce((s, r) => s + (r.durationMs ?? 0), 0) / runs.length) : null
+      });
+    }
+    const statsJobMatch = path.match(/^\/api\/stats\/jobs\/([^/]+)$/);
+    if (method === "GET" && statsJobMatch) {
+      const id = decodeURIComponent(statsJobMatch[1]);
+      const job = ctx.store.getJob(id);
+      if (!job) return sendError(res, 404, "NOT_FOUND", `Job ${id} not found`);
+      const runs = ctx.store.listRuns({ jobId: id, limit: 100 });
+      return sendJson(res, 200, {
+        jobId: id,
+        totalRuns: runs.length,
+        succeeded: runs.filter((r) => r.status === "success").length,
+        failed: runs.filter((r) => r.status === "failed").length,
+        lastStatus: runs[0]?.status ?? null,
+        lastRunAt: runs[0]?.startedAt ?? null
+      });
+    }
+    if (method === "GET" && path === "/api/daemon/status") {
+      return sendJson(res, 200, {
+        pid: process.pid,
+        version: VERSION,
+        uptimeSec: Math.floor((Date.now() - ctx.startedAt.getTime()) / 1e3),
+        jobs: ctx.store.listJobs().length
+      });
+    }
+    if (method === "POST" && path === "/api/daemon/reload") {
+      await ctx.reload();
+      return sendJson(res, 200, { ok: true });
+    }
+    if (method === "GET" && path === "/api/export") {
+      return sendJson(res, 200, { jobs: ctx.store.listJobs() });
+    }
+    if (method === "POST" && path === "/api/import") {
+      const body = await readBody(req);
+      const jobs = Array.isArray(body?.jobs) ? body.jobs : [];
+      const results = [];
+      for (const raw of jobs) {
+        const parsed = JobSchema.safeParse(raw);
+        if (parsed.success) {
+          ctx.store.upsertJob(parsed.data);
+          ctx.scheduler.schedule(parsed.data, ctx.store);
+          results.push({ id: parsed.data.id, ok: true });
+        } else {
+          results.push({ id: String(raw?.id ?? "?"), ok: false, error: "validation failed" });
+        }
+      }
+      return sendJson(res, 200, { imported: results.filter((r) => r.ok).length, results });
+    }
+    if (method === "GET" && path === "/api/autostart/status") {
+      const backend = url.searchParams.get("backend") ?? void 0;
+      const autostart = createAutostart({ backend });
+      const result = await autostart.status();
+      return sendJson(res, 200, result);
+    }
+    if (method === "POST" && path === "/api/autostart/install") {
+      const body = await readBody(req);
+      const backend = body?.["backend"];
+      const autostart = createAutostart({ backend });
+      const result = await autostart.install();
+      return sendJson(res, 200, result);
+    }
+    if (method === "POST" && path === "/api/autostart/remove") {
+      const body = await readBody(req);
+      const backend = body?.["backend"];
+      const autostart = createAutostart({ backend });
+      const result = await autostart.remove();
+      return sendJson(res, 200, result);
+    }
+    if (method === "GET" && (path === "/" || path === "/dashboard" || path.startsWith("/dashboard/"))) {
+      return serveDashboard(res, path);
+    }
+    return sendError(res, 404, "NOT_FOUND", `${method} ${path} not found`);
+  } catch (err) {
+    if (err instanceof NotImplementedInV1Error) {
+      return sendError(res, 501, "NOT_IMPLEMENTED_V1", err.message);
+    }
+    if (err instanceof CrontickError) {
+      return sendError(res, 400, err.code, err.message, err.details);
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return sendError(res, 500, "INTERNAL_ERROR", msg);
+  }
+}
+function streamLogs(req, res, runId, ctx) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  let lastTs = 0;
+  const existing = ctx.store.getLogs(runId);
+  for (const log of existing) {
+    sseEvent(res, { stream: log.stream, ts: log.ts, data: log.chunk.toString("utf-8") });
+    if (log.ts > lastTs) lastTs = log.ts;
+  }
+  const poll = setInterval(() => {
+    const run = ctx.store.getRun(runId);
+    const newLogs = ctx.store.tailLogs(runId, lastTs);
+    for (const log of newLogs) {
+      sseEvent(res, { stream: log.stream, ts: log.ts, data: log.chunk.toString("utf-8") });
+      if (log.ts > lastTs) lastTs = log.ts;
+    }
+    const terminal = /* @__PURE__ */ new Set(["success", "failed", "canceled", "timeout"]);
+    if (!run || terminal.has(run.status)) {
+      sseEvent(res, { done: true, status: run?.status });
+      clearInterval(poll);
+      res.end();
+    }
+  }, SSE_POLL_MS);
+  req.on("close", () => {
+    clearInterval(poll);
+  });
+}
+function dashboardDir() {
+  const moduleDir = (0, import_node_path5.resolve)((0, import_node_url2.fileURLToPath)(import_meta.url), "..");
+  return (0, import_node_path5.resolve)(moduleDir, "../dashboard");
+}
+function serveDashboard(res, reqPath) {
+  const dashDir = dashboardDir();
+  const indexFile = (0, import_node_path5.join)(dashDir, "index.html");
+  let filePath;
+  if (reqPath === "/" || reqPath === "/dashboard" || reqPath === "/dashboard/") {
+    filePath = indexFile;
+  } else {
+    const sub = reqPath.startsWith("/dashboard/") ? reqPath.slice("/dashboard".length) : reqPath;
+    const normalizedSub = (0, import_node_path5.normalize)(sub).replace(/^[/\\]+/, "");
+    filePath = (0, import_node_path5.resolve)(dashDir, normalizedSub);
+  }
+  if (filePath !== indexFile && !filePath.startsWith(`${dashDir}${import_node_path5.sep}`)) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Bad Request");
+    return;
+  }
+  if (!(0, import_node_fs5.existsSync)(filePath)) {
+    filePath = indexFile;
+  }
+  if (!(0, import_node_fs5.existsSync)(filePath)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  const stat = (0, import_node_fs5.statSync)(filePath);
+  if (!stat.isFile()) {
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("Forbidden");
+    return;
+  }
+  const ext = (0, import_node_path5.extname)(filePath).toLowerCase();
+  const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+  res.writeHead(200, {
+    "Content-Type": contentType,
+    "Content-Length": stat.size,
+    "Cache-Control": "no-cache"
+  });
+  (0, import_node_fs5.createReadStream)(filePath).pipe(res);
+}
+function sseEvent(res, data) {
+  res.write(`data: ${JSON.stringify(data)}
+
+`);
+}
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (!raw) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve({});
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, body) {
+  const json = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(json);
+}
+function sendError(res, status, code, message, details) {
+  sendJson(res, status, { error: { code, message, details } });
+}
+
+// src/daemon/index.ts
+var nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+var needsSqliteShim = nodeMajor < 24 && !process.execArgv.includes("--experimental-sqlite");
+if (needsSqliteShim) {
+  const child = (0, import_node_child_process3.spawn)(process.execPath, ["--experimental-sqlite", ...process.argv.slice(1)], {
+    stdio: "inherit",
+    env: process.env,
+    detached: false
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+} else {
+  let log = function(level, msg, data) {
+    const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...data ? { data } : {} });
+    process.stderr.write(line + "\n");
+    if (logFile) {
+      try {
+        (0, import_node_fs6.appendFileSync)(logFile, line + "\n");
+      } catch {
+      }
+    }
+  }, checkSingleInstance = function() {
+    const pidPath = pidFilePath();
+    if (!(0, import_node_fs6.existsSync)(pidPath)) return;
+    try {
+      const existingPid = parseInt((0, import_node_fs6.readFileSync)(pidPath, "utf-8").trim(), 10);
+      if (!isNaN(existingPid)) {
+        try {
+          process.kill(existingPid, 0);
+          log("error", "Daemon already running", { pid: existingPid });
+          process.exit(1);
+        } catch {
+          log("warn", "Removing stale PID file", { pid: existingPid });
+        }
+      }
+    } catch {
+    }
+  }, cleanup = function() {
+    for (const p of [pidFilePath(), portFilePath()]) {
+      try {
+        if ((0, import_node_fs6.existsSync)(p)) (0, import_node_fs6.unlinkSync)(p);
+      } catch {
+      }
+    }
+  };
+  log2 = log, checkSingleInstance2 = checkSingleInstance, cleanup2 = cleanup;
+  let logFile = null;
+  async function main() {
+    ensureDirs();
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    logFile = (0, import_node_path6.join)(logsDir(), `daemon-${today}.log`);
+    log("info", "Starting crontick daemon", { pid: process.pid, node: process.version });
+    checkSingleInstance();
+    (0, import_node_fs6.writeFileSync)(pidFilePath(), String(process.pid), "utf-8");
+    const store = new Store(runsDbPath(), jobsDir());
+    store.open();
+    const reconciled = store.reconcileOrphanRuns();
+    if (reconciled > 0) {
+      log("warn", `Reconciled ${reconciled} orphaned run(s) from previous daemon session`);
+    }
+    store.loadJobsFromDisk();
+    const jobs = store.listJobs();
+    log("info", `Loaded ${jobs.length} job(s) from disk`);
+    const scheduler = new Scheduler();
+    const runner = new Runner();
+    for (const job of jobs) {
+      if (job.enabled) scheduler.schedule(job, store);
+    }
+    scheduler.on("tick", ({ jobId, plannedAt }) => {
+      const job = store.getJob(jobId);
+      if (!job || !job.enabled) return;
+      const run = store.insertRun(jobId, plannedAt.getTime());
+      runner.run(job, run.id, store).catch((err) => {
+        log("error", "Runner error", { jobId, error: String(err) });
+      });
+    });
+    async function reload() {
+      log("info", "Reloading jobs from disk");
+      scheduler.unscheduleAll();
+      store.loadJobsFromDisk();
+      const reloaded = store.listJobs();
+      for (const job of reloaded) {
+        if (job.enabled) scheduler.schedule(job, store);
+      }
+      log("info", `Reloaded ${reloaded.length} job(s)`);
+    }
+    const startedAt = /* @__PURE__ */ new Date();
+    const ctx = { store, scheduler, runner, startedAt, port: 0, reload };
+    const server = createApiServer(ctx);
+    await new Promise((resolve, reject) => {
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        const port = typeof addr === "object" && addr ? addr.port : 0;
+        ctx.port = port;
+        (0, import_node_fs6.writeFileSync)(portFilePath(), String(port), "utf-8");
+        log("info", `API listening on 127.0.0.1:${port}`);
+        resolve();
+      });
+      server.on("error", reject);
+    });
+    let shuttingDown = false;
+    async function shutdown(signal) {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      log("info", `Received ${signal}, shutting down`);
+      server.close();
+      scheduler.unscheduleAll();
+      await new Promise((r) => setTimeout(r, 100));
+      store.close();
+      cleanup();
+      log("info", "Daemon stopped");
+      process.exit(0);
+    }
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    log("info", "Daemon ready");
+  }
+  main().catch((err) => {
+    process.stderr.write(`Fatal daemon error: ${String(err)}
+`);
+    cleanup();
+    process.exit(1);
+  });
+}
+var log2;
+var checkSingleInstance2;
+var cleanup2;
+//# sourceMappingURL=index.cjs.map