@hasna/uptime 0.1.0

package/dist/index.js

@@ -0,0 +1,1090 @@
+// @bun
+// src/checks.ts
+import net from "net";
+async function runMonitorCheck(monitor, options = {}) {
+  if (!monitor.enabled) {
+    return { status: "down", latencyMs: null, error: "monitor is disabled" };
+  }
+  if (monitor.kind === "http")
+    return runHttpCheck(monitor, options.fetch ?? fetch);
+  return runTcpCheck(monitor);
+}
+async function runHttpCheck(monitor, fetchImpl = fetch) {
+  if (!monitor.url)
+    return { status: "down", latencyMs: null, error: "missing url" };
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), monitor.timeoutMs);
+  const started = performance.now();
+  try {
+    const response = await fetchImpl(monitor.url, {
+      method: monitor.method || "GET",
+      redirect: "manual",
+      signal: controller.signal
+    });
+    const latencyMs = Math.round((performance.now() - started) * 100) / 100;
+    const ok = monitor.expectedStatus == null ? response.status >= 200 && response.status < 400 : response.status === monitor.expectedStatus;
+    return {
+      status: ok ? "up" : "down",
+      latencyMs,
+      statusCode: response.status,
+      error: ok ? null : `unexpected status ${response.status}`
+    };
+  } catch (error) {
+    return {
+      status: "down",
+      latencyMs: Math.round((performance.now() - started) * 100) / 100,
+      statusCode: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function runTcpCheck(monitor) {
+  if (!monitor.host || !monitor.port)
+    return { status: "down", latencyMs: null, error: "missing host or port" };
+  const started = performance.now();
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: monitor.host, port: monitor.port, timeout: monitor.timeoutMs });
+    let settled = false;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.once("connect", () => {
+      finish({ status: "up", latencyMs: Math.round((performance.now() - started) * 100) / 100, statusCode: null, error: null });
+    });
+    socket.once("timeout", () => {
+      finish({ status: "down", latencyMs: Math.round((performance.now() - started) * 100) / 100, statusCode: null, error: "tcp timeout" });
+    });
+    socket.once("error", (error) => {
+      finish({ status: "down", latencyMs: Math.round((performance.now() - started) * 100) / 100, statusCode: null, error: error.message });
+    });
+  });
+}
+
+// src/paths.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function uptimeHome() {
+  return process.env.HASNA_UPTIME_HOME || join(homedir(), ".hasna", "uptime");
+}
+function uptimeDbPath() {
+  return process.env.HASNA_UPTIME_DB || join(uptimeHome(), "uptime.db");
+}
+function ensureUptimeHome() {
+  const home = uptimeHome();
+  mkdirSync(home, { recursive: true });
+  return home;
+}
+
+// src/store.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+import { Database } from "bun:sqlite";
+
+// src/limits.ts
+var MIN_INTERVAL_SECONDS = 1;
+var MAX_INTERVAL_SECONDS = 86400;
+var MIN_TIMEOUT_MS = 1;
+var MAX_TIMEOUT_MS = 60000;
+var MIN_RETRY_COUNT = 0;
+var MAX_RETRY_COUNT = 10;
+var MAX_RESULT_LIMIT = 1000;
+
+// src/store.ts
+class UptimeStore {
+  dbPath;
+  db;
+  constructor(options = {}) {
+    this.dbPath = options.dbPath ?? uptimeDbPath();
+    if (this.dbPath !== ":memory:") {
+      mkdirSync2(dirname(this.dbPath), { recursive: true });
+    }
+    this.db = new Database(this.dbPath, { create: true });
+    this.db.run("PRAGMA journal_mode = WAL");
+    this.db.run("PRAGMA foreign_keys = ON");
+    this.migrate();
+  }
+  close() {
+    this.db.close();
+  }
+  migrate() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS monitors (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        kind TEXT NOT NULL CHECK (kind IN ('http', 'tcp')),
+        url TEXT,
+        host TEXT,
+        port INTEGER,
+        method TEXT NOT NULL DEFAULT 'GET',
+        expected_status INTEGER,
+        interval_seconds INTEGER NOT NULL DEFAULT 60,
+        timeout_ms INTEGER NOT NULL DEFAULT 5000,
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        status TEXT NOT NULL DEFAULT 'unknown',
+        last_checked_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS check_results (
+        id TEXT PRIMARY KEY,
+        monitor_id TEXT NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
+        checked_at TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('up', 'down')),
+        latency_ms REAL,
+        status_code INTEGER,
+        error TEXT,
+        attempt_count INTEGER NOT NULL DEFAULT 1
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS incidents (
+        id TEXT PRIMARY KEY,
+        monitor_id TEXT NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
+        status TEXT NOT NULL CHECK (status IN ('open', 'closed')),
+        opened_at TEXT NOT NULL,
+        closed_at TEXT,
+        last_failure_at TEXT NOT NULL,
+        failure_count INTEGER NOT NULL DEFAULT 1,
+        recovery_check_id TEXT,
+        reason TEXT
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_results_monitor_time ON check_results(monitor_id, checked_at DESC)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_incidents_monitor_status ON incidents(monitor_id, status)");
+  }
+  createMonitor(input) {
+    const normalized = normalizeCreateMonitor(input);
+    const now = new Date().toISOString();
+    const monitor = {
+      id: newId("mon"),
+      name: normalized.name,
+      kind: normalized.kind,
+      url: normalized.url ?? null,
+      host: normalized.host ?? null,
+      port: normalized.port ?? null,
+      method: normalized.method ?? "GET",
+      expectedStatus: normalized.expectedStatus ?? null,
+      intervalSeconds: normalized.intervalSeconds ?? 60,
+      timeoutMs: normalized.timeoutMs ?? 5000,
+      retryCount: normalized.retryCount ?? 0,
+      enabled: normalized.enabled ?? true,
+      status: normalized.enabled === false ? "paused" : "unknown",
+      lastCheckedAt: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.query(`INSERT INTO monitors (
+          id, name, kind, url, host, port, method, expected_status,
+          interval_seconds, timeout_ms, retry_count, enabled, status,
+          last_checked_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(monitor.id, monitor.name, monitor.kind, monitor.url, monitor.host, monitor.port, monitor.method, monitor.expectedStatus, monitor.intervalSeconds, monitor.timeoutMs, monitor.retryCount, monitor.enabled ? 1 : 0, monitor.status, monitor.lastCheckedAt, monitor.createdAt, monitor.updatedAt);
+    return monitor;
+  }
+  listMonitors(options = {}) {
+    const rows = options.includeDisabled ? this.db.query("SELECT * FROM monitors ORDER BY name ASC").all() : this.db.query("SELECT * FROM monitors WHERE enabled = 1 ORDER BY name ASC").all();
+    return rows.map(monitorFromRow);
+  }
+  getMonitor(idOrName) {
+    const row = this.db.query("SELECT * FROM monitors WHERE id = ? OR name = ?").get(idOrName, idOrName);
+    return row ? monitorFromRow(row) : null;
+  }
+  updateMonitor(idOrName, input) {
+    const current = this.getMonitor(idOrName);
+    if (!current)
+      throw new Error(`Monitor not found: ${idOrName}`);
+    const updatedAt = new Date().toISOString();
+    const next = normalizeUpdateMonitor(current, input, updatedAt);
+    this.db.query(`UPDATE monitors SET
+          name = ?, kind = ?, url = ?, host = ?, port = ?, method = ?,
+          expected_status = ?, interval_seconds = ?, timeout_ms = ?,
+          retry_count = ?, enabled = ?, status = ?, last_checked_at = ?, updated_at = ?
+        WHERE id = ?`).run(next.name, next.kind, next.url, next.host, next.port, next.method, next.expectedStatus, next.intervalSeconds, next.timeoutMs, next.retryCount, next.enabled ? 1 : 0, next.status, next.lastCheckedAt, updatedAt, current.id);
+    return this.getMonitor(current.id);
+  }
+  deleteMonitor(idOrName) {
+    const current = this.getMonitor(idOrName);
+    if (!current)
+      return false;
+    this.db.query("DELETE FROM monitors WHERE id = ?").run(current.id);
+    return true;
+  }
+  recordCheckResult(input) {
+    const monitor = this.getMonitor(input.monitorId);
+    if (!monitor)
+      throw new Error(`Monitor not found: ${input.monitorId}`);
+    const checkedAt = input.checkedAt ?? new Date().toISOString();
+    const result = {
+      id: newId("chk"),
+      monitorId: monitor.id,
+      checkedAt,
+      status: input.status,
+      latencyMs: input.latencyMs,
+      statusCode: input.statusCode,
+      error: input.error,
+      attemptCount: Math.max(1, input.attemptCount)
+    };
+    const tx = this.db.transaction(() => {
+      this.db.query(`INSERT INTO check_results (
+            id, monitor_id, checked_at, status, latency_ms, status_code, error, attempt_count
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(result.id, result.monitorId, result.checkedAt, result.status, result.latencyMs, result.statusCode, result.error, result.attemptCount);
+      this.db.query("UPDATE monitors SET status = ?, last_checked_at = ?, updated_at = ? WHERE id = ?").run(result.status, result.checkedAt, result.checkedAt, result.monitorId);
+      this.reconcileIncidentInTransaction(result);
+    });
+    tx();
+    return result;
+  }
+  listResults(options = {}) {
+    const limit = clampLimit(options.limit ?? 50);
+    const rows = options.monitorId ? this.db.query("SELECT * FROM check_results WHERE monitor_id = ? ORDER BY checked_at DESC LIMIT ?").all(options.monitorId, limit) : this.db.query("SELECT * FROM check_results ORDER BY checked_at DESC LIMIT ?").all(limit);
+    return rows.map(checkResultFromRow);
+  }
+  listIncidents(options = {}) {
+    const clauses = [];
+    const args = [];
+    if (options.status) {
+      clauses.push("status = ?");
+      args.push(options.status);
+    }
+    if (options.monitorId) {
+      clauses.push("monitor_id = ?");
+      args.push(options.monitorId);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    args.push(clampLimit(options.limit ?? 50));
+    const rows = this.db.query(`SELECT * FROM incidents ${where} ORDER BY opened_at DESC LIMIT ?`).all(...args);
+    return rows.map(incidentFromRow);
+  }
+  getOpenIncident(monitorId) {
+    const row = this.db.query("SELECT * FROM incidents WHERE monitor_id = ? AND status = 'open' ORDER BY opened_at DESC LIMIT 1").get(monitorId);
+    return row ? incidentFromRow(row) : null;
+  }
+  summary() {
+    const monitors = this.listMonitors({ includeDisabled: true });
+    const summaries = monitors.map((monitor) => this.monitorSummary(monitor));
+    return {
+      generatedAt: new Date().toISOString(),
+      monitors: summaries,
+      totals: {
+        monitors: monitors.length,
+        enabled: monitors.filter((m) => m.enabled).length,
+        up: monitors.filter((m) => m.status === "up").length,
+        down: monitors.filter((m) => m.status === "down").length,
+        paused: monitors.filter((m) => !m.enabled || m.status === "paused").length,
+        unknown: monitors.filter((m) => m.status === "unknown").length,
+        openIncidents: this.listIncidents({ status: "open", limit: 1000 }).length
+      }
+    };
+  }
+  monitorSummary(monitor) {
+    const row = this.db.query(`SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN status = 'up' THEN 1 ELSE 0 END) as up_count,
+          SUM(CASE WHEN status = 'down' THEN 1 ELSE 0 END) as down_count,
+          AVG(CASE WHEN status = 'up' THEN latency_ms ELSE NULL END) as avg_latency
+        FROM check_results WHERE monitor_id = ?`).get(monitor.id);
+    const total = Number(row.total ?? 0);
+    const up = Number(row.up_count ?? 0);
+    const down = Number(row.down_count ?? 0);
+    return {
+      monitor,
+      totalChecks: total,
+      upChecks: up,
+      downChecks: down,
+      uptimePercent: total > 0 ? round(up / total * 100, 4) : null,
+      averageLatencyMs: row.avg_latency == null ? null : round(row.avg_latency, 2),
+      openIncident: this.getOpenIncident(monitor.id)
+    };
+  }
+  reconcileIncidentInTransaction(result) {
+    const open = this.db.query("SELECT * FROM incidents WHERE monitor_id = ? AND status = 'open' ORDER BY opened_at DESC LIMIT 1").get(result.monitorId);
+    if (result.status === "down") {
+      if (open) {
+        this.db.query("UPDATE incidents SET last_failure_at = ?, failure_count = failure_count + 1, reason = COALESCE(?, reason) WHERE id = ?").run(result.checkedAt, result.error, open.id);
+      } else {
+        this.db.query(`INSERT INTO incidents (
+              id, monitor_id, status, opened_at, closed_at, last_failure_at,
+              failure_count, recovery_check_id, reason
+            ) VALUES (?, ?, 'open', ?, NULL, ?, 1, NULL, ?)`).run(newId("inc"), result.monitorId, result.checkedAt, result.checkedAt, result.error);
+      }
+      return;
+    }
+    if (open) {
+      this.db.query("UPDATE incidents SET status = 'closed', closed_at = ?, recovery_check_id = ? WHERE id = ?").run(result.checkedAt, result.id, open.id);
+    }
+  }
+}
+function normalizeCreateMonitor(input) {
+  const name = input.name?.trim();
+  if (!name)
+    throw new Error("Monitor name is required");
+  const method = normalizeMethod(input.method ?? "GET");
+  const expectedStatus = normalizeExpectedStatus(input.expectedStatus);
+  if (input.kind === "http") {
+    const url = normalizeHttpUrl(input.url);
+    return {
+      name,
+      kind: input.kind,
+      url,
+      method,
+      expectedStatus,
+      intervalSeconds: boundedInteger(input.intervalSeconds ?? 60, "intervalSeconds", MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS),
+      timeoutMs: boundedInteger(input.timeoutMs ?? 5000, "timeoutMs", MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
+      retryCount: boundedInteger(input.retryCount ?? 0, "retryCount", MIN_RETRY_COUNT, MAX_RETRY_COUNT),
+      enabled: input.enabled ?? true
+    };
+  } else if (input.kind === "tcp") {
+    const host = input.host?.trim();
+    if (!host)
+      throw new Error("TCP monitors require host");
+    if (!Number.isInteger(input.port) || input.port <= 0 || input.port > 65535) {
+      throw new Error("TCP monitors require a port from 1 to 65535");
+    }
+    return {
+      name,
+      kind: input.kind,
+      host,
+      port: input.port,
+      method,
+      expectedStatus: null,
+      intervalSeconds: boundedInteger(input.intervalSeconds ?? 60, "intervalSeconds", MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS),
+      timeoutMs: boundedInteger(input.timeoutMs ?? 5000, "timeoutMs", MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
+      retryCount: boundedInteger(input.retryCount ?? 0, "retryCount", MIN_RETRY_COUNT, MAX_RETRY_COUNT),
+      enabled: input.enabled ?? true
+    };
+  } else {
+    throw new Error("Monitor kind must be http or tcp");
+  }
+}
+function normalizeUpdateMonitor(current, input, updatedAt) {
+  const merged = {
+    ...current,
+    ...input,
+    expectedStatus: input.expectedStatus === undefined ? current.expectedStatus : input.expectedStatus,
+    updatedAt
+  };
+  const normalized = normalizeCreateMonitor({
+    name: merged.name,
+    kind: merged.kind,
+    url: merged.url ?? undefined,
+    host: merged.host ?? undefined,
+    port: merged.port ?? undefined,
+    method: merged.method,
+    expectedStatus: merged.expectedStatus,
+    intervalSeconds: merged.intervalSeconds,
+    timeoutMs: merged.timeoutMs,
+    retryCount: merged.retryCount,
+    enabled: merged.enabled
+  });
+  const checkDefinitionChanged = normalized.kind !== current.kind || (normalized.url ?? null) !== current.url || (normalized.host ?? null) !== current.host || (normalized.port ?? null) !== current.port || normalized.method !== current.method || normalized.expectedStatus !== current.expectedStatus;
+  const status = normalized.enabled ? checkDefinitionChanged || !current.enabled ? "unknown" : current.status : "paused";
+  return {
+    ...current,
+    name: normalized.name,
+    kind: normalized.kind,
+    url: normalized.url ?? null,
+    host: normalized.host ?? null,
+    port: normalized.port ?? null,
+    method: normalized.method,
+    expectedStatus: normalized.expectedStatus,
+    intervalSeconds: normalized.intervalSeconds,
+    timeoutMs: normalized.timeoutMs,
+    retryCount: normalized.retryCount,
+    enabled: normalized.enabled,
+    status,
+    lastCheckedAt: checkDefinitionChanged ? null : current.lastCheckedAt,
+    updatedAt
+  };
+}
+function normalizeHttpUrl(value) {
+  const raw = value?.trim();
+  if (!raw)
+    throw new Error("HTTP monitors require url");
+  const parsed = new URL(raw);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("HTTP monitor url must use http or https");
+  }
+  return parsed.toString();
+}
+function normalizeMethod(value) {
+  const method = value.trim().toUpperCase();
+  if (!/^[A-Z]+$/.test(method))
+    throw new Error("HTTP method must contain only letters");
+  return method;
+}
+function normalizeExpectedStatus(value) {
+  if (value == null)
+    return null;
+  if (!Number.isInteger(value) || value < 100 || value > 599) {
+    throw new Error("expectedStatus must be an HTTP status from 100 to 599");
+  }
+  return value;
+}
+function monitorFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    kind: row.kind,
+    url: row.url,
+    host: row.host,
+    port: row.port,
+    method: row.method,
+    expectedStatus: row.expected_status,
+    intervalSeconds: row.interval_seconds,
+    timeoutMs: row.timeout_ms,
+    retryCount: row.retry_count,
+    enabled: Boolean(row.enabled),
+    status: row.status,
+    lastCheckedAt: row.last_checked_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function checkResultFromRow(row) {
+  return {
+    id: row.id,
+    monitorId: row.monitor_id,
+    checkedAt: row.checked_at,
+    status: row.status,
+    latencyMs: row.latency_ms,
+    statusCode: row.status_code,
+    error: row.error,
+    attemptCount: row.attempt_count
+  };
+}
+function incidentFromRow(row) {
+  return {
+    id: row.id,
+    monitorId: row.monitor_id,
+    status: row.status,
+    openedAt: row.opened_at,
+    closedAt: row.closed_at,
+    lastFailureAt: row.last_failure_at,
+    failureCount: row.failure_count,
+    recoveryCheckId: row.recovery_check_id,
+    reason: row.reason
+  };
+}
+function newId(prefix) {
+  return `${prefix}_${randomUUID().replace(/-/g, "").slice(0, 18)}`;
+}
+function boundedInteger(value, label, min, max) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${label} must be an integer from ${min} to ${max}`);
+  }
+  return value;
+}
+function clampLimit(value) {
+  if (!Number.isFinite(value))
+    return 50;
+  return Math.max(1, Math.min(Math.floor(value), MAX_RESULT_LIMIT));
+}
+function round(value, places) {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+
+// src/service.ts
+class UptimeService {
+  store;
+  checkRunner;
+  inFlightChecks = new Set;
+  constructor(options = {}) {
+    this.store = options.store ?? new UptimeStore(options);
+    this.checkRunner = options.checkRunner ?? runMonitorCheck;
+  }
+  close() {
+    this.store.close();
+  }
+  createMonitor(input) {
+    return this.store.createMonitor(input);
+  }
+  updateMonitor(idOrName, input) {
+    return this.store.updateMonitor(idOrName, input);
+  }
+  deleteMonitor(idOrName) {
+    return this.store.deleteMonitor(idOrName);
+  }
+  listMonitors(options = {}) {
+    return this.store.listMonitors(options);
+  }
+  getMonitor(idOrName) {
+    return this.store.getMonitor(idOrName);
+  }
+  listResults(options = {}) {
+    return this.store.listResults(options);
+  }
+  listIncidents(options = {}) {
+    return this.store.listIncidents(options);
+  }
+  summary() {
+    return this.store.summary();
+  }
+  async checkMonitor(idOrName) {
+    const monitor = this.store.getMonitor(idOrName);
+    if (!monitor)
+      throw new Error(`Monitor not found: ${idOrName}`);
+    if (!monitor.enabled)
+      throw new Error(`Monitor is disabled: ${monitor.name}`);
+    if (this.inFlightChecks.has(monitor.id))
+      throw new Error(`Monitor check already in progress: ${monitor.name}`);
+    this.inFlightChecks.add(monitor.id);
+    try {
+      let attemptCount = 0;
+      let last = null;
+      const maxAttempts = Math.max(1, monitor.retryCount + 1);
+      while (attemptCount < maxAttempts) {
+        attemptCount += 1;
+        last = await this.checkRunner(monitor);
+        if (last.status === "up")
+          break;
+      }
+      return this.store.recordCheckResult({
+        monitorId: monitor.id,
+        status: last.status,
+        latencyMs: last.latencyMs,
+        statusCode: last.statusCode ?? null,
+        error: last.error ?? null,
+        attemptCount
+      });
+    } finally {
+      this.inFlightChecks.delete(monitor.id);
+    }
+  }
+  async checkAll() {
+    const monitors = this.store.listMonitors();
+    const results = [];
+    for (const monitor of monitors) {
+      results.push(await this.checkMonitor(monitor.id));
+    }
+    return results;
+  }
+  startScheduler(options = {}) {
+    const tickMs = options.tickMs ?? 1000;
+    const timer = setInterval(() => {
+      this.runDueChecks().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+      });
+    }, tickMs);
+    return {
+      stop: () => clearInterval(timer)
+    };
+  }
+  async runDueChecks(now = new Date) {
+    const due = this.store.listMonitors().filter((monitor) => this.isDue(monitor, now));
+    const results = [];
+    for (const monitor of due) {
+      const current = this.store.getMonitor(monitor.id);
+      if (!current || !this.isDue(current, now))
+        continue;
+      results.push(await this.checkMonitor(current.id));
+    }
+    return results;
+  }
+  isDue(monitor, now) {
+    if (!monitor.enabled)
+      return false;
+    if (this.inFlightChecks.has(monitor.id))
+      return false;
+    if (!monitor.lastCheckedAt)
+      return true;
+    const last = new Date(monitor.lastCheckedAt).getTime();
+    return now.getTime() - last >= monitor.intervalSeconds * 1000;
+  }
+}
+function createUptimeClient(options = {}) {
+  return new UptimeService(options);
+}
+
+// src/dashboard.ts
+function dashboardHtml() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Open Uptime</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #f7f8fb;
+      --panel: #ffffff;
+      --text: #17202a;
+      --muted: #5f6b7a;
+      --line: #d8dee8;
+      --up: #157347;
+      --down: #b42318;
+      --warn: #9a6700;
+      --accent: #2457c5;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      background: var(--bg);
+      color: var(--text);
+    }
+    header {
+      border-bottom: 1px solid var(--line);
+      background: var(--panel);
+      padding: 18px 24px;
+      display: flex;
+      justify-content: space-between;
+      gap: 16px;
+      align-items: center;
+    }
+    h1 { margin: 0; font-size: 20px; letter-spacing: 0; }
+    main { padding: 24px; max-width: 1180px; margin: 0 auto; }
+    .grid { display: grid; gap: 16px; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); }
+    .panel {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 16px;
+    }
+    .metric { font-size: 28px; font-weight: 700; margin-top: 6px; }
+    .muted { color: var(--muted); font-size: 13px; }
+    .toolbar { display: flex; gap: 8px; align-items: center; }
+    .stack { display: grid; gap: 16px; margin-top: 16px; }
+    .form-grid { display: grid; gap: 10px; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); align-items: end; }
+    label { display: grid; gap: 5px; color: var(--muted); font-size: 12px; font-weight: 700; text-transform: uppercase; }
+    input, select {
+      width: 100%;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 9px 10px;
+      background: white;
+      color: var(--text);
+      font: inherit;
+    }
+    button {
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      background: var(--panel);
+      color: var(--text);
+      padding: 8px 12px;
+      cursor: pointer;
+      font-weight: 600;
+    }
+    button.primary { background: var(--accent); color: white; border-color: var(--accent); }
+    button.danger { color: var(--down); }
+    table { width: 100%; border-collapse: collapse; margin-top: 16px; }
+    th, td { text-align: left; border-bottom: 1px solid var(--line); padding: 11px 8px; vertical-align: top; }
+    th { color: var(--muted); font-size: 12px; text-transform: uppercase; }
+    .badge { display: inline-flex; min-width: 72px; justify-content: center; border-radius: 999px; padding: 4px 8px; font-size: 12px; font-weight: 700; }
+    .up { background: #dcfce7; color: var(--up); }
+    .down { background: #fee2e2; color: var(--down); }
+    .paused { background: #fef3c7; color: var(--warn); }
+    .unknown { background: #e5e7eb; color: #374151; }
+    .row-actions { display: flex; gap: 6px; flex-wrap: wrap; }
+    @media (max-width: 760px) {
+      header { align-items: flex-start; flex-direction: column; }
+      main { padding: 16px; }
+      table { display: block; overflow-x: auto; white-space: nowrap; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div>
+      <h1>Open Uptime</h1>
+      <div class="muted">Local uptime and downtime monitoring</div>
+    </div>
+    <div class="toolbar">
+      <button id="check-all" class="primary">Run Checks</button>
+      <button id="refresh">Refresh</button>
+    </div>
+  </header>
+  <main>
+    <section class="grid" id="metrics"></section>
+    <section class="panel" style="margin-top:16px">
+      <strong>Add Monitor</strong>
+      <form id="monitor-form" class="form-grid">
+        <label>Name<input id="form-name" required /></label>
+        <label>Kind<select id="form-kind"><option value="http">HTTP</option><option value="tcp">TCP</option></select></label>
+        <label>URL<input id="form-url" placeholder="https://example.com/health" /></label>
+        <label>Host<input id="form-host" placeholder="127.0.0.1" /></label>
+        <label>Port<input id="form-port" type="number" min="1" max="65535" /></label>
+        <label>Interval<input id="form-interval" type="number" min="1" value="60" /></label>
+        <label>Timeout<input id="form-timeout" type="number" min="1" value="5000" /></label>
+        <button id="form-submit" class="primary" type="submit">Add</button>
+        <button id="form-cancel" type="button">Cancel</button>
+      </form>
+      <div class="muted" id="form-status"></div>
+    </section>
+    <section class="panel" style="margin-top:16px">
+      <div style="display:flex;justify-content:space-between;gap:12px;align-items:center">
+        <div>
+          <strong>Monitors</strong>
+          <div class="muted" id="generated"></div>
+        </div>
+      </div>
+      <table>
+        <thead>
+          <tr><th>Status</th><th>Name</th><th>Target</th><th>Uptime</th><th>Latency</th><th>Last Check</th><th>Incident</th><th></th></tr>
+        </thead>
+        <tbody id="monitors"></tbody>
+      </table>
+    </section>
+    <section class="stack">
+      <section class="panel">
+        <strong>Recent Results</strong>
+        <table>
+          <thead><tr><th>Status</th><th>Monitor</th><th>Checked</th><th>Latency</th><th>Error</th></tr></thead>
+          <tbody id="results"></tbody>
+        </table>
+      </section>
+      <section class="panel">
+        <strong>Incidents</strong>
+        <table>
+          <thead><tr><th>Status</th><th>Monitor</th><th>Opened</th><th>Closed</th><th>Failures</th><th>Reason</th></tr></thead>
+          <tbody id="incidents"></tbody>
+        </table>
+      </section>
+    </section>
+  </main>
+  <script>
+    let monitorCache = [];
+    let editingId = null;
+    const fmt = (value) => value == null || value === '' ? '-' : String(value);
+    const pct = (value) => value == null ? '-' : Number(value).toFixed(2) + '%';
+    const byId = (id) => document.getElementById(id);
+    const text = (value) => document.createTextNode(fmt(value));
+    function clear(node) { while (node.firstChild) node.removeChild(node.firstChild); }
+    function cell(value) {
+      const td = document.createElement('td');
+      td.appendChild(text(value));
+      return td;
+    }
+    function statusCell(status) {
+      const td = document.createElement('td');
+      const span = document.createElement('span');
+      const safe = ['up', 'down', 'paused', 'unknown'].includes(status) ? status : 'unknown';
+      span.className = 'badge ' + safe;
+      span.textContent = status || 'unknown';
+      td.appendChild(span);
+      return td;
+    }
+    function button(label, handler, className) {
+      const btn = document.createElement('button');
+      btn.type = 'button';
+      btn.textContent = label;
+      if (className) btn.className = className;
+      btn.addEventListener('click', handler);
+      return btn;
+    }
+    async function load() {
+      const [summary, results, incidents] = await Promise.all([
+        fetch('/api/summary').then((r) => r.json()),
+        fetch('/api/results?limit=20').then((r) => r.json()),
+        fetch('/api/incidents?limit=20').then((r) => r.json()),
+      ]);
+      monitorCache = summary.monitors.map((item) => item.monitor);
+      byId('generated').textContent = 'Generated ' + new Date(summary.generatedAt).toLocaleString();
+      renderMetrics(summary);
+      renderMonitors(summary);
+      renderResults(results);
+      renderIncidents(incidents);
+    }
+    function renderMetrics(summary) {
+      const root = byId('metrics');
+      clear(root);
+      for (const [label, value] of [
+        ['Monitors', summary.totals.monitors],
+        ['Up', summary.totals.up],
+        ['Down', summary.totals.down],
+        ['Open incidents', summary.totals.openIncidents],
+      ]) {
+        const panel = document.createElement('div');
+        panel.className = 'panel';
+        const small = document.createElement('div');
+        small.className = 'muted';
+        small.textContent = label;
+        const metric = document.createElement('div');
+        metric.className = 'metric';
+        metric.textContent = value;
+        panel.append(small, metric);
+        root.appendChild(panel);
+      }
+    }
+    function renderMonitors(summary) {
+      const root = byId('monitors');
+      clear(root);
+      for (const item of summary.monitors) {
+        const m = item.monitor;
+        const target = m.kind === 'http' ? m.url : m.host + ':' + m.port;
+        const incident = item.openIncident ? 'open since ' + new Date(item.openIncident.openedAt).toLocaleString() : '-';
+        const tr = document.createElement('tr');
+        const name = document.createElement('td');
+        const strong = document.createElement('strong');
+        strong.textContent = m.name;
+        const kind = document.createElement('div');
+        kind.className = 'muted';
+        kind.textContent = m.kind;
+        name.append(strong, kind);
+        const actions = document.createElement('td');
+        actions.className = 'row-actions';
+        actions.append(
+          button('Check', () => checkOne(m.id)),
+          button(m.enabled ? 'Pause' : 'Resume', () => setEnabled(m.id, !m.enabled)),
+          button('Edit', () => fillForm(m.id)),
+          button('Delete', () => deleteMonitor(m.id), 'danger'),
+        );
+        tr.append(
+          statusCell(m.status),
+          name,
+          cell(target),
+          cell(pct(item.uptimePercent)),
+          cell(item.averageLatencyMs == null ? '-' : item.averageLatencyMs + ' ms'),
+          cell(m.lastCheckedAt ? new Date(m.lastCheckedAt).toLocaleString() : '-'),
+          cell(incident),
+          actions,
+        );
+        root.appendChild(tr);
+      }
+    }
+    function renderResults(results) {
+      const root = byId('results');
+      clear(root);
+      for (const result of results) {
+        const tr = document.createElement('tr');
+        tr.append(
+          statusCell(result.status),
+          cell(result.monitorId),
+          cell(new Date(result.checkedAt).toLocaleString()),
+          cell(result.latencyMs == null ? '-' : result.latencyMs + ' ms'),
+          cell(result.error),
+        );
+        root.appendChild(tr);
+      }
+    }
+    function renderIncidents(incidents) {
+      const root = byId('incidents');
+      clear(root);
+      for (const incident of incidents) {
+        const tr = document.createElement('tr');
+        tr.append(
+          statusCell(incident.status),
+          cell(incident.monitorId),
+          cell(new Date(incident.openedAt).toLocaleString()),
+          cell(incident.closedAt ? new Date(incident.closedAt).toLocaleString() : '-'),
+          cell(incident.failureCount),
+          cell(incident.reason),
+        );
+        root.appendChild(tr);
+      }
+    }
+    async function checkOne(id) {
+      await fetch('/api/monitors/' + encodeURIComponent(id) + '/check', { method: 'POST' });
+      await load();
+    }
+    async function setEnabled(id, enabled) {
+      await fetch('/api/monitors/' + encodeURIComponent(id), {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ enabled }),
+      });
+      await load();
+    }
+    async function deleteMonitor(id) {
+      await fetch('/api/monitors/' + encodeURIComponent(id), { method: 'DELETE' });
+      await load();
+    }
+    function fillForm(id) {
+      const m = monitorCache.find((item) => item.id === id);
+      if (!m) return;
+      editingId = m.id;
+      byId('form-name').value = m.name;
+      byId('form-kind').value = m.kind;
+      byId('form-url').value = m.url || '';
+      byId('form-host').value = m.host || '';
+      byId('form-port').value = m.port || '';
+      byId('form-interval').value = m.intervalSeconds;
+      byId('form-timeout').value = m.timeoutMs;
+      byId('form-submit').textContent = 'Save';
+      byId('form-status').textContent = ['Editing', m.name].join(' ');
+    }
+    function resetForm() {
+      editingId = null;
+      byId('monitor-form').reset();
+      byId('form-submit').textContent = 'Add';
+      byId('form-status').textContent = '';
+    }
+    byId('monitor-form').addEventListener('submit', async (event) => {
+      event.preventDefault();
+      const kind = byId('form-kind').value;
+      const body = {
+        name: byId('form-name').value,
+        kind,
+        intervalSeconds: Number(byId('form-interval').value || 60),
+        timeoutMs: Number(byId('form-timeout').value || 5000),
+      };
+      if (kind === 'http') body.url = byId('form-url').value;
+      else {
+        body.host = byId('form-host').value;
+        body.port = Number(byId('form-port').value);
+      }
+      const response = await fetch(editingId ? '/api/monitors/' + encodeURIComponent(editingId) : '/api/monitors', {
+        method: editingId ? 'PATCH' : 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const payload = await response.json();
+      byId('form-status').textContent = response.ok ? [editingId ? 'Saved' : 'Added', payload.name].join(' ') : payload.error;
+      if (response.ok) resetForm();
+      await load();
+    });
+    byId('form-cancel').addEventListener('click', resetForm);
+    byId('refresh').addEventListener('click', load);
+    byId('check-all').addEventListener('click', async () => {
+      await fetch('/api/check-all', { method: 'POST' });
+      await load();
+    });
+    load();
+  </script>
+</body>
+</html>`;
+}
+
+// src/api.ts
+function createApiHandler(service) {
+  return async (request) => {
+    const url = new URL(request.url);
+    try {
+      validateLocalMutationRequest(request, url);
+      if (request.method === "GET" && url.pathname === "/") {
+        return html(dashboardHtml());
+      }
+      if (request.method === "GET" && url.pathname === "/health") {
+        return json({ ok: true, service: "uptime" });
+      }
+      if (request.method === "GET" && url.pathname === "/api/summary") {
+        return json(service.summary());
+      }
+      if (request.method === "GET" && url.pathname === "/api/monitors") {
+        return json(service.listMonitors({ includeDisabled: url.searchParams.get("includeDisabled") === "true" }));
+      }
+      if (request.method === "POST" && url.pathname === "/api/monitors") {
+        return json(service.createMonitor(await jsonBody(request)), 201);
+      }
+      if (request.method === "GET" && url.pathname === "/api/incidents") {
+        const status = url.searchParams.get("status");
+        return json(service.listIncidents({
+          status: status === "open" || status === "closed" ? status : undefined,
+          monitorId: url.searchParams.get("monitorId") ?? undefined,
+          limit: numericParam(url, "limit", 50)
+        }));
+      }
+      if (request.method === "GET" && url.pathname === "/api/results") {
+        return json(service.listResults({
+          monitorId: url.searchParams.get("monitorId") ?? undefined,
+          limit: numericParam(url, "limit", 50)
+        }));
+      }
+      if (request.method === "POST" && url.pathname === "/api/check-all") {
+        return json(await service.checkAll());
+      }
+      const monitorMatch = url.pathname.match(/^\/api\/monitors\/([^/]+)(?:\/(check))?$/);
+      if (monitorMatch) {
+        const id = decodeURIComponent(monitorMatch[1]);
+        if (request.method === "GET" && !monitorMatch[2]) {
+          const monitor = service.getMonitor(id);
+          return monitor ? json(monitor) : json({ error: "not found" }, 404);
+        }
+        if (request.method === "PATCH" && !monitorMatch[2]) {
+          return json(service.updateMonitor(id, await jsonBody(request)));
+        }
+        if (request.method === "DELETE" && !monitorMatch[2]) {
+          return json({ deleted: service.deleteMonitor(id) });
+        }
+        if (request.method === "POST" && monitorMatch[2] === "check") {
+          return json(await service.checkMonitor(id));
+        }
+      }
+      return json({ error: "not found" }, 404);
+    } catch (error) {
+      return json({ error: error instanceof Error ? error.message : String(error) }, error instanceof ApiError ? error.status : 400);
+    }
+  };
+}
+function serveUptime(options = {}) {
+  const service = options.service ?? new UptimeService(options);
+  const scheduler = options.check ? service.startScheduler() : undefined;
+  const server = Bun.serve({
+    hostname: options.host ?? "127.0.0.1",
+    port: options.port ?? 3899,
+    fetch: createApiHandler(service)
+  });
+  return { server, service, scheduler };
+}
+function json(value, status = 200) {
+  return new Response(JSON.stringify(value, null, 2), {
+    status,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      "cache-control": "no-store"
+    }
+  });
+}
+function html(value) {
+  return new Response(value, {
+    headers: {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store"
+    }
+  });
+}
+function numericParam(url, name, fallback) {
+  const raw = url.searchParams.get(name);
+  if (!raw)
+    return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function validateLocalMutationRequest(request, url) {
+  if (!["POST", "PATCH", "DELETE"].includes(request.method))
+    return;
+  const origin = request.headers.get("origin");
+  if (origin && origin !== `${url.protocol}//${url.host}`) {
+    throw new ApiError("cross-origin mutation rejected", 403);
+  }
+}
+async function jsonBody(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  const mediaType = contentType.split(";")[0]?.trim().toLowerCase();
+  if (mediaType !== "application/json" && !mediaType.endsWith("+json")) {
+    throw new ApiError("content-type must be application/json", 415);
+  }
+  return request.json();
+}
+
+class ApiError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+export {
+  uptimeHome,
+  uptimeDbPath,
+  serveUptime,
+  runTcpCheck,
+  runMonitorCheck,
+  runHttpCheck,
+  ensureUptimeHome,
+  createUptimeClient,
+  createApiHandler,
+  UptimeStore,
+  UptimeService
+};