@hasna/uptime 0.1.0

package/dist/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function uptimeHome(): string;
+export declare function uptimeDbPath(): string;
+export declare function ensureUptimeHome(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAIA,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAIzC"}

package/dist/paths.js

@@ -0,0 +1,21 @@
+// @bun
+// 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;
+}
+export {
+  uptimeHome,
+  uptimeDbPath,
+  ensureUptimeHome
+};

package/dist/service.d.ts

@@ -0,0 +1,36 @@
+import { UptimeStore, type UptimeStoreOptions } from "./store.js";
+import type { CheckAttemptResult, CheckResult, CreateMonitorInput, Incident, ListResultsOptions, Monitor, SchedulerHandle, UpdateMonitorInput, UptimeSummary } from "./types.js";
+export interface UptimeServiceOptions extends UptimeStoreOptions {
+    store?: UptimeStore;
+    checkRunner?: (monitor: Monitor) => Promise<CheckAttemptResult>;
+}
+export declare class UptimeService {
+    readonly store: UptimeStore;
+    private readonly checkRunner;
+    private readonly inFlightChecks;
+    constructor(options?: UptimeServiceOptions);
+    close(): void;
+    createMonitor(input: CreateMonitorInput): Monitor;
+    updateMonitor(idOrName: string, input: UpdateMonitorInput): Monitor;
+    deleteMonitor(idOrName: string): boolean;
+    listMonitors(options?: {
+        includeDisabled?: boolean;
+    }): Monitor[];
+    getMonitor(idOrName: string): Monitor | null;
+    listResults(options?: ListResultsOptions): CheckResult[];
+    listIncidents(options?: {
+        status?: "open" | "closed";
+        monitorId?: string;
+        limit?: number;
+    }): Incident[];
+    summary(): UptimeSummary;
+    checkMonitor(idOrName: string): Promise<CheckResult>;
+    checkAll(): Promise<CheckResult[]>;
+    startScheduler(options?: {
+        tickMs?: number;
+    }): SchedulerHandle;
+    runDueChecks(now?: Date): Promise<CheckResult[]>;
+    private isDue;
+}
+export declare function createUptimeClient(options?: UptimeServiceOptions): UptimeService;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,kBAAkB,EAClB,OAAO,EACP,eAAe,EACf,kBAAkB,EAClB,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACjE;AAED,qBAAa,aAAa;IACxB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoD;IAChF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;gBAExC,OAAO,GAAE,oBAAyB;IAK9C,KAAK,IAAI,IAAI;IAIb,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAIjD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAInE,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC,YAAY,CAAC,OAAO,GAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,EAAE;IAIpE,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAI5C,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,WAAW,EAAE;IAI5D,aAAa,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,QAAQ,EAAE;IAI3G,OAAO,IAAI,aAAa;IAIlB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IA4BpD,QAAQ,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IASxC,cAAc,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,eAAe;IAY5D,YAAY,CAAC,GAAG,GAAE,IAAiB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAWlE,OAAO,CAAC,KAAK;CAOd;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,oBAAyB,GAAG,aAAa,CAEpF"}

package/dist/service.js

@@ -0,0 +1,611 @@
+// @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);
+}
+export {
+  createUptimeClient,
+  UptimeService
+};