@hasna/uptime 0.1.0

package/dist/store.d.ts

@@ -0,0 +1,32 @@
+import type { CheckResult, CreateMonitorInput, Incident, ListResultsOptions, Monitor, UpdateMonitorInput, UptimeSummary } from "./types.js";
+export interface UptimeStoreOptions {
+    dbPath?: string;
+}
+export declare class UptimeStore {
+    readonly dbPath: string;
+    private readonly db;
+    constructor(options?: UptimeStoreOptions);
+    close(): void;
+    migrate(): void;
+    createMonitor(input: CreateMonitorInput): Monitor;
+    listMonitors(options?: {
+        includeDisabled?: boolean;
+    }): Monitor[];
+    getMonitor(idOrName: string): Monitor | null;
+    updateMonitor(idOrName: string, input: UpdateMonitorInput): Monitor;
+    deleteMonitor(idOrName: string): boolean;
+    recordCheckResult(input: Omit<CheckResult, "id" | "checkedAt"> & {
+        checkedAt?: string;
+    }): CheckResult;
+    listResults(options?: ListResultsOptions): CheckResult[];
+    listIncidents(options?: {
+        status?: "open" | "closed";
+        monitorId?: string;
+        limit?: number;
+    }): Incident[];
+    getOpenIncident(monitorId: string): Incident | null;
+    summary(): UptimeSummary;
+    private monitorSummary;
+    private reconcileIncidentInTransaction;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,kBAAkB,EAClB,OAAO,EAGP,kBAAkB,EAClB,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA0DD,qBAAa,WAAW;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAElB,OAAO,GAAE,kBAAuB;IAW5C,KAAK,IAAI,IAAI;IAIb,OAAO,IAAI,IAAI;IAkDf,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAkDjD,YAAY,CAAC,OAAO,GAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,EAAE;IAOpE,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAO5C,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO;IAiCnE,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAOxC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW;IAwCrG,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,WAAW,EAAE;IAU5D,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;IAmB3G,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAOnD,OAAO,IAAI,aAAa;IAkBxB,OAAO,CAAC,cAAc;IAyBtB,OAAO,CAAC,8BAA8B;CA2BvC"}

package/dist/store.js

@@ -0,0 +1,431 @@
+// @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;
+}
+
+// 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;
+}
+export {
+  UptimeStore
+};

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+export type MonitorKind = "http" | "tcp";
+export type MonitorStatus = "unknown" | "up" | "down" | "paused";
+export type CheckStatus = "up" | "down";
+export type IncidentStatus = "open" | "closed";
+export interface Monitor {
+    id: string;
+    name: string;
+    kind: MonitorKind;
+    url: string | null;
+    host: string | null;
+    port: number | null;
+    method: string;
+    expectedStatus: number | null;
+    intervalSeconds: number;
+    timeoutMs: number;
+    retryCount: number;
+    enabled: boolean;
+    status: MonitorStatus;
+    lastCheckedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateMonitorInput {
+    name: string;
+    kind: MonitorKind;
+    url?: string;
+    host?: string;
+    port?: number;
+    method?: string;
+    expectedStatus?: number | null;
+    intervalSeconds?: number;
+    timeoutMs?: number;
+    retryCount?: number;
+    enabled?: boolean;
+}
+export type UpdateMonitorInput = Partial<Omit<CreateMonitorInput, "kind">> & {
+    kind?: MonitorKind;
+};
+export interface CheckResult {
+    id: string;
+    monitorId: string;
+    checkedAt: string;
+    status: CheckStatus;
+    latencyMs: number | null;
+    statusCode: number | null;
+    error: string | null;
+    attemptCount: number;
+}
+export interface CheckAttemptResult {
+    status: CheckStatus;
+    latencyMs: number | null;
+    statusCode?: number | null;
+    error?: string | null;
+}
+export interface Incident {
+    id: string;
+    monitorId: string;
+    status: IncidentStatus;
+    openedAt: string;
+    closedAt: string | null;
+    lastFailureAt: string;
+    failureCount: number;
+    recoveryCheckId: string | null;
+    reason: string | null;
+}
+export interface MonitorSummary {
+    monitor: Monitor;
+    totalChecks: number;
+    upChecks: number;
+    downChecks: number;
+    uptimePercent: number | null;
+    averageLatencyMs: number | null;
+    openIncident: Incident | null;
+}
+export interface UptimeSummary {
+    generatedAt: string;
+    monitors: MonitorSummary[];
+    totals: {
+        monitors: number;
+        enabled: number;
+        up: number;
+        down: number;
+        paused: number;
+        unknown: number;
+        openIncidents: number;
+    };
+}
+export interface ListResultsOptions {
+    monitorId?: string;
+    limit?: number;
+}
+export interface SchedulerHandle {
+    stop: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,KAAK,CAAC;AACzC,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAC;AACjE,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,MAAM,CAAC;AACxC,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/C,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,GAAG;IAC3E,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,YAAY,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB"}

package/dist/types.js

@@ -0,0 +1 @@
+// @bun

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function packageVersion(): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAIA,wBAAgB,cAAc,IAAI,MAAM,CAcvC"}

package/dist/version.js

@@ -0,0 +1,21 @@
+// @bun
+// src/version.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function packageVersion() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, "..", "package.json"),
+    join(here, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(readFileSync(candidate, "utf8")).version ?? "0.0.0";
+    } catch {}
+  }
+  return "0.0.0";
+}
+export {
+  packageVersion
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@hasna/uptime",
+  "version": "0.1.0",
+  "description": "Local-first uptime and downtime monitoring service with CLI, MCP, SDK, SQLite persistence, and a dashboard.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "homepage": "https://github.com/hasna/uptime#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/uptime.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hasna/uptime/issues"
+  },
+  "keywords": [
+    "uptime",
+    "monitoring",
+    "pingdom",
+    "mcp",
+    "hasna"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES.md",
+    "SECURITY.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md"
+  ],
+  "bin": {
+    "uptime": "dist/cli/index.js",
+    "uptime-mcp": "dist/mcp/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./sdk": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api.d.ts",
+      "import": "./dist/api.js"
+    },
+    "./storage": {
+      "types": "./dist/store.d.ts",
+      "import": "./dist/store.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/cli/index.ts --outdir dist/cli --target bun --external @modelcontextprotocol/sdk && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk && bun build src/index.ts src/api.ts src/service.ts src/store.ts src/checks.ts src/types.ts src/paths.ts src/dashboard.ts src/version.ts --root src --outdir dist --target bun && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist && chmod +x dist/cli/index.js dist/mcp/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test ./tests",
+    "dev:cli": "bun run src/cli/index.ts",
+    "dev:mcp": "bun run src/mcp/index.ts",
+    "dev:server": "bun run src/cli/index.ts serve",
+    "prepublishOnly": "bun run build && bun run typecheck && bun test",
+    "postinstall": "mkdir -p $HOME/.hasna/uptime 2>/dev/null || true"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "chalk": "^5.6.2",
+    "commander": "^13.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.9.3"
+  }
+}