cronfish 0.12.0

package/src/ui/server.ts

@@ -0,0 +1,469 @@
+// Local web dashboard for cronfish. Bound to 127.0.0.1 (no auth).
+//
+// Serves the prebuilt ui/dist/ bundle + a JSON API + a Range-aware log
+// streaming endpoint. The dashboard is read-only — no mutating endpoints.
+
+import { existsSync, statSync } from "node:fs";
+import { extname, join, normalize, resolve } from "node:path";
+import { openDb } from "../db.ts";
+import { dispatchSchedule } from "../schedule.ts";
+
+export interface UiServerOptions {
+  consumerRoot: string;
+  port: number;
+  hostname?: string;
+}
+
+interface JobRow {
+  id: number;
+  slug: string;
+  kind: string;
+  schedule: string;
+  enabled: number;
+  timeout_s: number | null;
+  retries: number;
+  concurrency: string;
+  model: string | null;
+  description: string | null;
+  last_synced_at: string;
+  deleted_at: string | null;
+}
+
+function filenameFromSlug(slug: string): string {
+  // slug encodes the kind as `-<ext>` — reverse it to get the on-disk name.
+  return slug.replace(/-(md|ts|sh|py)$/, ".$1");
+}
+
+function nextRunIso(
+  schedule: string,
+  lastStartedAt: string | null,
+): string | null {
+  try {
+    const d = dispatchSchedule(schedule);
+    if (d.kind !== "seconds") return null;
+    const baseMs = lastStartedAt
+      ? new Date(lastStartedAt).getTime()
+      : Date.now();
+    const periodMs = d.value * 1000;
+    let next = baseMs + periodMs;
+    if (next <= Date.now()) {
+      // skip past missed fires
+      const elapsed = Date.now() - baseMs;
+      next = baseMs + Math.ceil(elapsed / periodMs) * periodMs;
+    }
+    return new Date(next).toISOString();
+  } catch {
+    return null;
+  }
+}
+
+interface InvocationRow {
+  id: number;
+  job_id: number;
+  started_at: string;
+  finished_at: string | null;
+  status: string;
+  exit_code: number | null;
+  trigger: string;
+  log_path: string;
+  result_summary: string | null;
+  result_ok: number | null;
+  result_json: string | null;
+  result_truncated: number;
+}
+
+const MIME: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+};
+
+function distRoot(): string {
+  // server.ts lives at src/ui/server.ts in source, but is consumed from the
+  // installed package layout. Walk up from this file to repo root and join
+  // "ui/dist". URL → pathname avoids node:url import.
+  const here = new URL(".", import.meta.url).pathname;
+  return resolve(here, "..", "..", "ui", "dist");
+}
+
+function json(body: unknown, init?: ResponseInit): Response {
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store",
+      ...(init?.headers ?? {}),
+    },
+  });
+}
+
+function notFound(msg = "not found"): Response {
+  return new Response(msg, { status: 404 });
+}
+
+function badRequest(msg: string): Response {
+  return new Response(msg, { status: 400 });
+}
+
+async function serveStatic(pathname: string): Promise<Response | null> {
+  const dist = distRoot();
+  if (!existsSync(dist)) return null;
+  const rel = pathname === "/" ? "/index.html" : pathname;
+  const safe = normalize(rel).replace(/^\/+/, "");
+  if (safe.startsWith("..")) return null;
+  const full = join(dist, safe);
+  if (!full.startsWith(dist)) return null;
+  if (!existsSync(full)) return null;
+  const st = statSync(full);
+  if (st.isDirectory()) return null;
+  const file = Bun.file(full);
+  const mime = MIME[extname(full).toLowerCase()] ?? "application/octet-stream";
+  return new Response(file, { headers: { "content-type": mime } });
+}
+
+async function spaFallback(): Promise<Response> {
+  const dist = distRoot();
+  const indexPath = join(dist, "index.html");
+  if (!existsSync(indexPath)) {
+    return new Response(
+      "cronfish ui bundle not found.\n\n" +
+        `Expected: ${indexPath}\n\n` +
+        "If you're running from source, build it first:\n" +
+        "  cd ui && bun install && bun run build\n",
+      { status: 503, headers: { "content-type": "text/plain; charset=utf-8" } },
+    );
+  }
+  return new Response(Bun.file(indexPath), {
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+}
+
+function parseRange(
+  header: string | null,
+  size: number,
+): { start: number; end: number } | null {
+  if (!header) return null;
+  const m = header.match(/^bytes=(\d*)-(\d*)$/);
+  if (!m) return null;
+  const startRaw = m[1];
+  const endRaw = m[2];
+  let start: number;
+  let end: number;
+  if (startRaw === "" && endRaw === "") return null;
+  if (startRaw === "") {
+    // suffix range: last N bytes
+    const n = parseInt(endRaw, 10);
+    if (Number.isNaN(n) || n <= 0) return null;
+    start = Math.max(0, size - n);
+    end = size - 1;
+  } else {
+    start = parseInt(startRaw, 10);
+    end = endRaw === "" ? size - 1 : parseInt(endRaw, 10);
+  }
+  if (Number.isNaN(start) || Number.isNaN(end)) return null;
+  if (start > end || start >= size) return null;
+  end = Math.min(end, size - 1);
+  return { start, end };
+}
+
+async function serveLog(
+  consumerRoot: string,
+  invocationId: number,
+  rangeHeader: string | null,
+): Promise<Response> {
+  const db = openDb(consumerRoot);
+  try {
+    const inv = db
+      .query("SELECT log_path FROM cron_invocations WHERE id = $id")
+      .get({ $id: invocationId }) as { log_path: string } | undefined;
+    if (!inv) return notFound("invocation not found");
+    const path = inv.log_path;
+    if (!existsSync(path)) {
+      return new Response("[log file missing]\n", {
+        status: 200,
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+    const st = statSync(path);
+    const size = st.size;
+    const range = parseRange(rangeHeader, size);
+    const file = Bun.file(path);
+    if (range) {
+      const sliced = file.slice(range.start, range.end + 1);
+      return new Response(sliced, {
+        status: 206,
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+          "content-range": `bytes ${range.start}-${range.end}/${size}`,
+          "content-length": String(range.end - range.start + 1),
+          "accept-ranges": "bytes",
+          "cache-control": "no-store",
+        },
+      });
+    }
+    return new Response(file, {
+      headers: {
+        "content-type": "text/plain; charset=utf-8",
+        "content-length": String(size),
+        "accept-ranges": "bytes",
+        "cache-control": "no-store",
+      },
+    });
+  } finally {
+    db.close();
+  }
+}
+
+function listJobs(consumerRoot: string): unknown {
+  const db = openDb(consumerRoot);
+  try {
+    const jobs = db
+      .query<
+        JobRow & {
+          last_status: string | null;
+          last_started_at: string | null;
+          last_finished_at: string | null;
+          last_exit_code: number | null;
+          last_duration_ms: number | null;
+          last_invocation_id: number | null;
+        },
+        []
+      >(
+        `
+        SELECT j.*,
+               last.status         AS last_status,
+               last.started_at     AS last_started_at,
+               last.finished_at    AS last_finished_at,
+               last.exit_code      AS last_exit_code,
+               last.id             AS last_invocation_id,
+               CASE
+                 WHEN last.finished_at IS NULL THEN NULL
+                 ELSE CAST(
+                   (julianday(last.finished_at) - julianday(last.started_at)) * 86400000 AS INTEGER
+                 )
+               END AS last_duration_ms
+        FROM cron_jobs j
+        LEFT JOIN cron_invocations last
+          ON last.id = (
+            SELECT id FROM cron_invocations
+            WHERE job_id = j.id
+            ORDER BY started_at DESC
+            LIMIT 1
+          )
+        ORDER BY j.deleted_at IS NOT NULL, j.slug
+      `,
+      )
+      .all();
+    return jobs.map((j) => ({
+      ...j,
+      filename: filenameFromSlug(j.slug),
+      next_run: nextRunIso(j.schedule, j.last_started_at),
+    }));
+  } finally {
+    db.close();
+  }
+}
+
+function getJob(consumerRoot: string, slug: string): unknown {
+  const db = openDb(consumerRoot);
+  try {
+    const job = db
+      .query<JobRow, [string]>("SELECT * FROM cron_jobs WHERE slug = ?")
+      .get(slug);
+    if (!job) return null;
+    const lastInv = db
+      .query<{ started_at: string | null }, [string]>(
+        `SELECT i.started_at FROM cron_invocations i
+         JOIN cron_jobs j ON j.id = i.job_id
+         WHERE j.slug = ?
+         ORDER BY i.started_at DESC LIMIT 1`,
+      )
+      .get(slug);
+    return {
+      ...job,
+      filename: filenameFromSlug(job.slug),
+      next_run: nextRunIso(job.schedule, lastInv?.started_at ?? null),
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// log_path holds an absolute filesystem path on the host (e.g.
+// /Users/<user>/...) — strip it from API responses so consumers that proxy
+// the dashboard to the public internet don't leak host paths. The bytes are
+// still served via /api/invocations/:id/log, which looks log_path up
+// server-side.
+function stripLogPath<T extends { log_path?: string }>(row: T): Omit<T, "log_path"> {
+  const { log_path: _, ...rest } = row;
+  return rest;
+}
+
+function listInvocations(
+  consumerRoot: string,
+  slug: string,
+  limit: number,
+): unknown {
+  const db = openDb(consumerRoot);
+  try {
+    const rows = db
+      .query<InvocationRow & { duration_ms: number | null }, [string, number]>(
+        `
+        SELECT i.*,
+          CASE
+            WHEN i.finished_at IS NULL THEN NULL
+            ELSE CAST(
+              (julianday(i.finished_at) - julianday(i.started_at)) * 86400000 AS INTEGER
+            )
+          END AS duration_ms
+        FROM cron_invocations i
+        JOIN cron_jobs j ON j.id = i.job_id
+        WHERE j.slug = ?
+        ORDER BY i.started_at DESC
+        LIMIT ?
+      `,
+      )
+      .all(slug, limit);
+    return rows.map(stripLogPath);
+  } finally {
+    db.close();
+  }
+}
+
+function listAllInvocations(consumerRoot: string, limit: number): unknown {
+  const db = openDb(consumerRoot);
+  try {
+    const rows = db
+      .query<
+        InvocationRow & { slug: string; duration_ms: number | null },
+        [number]
+      >(
+        `
+        SELECT i.*, j.slug AS slug,
+          CASE
+            WHEN i.finished_at IS NULL THEN NULL
+            ELSE CAST(
+              (julianday(i.finished_at) - julianday(i.started_at)) * 86400000 AS INTEGER
+            )
+          END AS duration_ms
+        FROM cron_invocations i
+        JOIN cron_jobs j ON j.id = i.job_id
+        ORDER BY i.started_at DESC
+        LIMIT ?
+      `,
+      )
+      .all(limit);
+    return rows.map(stripLogPath);
+  } finally {
+    db.close();
+  }
+}
+
+function getInvocation(consumerRoot: string, id: number): unknown {
+  const db = openDb(consumerRoot);
+  try {
+    const row = db
+      .query<
+        InvocationRow & { slug: string; duration_ms: number | null },
+        [number]
+      >(
+        `
+        SELECT i.*, j.slug AS slug,
+          CASE
+            WHEN i.finished_at IS NULL THEN NULL
+            ELSE CAST(
+              (julianday(i.finished_at) - julianday(i.started_at)) * 86400000 AS INTEGER
+            )
+          END AS duration_ms
+        FROM cron_invocations i
+        JOIN cron_jobs j ON j.id = i.job_id
+        WHERE i.id = ?
+      `,
+      )
+      .get(id);
+    return row ? stripLogPath(row) : null;
+  } finally {
+    db.close();
+  }
+}
+
+export async function startUiServer(opts: UiServerOptions): Promise<string> {
+  const hostname = opts.hostname ?? "127.0.0.1";
+  const server = Bun.serve({
+    hostname,
+    port: opts.port,
+    fetch: async (req) => {
+      const url = new URL(req.url);
+      const { pathname } = url;
+
+      // --- API ---
+      if (pathname === "/api/jobs" && req.method === "GET") {
+        return json(listJobs(opts.consumerRoot));
+      }
+
+      const jobDetail = pathname.match(/^\/api\/jobs\/([^/]+)$/);
+      if (jobDetail && req.method === "GET") {
+        const slug = decodeURIComponent(jobDetail[1]);
+        const row = getJob(opts.consumerRoot, slug);
+        return row ? json(row) : notFound("job not found");
+      }
+
+      const jobInv = pathname.match(/^\/api\/jobs\/([^/]+)\/invocations$/);
+      if (jobInv && req.method === "GET") {
+        const slug = decodeURIComponent(jobInv[1]);
+        const limitParam = url.searchParams.get("limit");
+        const limit = limitParam ? parseInt(limitParam, 10) : 50;
+        if (Number.isNaN(limit) || limit <= 0 || limit > 1000) {
+          return badRequest("limit must be 1..1000");
+        }
+        return json(listInvocations(opts.consumerRoot, slug, limit));
+      }
+
+      if (pathname === "/api/invocations" && req.method === "GET") {
+        const limitParam = url.searchParams.get("limit");
+        const limit = limitParam ? parseInt(limitParam, 10) : 100;
+        if (Number.isNaN(limit) || limit <= 0 || limit > 1000) {
+          return badRequest("limit must be 1..1000");
+        }
+        return json(listAllInvocations(opts.consumerRoot, limit));
+      }
+
+      const invDetail = pathname.match(/^\/api\/invocations\/(\d+)$/);
+      if (invDetail && req.method === "GET") {
+        const id = parseInt(invDetail[1], 10);
+        const row = getInvocation(opts.consumerRoot, id);
+        return row ? json(row) : notFound("invocation not found");
+      }
+
+      const invLog = pathname.match(/^\/api\/invocations\/(\d+)\/log$/);
+      if (invLog && req.method === "GET") {
+        const id = parseInt(invLog[1], 10);
+        return serveLog(opts.consumerRoot, id, req.headers.get("range"));
+      }
+
+      if (pathname.startsWith("/api/")) return notFound("unknown api route");
+
+      // --- Static + SPA ---
+      const staticHit = await serveStatic(pathname);
+      if (staticHit) return staticHit;
+      return spaFallback();
+    },
+    error: (err) => {
+      console.error("[cronfish ui]", err);
+      return new Response(`server error: ${err.message}`, { status: 500 });
+    },
+  });
+  return `http://${server.hostname}:${server.port}`;
+}

package/src/watchdog.ts

@@ -0,0 +1,201 @@
+// Watchdog: detect crons that should have fired but didn't.
+//
+// One alert per miss window: after firing a `missed` for a job, stay quiet
+// until the job runs successfully again (which resets the baseline by way of
+// last_ok advancing past any earlier `missed` row).
+//
+// Cold-start: jobs with zero successful runs are skipped — brand-new crons
+// don't ping until they've succeeded at least once.
+
+import { Database } from "bun:sqlite";
+import { join } from "node:path";
+import {
+  buildRegistry,
+  loadConsumerAlertsConfig,
+  safeNotify,
+  type AlertPayload,
+} from "./alerts/index.ts";
+import { chooseAdapterName, buildUiUrl } from "./alerts/dispatch.ts";
+import {
+  getJobIdBySlug,
+  getLastOkStartedAt,
+  getLatestMissedFiredAt,
+  listEnabledJobs,
+  openDb,
+  recordMissedAlert,
+} from "./db.ts";
+import { discoverJobs } from "./jobs.ts";
+import {
+  intervalSecondsAt,
+  nextFireAfter,
+  parseMissedAfter,
+} from "./schedule.ts";
+
+const DEFAULT_GRACE_FLOOR_S = 600;
+
+export interface WatchdogDecision {
+  slug: string;
+  outcome: "skipped-cold" | "skipped-manual" | "skipped-on-time" |
+           "skipped-already-fired" | "skipped-no-adapter" |
+           "fired" | "fire-failed";
+  expected_at?: string;
+  grace_s?: number;
+  error?: string;
+}
+
+export interface WatchdogInput {
+  consumerRoot: string;
+  now?: Date;
+}
+
+export async function runWatchdog(
+  input: WatchdogInput,
+): Promise<WatchdogDecision[]> {
+  const now = input.now ?? new Date();
+  const cronDir = join(input.consumerRoot, "cron");
+  const { jobs } = discoverJobs(cronDir);
+  const jobBySlug = new Map(jobs.map((j) => [j.slug, j]));
+
+  const db = openDb(input.consumerRoot);
+  const cfg = loadConsumerAlertsConfig(input.consumerRoot);
+  const registry = buildRegistry(cfg.alerts);
+  const decisions: WatchdogDecision[] = [];
+
+  try {
+    const rows = listEnabledJobs(db);
+    for (const row of rows) {
+      const job = jobBySlug.get(row.slug);
+      if (!job) continue;
+      if (row.schedule === "manual") {
+        decisions.push({ slug: row.slug, outcome: "skipped-manual" });
+        continue;
+      }
+      const lastOk = getLastOkStartedAt(db, row.id);
+      if (!lastOk) {
+        decisions.push({ slug: row.slug, outcome: "skipped-cold" });
+        continue;
+      }
+      const lastOkDate = new Date(lastOk);
+      const expected = nextFireAfter(job.schedule, lastOkDate);
+      if (!expected) {
+        decisions.push({ slug: row.slug, outcome: "skipped-manual" });
+        continue;
+      }
+      const intervalS = intervalSecondsAt(job.schedule, expected) ?? 60;
+      const overrideS = parseMissedAfter(job.missed_after);
+      const graceS = overrideS ?? Math.max(2 * intervalS, DEFAULT_GRACE_FLOOR_S);
+      const deadline = new Date(expected.getTime() + graceS * 1000);
+      if (now < deadline) {
+        decisions.push({
+          slug: row.slug,
+          outcome: "skipped-on-time",
+          expected_at: expected.toISOString(),
+          grace_s: graceS,
+        });
+        continue;
+      }
+      const lastMissed = getLatestMissedFiredAt(db, row.id);
+      if (lastMissed && new Date(lastMissed) > lastOkDate) {
+        decisions.push({
+          slug: row.slug,
+          outcome: "skipped-already-fired",
+          expected_at: expected.toISOString(),
+          grace_s: graceS,
+        });
+        continue;
+      }
+      const adapterName = chooseAdapterName(job.on_failure, cfg.alerts);
+      if (!adapterName || !registry.has(adapterName)) {
+        decisions.push({
+          slug: row.slug,
+          outcome: "skipped-no-adapter",
+          expected_at: expected.toISOString(),
+          grace_s: graceS,
+        });
+        continue;
+      }
+      const payload: AlertPayload = {
+        slug: row.slug,
+        status: "missed",
+        exit_code: null,
+        duration_ms: null,
+        started_at: expected.toISOString(),
+        log_tail: `expected at ${expected.toISOString()}, grace ${graceS}s, last ok ${lastOk}`,
+        ui_url: jobUiUrl(cfg, row.slug),
+      };
+      const outcome = await safeNotify(registry.get(adapterName), payload);
+      if (outcome.status === "sent") {
+        recordMissedAlert(db, row.id, expected.toISOString());
+        decisions.push({
+          slug: row.slug,
+          outcome: "fired",
+          expected_at: expected.toISOString(),
+          grace_s: graceS,
+        });
+      } else {
+        decisions.push({
+          slug: row.slug,
+          outcome: "fire-failed",
+          expected_at: expected.toISOString(),
+          grace_s: graceS,
+          error: outcome.error ?? "unknown",
+        });
+      }
+    }
+  } finally {
+    try {
+      db.close();
+    } catch {}
+  }
+  return decisions;
+}
+
+function jobUiUrl(
+  cfg: ReturnType<typeof loadConsumerAlertsConfig>,
+  slug: string,
+): string | null {
+  const base = cfg.ui?.public_url?.trim();
+  if (!base) return null;
+  return `${base.replace(/\/$/, "")}/jobs/${encodeURIComponent(slug)}`;
+}
+
+// Pure decision helper for unit tests — no DB / no IO.
+export interface DecisionInput {
+  now: Date;
+  schedule: string | number | undefined;
+  lastOk: string | null;
+  lastMissedFiredAt: string | null;
+  missedAfter?: string;
+  adapterConfigured: boolean;
+}
+
+export function decideWatchdog(input: DecisionInput): {
+  outcome: WatchdogDecision["outcome"];
+  expected?: Date;
+  grace_s?: number;
+} {
+  if (input.schedule === "manual" || input.schedule === undefined) {
+    return { outcome: "skipped-manual" };
+  }
+  if (!input.lastOk) return { outcome: "skipped-cold" };
+  const lastOkDate = new Date(input.lastOk);
+  const expected = nextFireAfter(input.schedule, lastOkDate);
+  if (!expected) return { outcome: "skipped-manual" };
+  const intervalS = intervalSecondsAt(input.schedule, expected) ?? 60;
+  const overrideS = parseMissedAfter(input.missedAfter);
+  const graceS = overrideS ?? Math.max(2 * intervalS, DEFAULT_GRACE_FLOOR_S);
+  const deadline = new Date(expected.getTime() + graceS * 1000);
+  if (input.now < deadline) {
+    return { outcome: "skipped-on-time", expected, grace_s: graceS };
+  }
+  if (
+    input.lastMissedFiredAt &&
+    new Date(input.lastMissedFiredAt) > lastOkDate
+  ) {
+    return { outcome: "skipped-already-fired", expected, grace_s: graceS };
+  }
+  if (!input.adapterConfigured) {
+    return { outcome: "skipped-no-adapter", expected, grace_s: graceS };
+  }
+  return { outcome: "fired", expected, grace_s: graceS };
+}

package/templates/_examples/one-time/echo-at.md

@@ -0,0 +1,10 @@
+---
+description: "Smoke test for cron/one-time/ — fires once at +10s and writes a tempfile"
+run_at: "+10s"
+model: haiku
+timeout: 30
+---
+
+Append the line `hello from one-time` to `/tmp/cronfish-one-time-smoke.txt` (create the file if needed). Then print exactly:
+
+`__CRONFISH_RESULT_V1__::{"summary":"echo-at fired","ok":true}`