crontick 0.1.0

package/dist/daemon/index.js

@@ -0,0 +1,1306 @@
+#!/usr/bin/env node
+import {
+  NotImplementedInV1Error,
+  createAutostart
+} from "../chunk-LPAFZNXK.js";
+import {
+  CrontickError
+} from "../chunk-YMAT5MON.js";
+import {
+  VERSION,
+  ensureDirs,
+  jobsDir,
+  logsDir,
+  pidFilePath,
+  portFilePath,
+  runsDbPath
+} from "../chunk-FMGZ3SSS.js";
+import {
+  JobSchema
+} from "../chunk-35FFLWP3.js";
+
+// src/daemon/index.ts
+import { spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync3, appendFileSync } from "fs";
+import { join as join3 } from "path";
+
+// src/daemon/store.ts
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "crypto";
+import { writeFileSync, readFileSync, unlinkSync, readdirSync, existsSync } from "fs";
+import { join } from "path";
+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 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 = join(this.jobsPath, `${job.id}.json`);
+    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 = join(this.jobsPath, `${id}.json`);
+    if (existsSync(filePath)) {
+      try {
+        unlinkSync(filePath);
+      } catch {
+      }
+    }
+    return changes > 0;
+  }
+  /** Load jobs from the jobs directory (disk is source of truth on daemon start). */
+  loadJobsFromDisk() {
+    if (!existsSync(this.jobsPath)) return;
+    const files = readdirSync(this.jobsPath).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const raw = readFileSync(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 = 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
+import { EventEmitter } from "events";
+import { Cron } from "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 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 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 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 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 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
+import { spawn } from "child_process";
+import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { tmpdir, platform } from "os";
+import { join as join2, isAbsolute } from "path";
+import { randomUUID as randomUUID2 } from "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 = join2(tmpdir(), "crontick");
+        mkdirSync(tmpDir, { recursive: true });
+        tmpFile = join2(tmpDir, `${randomUUID2()}${ext}`);
+        writeFileSync2(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 = isAbsolute(action.envFile) ? action.envFile : join2(action.cwd ?? process.cwd(), action.envFile);
+        try {
+          const fileContents = readFileSync2(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 = 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 && existsSync2(tmpFile)) {
+        try {
+          unlinkSync2(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 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
+import http from "http";
+import { createReadStream, existsSync as fsExistsSync, statSync } from "fs";
+import {
+  extname,
+  resolve as pathResolve,
+  join as pathJoin,
+  normalize,
+  sep as pathSep
+} from "path";
+import { URL } from "url";
+import { fileURLToPath } from "url";
+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 = http.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 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 } = await import("../job-JQGLDEJV.js");
+      const parsed = ScheduleSchema.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 } = await import("../job-JQGLDEJV.js");
+      const scheduleResult = ScheduleSchema.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 = pathResolve(fileURLToPath(import.meta.url), "..");
+  return pathResolve(moduleDir, "../dashboard");
+}
+function serveDashboard(res, reqPath) {
+  const dashDir = dashboardDir();
+  const indexFile = pathJoin(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 = normalize(sub).replace(/^[/\\]+/, "");
+    filePath = pathResolve(dashDir, normalizedSub);
+  }
+  if (filePath !== indexFile && !filePath.startsWith(`${dashDir}${pathSep}`)) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Bad Request");
+    return;
+  }
+  if (!fsExistsSync(filePath)) {
+    filePath = indexFile;
+  }
+  if (!fsExistsSync(filePath)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  const stat = statSync(filePath);
+  if (!stat.isFile()) {
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("Forbidden");
+    return;
+  }
+  const ext = 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"
+  });
+  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 = spawn2(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 {
+        appendFileSync(logFile, line + "\n");
+      } catch {
+      }
+    }
+  }, checkSingleInstance = function() {
+    const pidPath = pidFilePath();
+    if (!existsSync3(pidPath)) return;
+    try {
+      const existingPid = parseInt(readFileSync3(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 (existsSync3(p)) unlinkSync3(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 = join3(logsDir(), `daemon-${today}.log`);
+    log("info", "Starting crontick daemon", { pid: process.pid, node: process.version });
+    checkSingleInstance();
+    writeFileSync3(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;
+        writeFileSync3(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.js.map