happyuptime 1.0.0

package/README.md

@@ -0,0 +1,263 @@
+# happyuptime
+
+The official CLI for [Happy Uptime](https://happyuptime.com) — monitor uptime, manage incidents, and check site speed from your terminal.
+
+## Install
+
+```bash
+npm install -g happyuptime
+```
+
+Or use without installing:
+
+```bash
+npx happyuptime status
+```
+
+## Quick Start
+
+```bash
+# 1. Authenticate with your API key
+happy login --api-key hu_your_key_here
+
+# 2. Check your monitors
+happy status
+
+# 3. Speed test any URL
+happy speed-test https://example.com
+```
+
+Get an API key from your [Happy Uptime dashboard](https://happyuptime.com/dashboard/settings) under Settings > API Keys.
+
+## Commands
+
+### Authentication
+
+```bash
+happy login --api-key hu_xxx   # Save API key
+happy whoami                   # Show current auth status
+happy logout                   # Remove saved credentials
+```
+
+You can also set the `HAPPYUPTIME_API_KEY` environment variable instead of using `happy login`.
+
+### Status Overview
+
+```bash
+happy status          # Quick overview of all monitors
+happy status --json   # JSON output for scripting
+```
+
+Example output:
+
+```
+  ● All systems operational
+
+  Monitors
+  ● Production API
+  ● Marketing Site
+  ▲ Staging API degraded
+  ○ Dev Server (paused)
+
+  10 monitors | 8 up | 0 down | 1 degraded
+```
+
+### Monitors
+
+```bash
+happy monitors list                           # List all monitors
+happy monitors list --status down             # Filter by status
+happy monitors list --type http               # Filter by type
+happy monitors get <id>                       # Show monitor details
+
+happy monitors create \
+  --name "Production API" \
+  --url https://api.example.com/health \
+  --type http \
+  --interval 60 \
+  --regions us-east,eu-west                   # Create a monitor
+
+happy monitors pause <id>                     # Pause monitoring
+happy monitors resume <id>                    # Resume monitoring
+happy monitors delete <id>                    # Delete (with confirmation)
+happy monitors check https://example.com      # Quick-check a URL
+```
+
+### Incidents
+
+```bash
+happy incidents list                          # List incidents
+happy incidents list --status investigating   # Filter by status
+happy incidents get <id>                      # Show incident detail + timeline
+
+happy incidents create "API is slow" \
+  --severity major \
+  --message "Investigating elevated latency"  # Create incident
+
+happy incidents update <id> \
+  --status identified \
+  --message "Found root cause: database"      # Add status update
+
+happy incidents resolve <id> \
+  --message "Fix deployed, monitoring"        # Resolve incident
+```
+
+### Alerts
+
+```bash
+happy alerts list                             # List alert channels
+
+happy alerts create \
+  --name "Slack Engineering" \
+  --type slack \
+  --webhook-url https://hooks.slack.com/...   # Create channel
+
+happy alerts delete <id>                      # Delete channel
+```
+
+### Speed Test
+
+Test any URL from 6 global regions with timing waterfall:
+
+```bash
+happy speed-test https://example.com
+```
+
+Output includes a waterfall visualization:
+
+```
+  Speed Test: https://example.com
+  Avg: 245ms  Min: 180ms  Max: 420ms
+
+  ┌──────────┬────────┬──────┬───────┬─────┬─────────┬─────┬──────┐
+  │ Region   │ Status │ Code │ Total │ DNS │ Connect │ TLS │ TTFB │
+  ├──────────┼────────┼──────┼───────┼─────┼─────────┼─────┼──────┤
+  │ us-east  │ up     │ 200  │ 180ms │ 12ms│ 25ms    │ 35ms│ 108ms│
+  │ eu-west  │ up     │ 200  │ 245ms │ 15ms│ 45ms    │ 52ms│ 133ms│
+  └──────────┴────────┴──────┴───────┴─────┴─────────┴─────┴──────┘
+
+  Waterfall
+  us-east         ██████████████████████ 180ms
+  eu-west         ████████████████████████████ 245ms
+
+  ■ DNS  ■ Connect  ■ TLS  ■ TTFB  ■ Transfer
+```
+
+No authentication required for speed tests.
+
+### Config-as-Code
+
+Manage monitors declaratively with `happyuptime.yml`:
+
+```bash
+happy config pull                # Export current monitors to YAML
+happy config push                # Sync YAML to Happy Uptime
+happy config push --dry-run      # Preview changes without applying
+happy config validate            # Validate YAML syntax
+```
+
+Example `happyuptime.yml`:
+
+```yaml
+monitors:
+  - name: Production API
+    url: https://api.example.com/health
+    type: http
+    interval: 60
+    regions:
+      - us-east
+      - eu-west
+      - ap-southeast
+    tags:
+      - production
+      - critical
+
+  - name: Marketing Site
+    url: https://example.com
+    type: http
+    interval: 300
+    regions:
+      - us-east
+      - eu-west
+
+  - name: Database Backup
+    type: heartbeat
+    interval: 3600
+```
+
+Environment variable substitution is supported:
+
+```yaml
+monitors:
+  - name: API
+    url: ${API_URL}/health
+    headers:
+      Authorization: Bearer ${API_TOKEN}
+```
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `HAPPYUPTIME_API_KEY` | API key (alternative to `happy login`) |
+| `HAPPYUPTIME_API_URL` | Custom API base URL (default: `https://happyuptime.com`) |
+
+## JSON Output
+
+All commands support `--json` for machine-readable output:
+
+```bash
+happy status --json | jq '.monitors | length'
+happy monitors list --json | jq '.data[] | select(.status == "down")'
+```
+
+## CI/CD Usage
+
+Use in GitHub Actions or other CI pipelines:
+
+```yaml
+# .github/workflows/deploy.yml
+- name: Check monitors after deploy
+  run: |
+    npx happyuptime status --json
+  env:
+    HAPPYUPTIME_API_KEY: ${{ secrets.HAPPYUPTIME_API_KEY }}
+```
+
+```yaml
+# Create incident on deploy failure
+- name: Report deploy failure
+  if: failure()
+  run: |
+    npx happyuptime incidents create "Deploy failed" \
+      --severity major \
+      --message "Deploy to production failed in CI"
+  env:
+    HAPPYUPTIME_API_KEY: ${{ secrets.HAPPYUPTIME_API_KEY }}
+```
+
+## Config File
+
+Credentials are stored in `~/.happyuptime/config.json`:
+
+```json
+{
+  "apiKey": "hu_xxx",
+  "apiUrl": "https://happyuptime.com"
+}
+```
+
+## Requirements
+
+- Node.js 18+
+
+## Links
+
+- [Happy Uptime](https://happyuptime.com)
+- [API Documentation](https://happyuptime.com/docs)
+- [Dashboard](https://happyuptime.com/dashboard)
+- [GitHub](https://github.com/seangeng/happyuptime)
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,956 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk6 from 'chalk';
+import { writeFileSync, existsSync, readFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import Table from 'cli-table3';
+
+// src/lib/constants.ts
+var CONFIG_DIR = ".happyuptime";
+var CONFIG_FILE = "config.json";
+var VERSION = "1.0.0";
+function configPath() {
+  return join(homedir(), CONFIG_DIR, CONFIG_FILE);
+}
+function configDir() {
+  return join(homedir(), CONFIG_DIR);
+}
+function loadConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const dir = configDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(config, null, 2) + "\n");
+}
+function getApiKey() {
+  const envKey = process.env.HAPPYUPTIME_API_KEY;
+  if (envKey) return envKey;
+  const config = loadConfig();
+  if (config.apiKey) return config.apiKey;
+  console.error(
+    "No API key found. Run `happy login --api-key hu_xxx` or set HAPPYUPTIME_API_KEY."
+  );
+  process.exit(1);
+}
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl || process.env.HAPPYUPTIME_API_URL || "https://happyuptime.com";
+}
+
+// src/lib/api.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiError";
+  }
+};
+async function api(path, opts = {}) {
+  const baseUrl = getApiUrl();
+  const url = new URL(path, baseUrl);
+  if (opts.params) {
+    for (const [key, val] of Object.entries(opts.params)) {
+      if (val !== void 0) url.searchParams.set(key, String(val));
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "happyuptime-cli/1.0.0"
+  };
+  if (!opts.noAuth) {
+    headers["Authorization"] = `Bearer ${getApiKey()}`;
+  }
+  const res = await fetch(url.toString(), {
+    method: opts.method || "GET",
+    headers,
+    body: opts.body ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) {
+    let errBody = {};
+    try {
+      errBody = await res.json();
+    } catch {
+    }
+    throw new ApiError(
+      res.status,
+      errBody.error?.code || "unknown",
+      errBody.error?.message || `HTTP ${res.status}`
+    );
+  }
+  return res.json();
+}
+function table(headers, rows, opts) {
+  const t = new Table({
+    head: headers.map((h) => chalk6.bold.cyan(h)),
+    style: { head: [], border: ["gray"] },
+    ...{}
+  });
+  for (const row of rows) {
+    t.push(row.map(String));
+  }
+  console.log(t.toString());
+}
+function statusColor(status) {
+  switch (status.toLowerCase()) {
+    case "up":
+    case "operational":
+    case "resolved":
+      return chalk6.green(status);
+    case "degraded":
+    case "monitoring":
+    case "identified":
+    case "minor":
+      return chalk6.yellow(status);
+    case "down":
+    case "investigating":
+    case "major":
+    case "critical":
+      return chalk6.red(status);
+    case "paused":
+      return chalk6.gray(status);
+    default:
+      return status;
+  }
+}
+function kv(label, value) {
+  console.log(`  ${chalk6.gray(label + ":")} ${value ?? chalk6.dim("\u2014")}`);
+}
+function heading(text) {
+  console.log(chalk6.bold("\n" + text));
+}
+function success(text) {
+  console.log(chalk6.green("\u2713") + " " + text);
+}
+function warn(text) {
+  console.log(chalk6.yellow("!") + " " + text);
+}
+function error(text) {
+  console.error(chalk6.red("\u2717") + " " + text);
+}
+function formatMs(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function formatUptime(pct) {
+  const s = pct.toFixed(2) + "%";
+  if (pct >= 99.9) return chalk6.green(s);
+  if (pct >= 99) return chalk6.yellow(s);
+  return chalk6.red(s);
+}
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with Happy Uptime").option("--api-key <key>", "API key (starts with hu_)").option("--api-url <url>", "Custom API URL (default: https://happyuptime.com)").action(async (opts) => {
+  if (!opts.apiKey) {
+    error("Please provide an API key: happy login --api-key hu_xxx");
+    console.log(
+      chalk6.dim("\nCreate one at https://happyuptime.com/dashboard/settings")
+    );
+    process.exit(1);
+  }
+  if (!opts.apiKey.startsWith("hu_")) {
+    error("Invalid API key format. Keys start with hu_");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  config.apiKey = opts.apiKey;
+  if (opts.apiUrl) config.apiUrl = opts.apiUrl;
+  saveConfig(config);
+  try {
+    const res = await api(
+      "/api/v1/analytics/summary"
+    );
+    success(
+      `Authenticated! ${res.data.monitors.total} monitors found.`
+    );
+  } catch (e) {
+    const apiErr = e;
+    if (apiErr.status === 401) {
+      warn("Key saved but could not verify \u2014 check that it's valid.");
+    } else {
+      success("API key saved.");
+      warn("Could not reach API to verify.");
+    }
+  }
+  console.log(chalk6.dim(`Config saved to ~/.happyuptime/config.json`));
+});
+var whoamiCommand = new Command("whoami").description("Show current auth status").action(async () => {
+  try {
+    const key = getApiKey();
+    const url = getApiUrl();
+    const masked = key.slice(0, 7) + "..." + key.slice(-4);
+    heading("Happy Uptime CLI");
+    kv("API Key", masked);
+    kv("API URL", url);
+    const res = await api(
+      "/api/v1/analytics/summary"
+    );
+    kv("Monitors", `${res.data.monitors.total} total`);
+    console.log();
+  } catch {
+    error("Could not fetch account info. Check your API key.");
+    process.exit(1);
+  }
+});
+var logoutCommand = new Command("logout").description("Remove saved credentials").action(() => {
+  saveConfig({});
+  success("Logged out. API key removed from ~/.happyuptime/config.json");
+});
+var monitorsCommand = new Command("monitors").description("Manage monitors").addCommand(listMonitors()).addCommand(getMonitor()).addCommand(createMonitor()).addCommand(deleteMonitor()).addCommand(pauseMonitor()).addCommand(resumeMonitor()).addCommand(checkMonitor());
+function listMonitors() {
+  return new Command("list").alias("ls").description("List all monitors").option("-s, --status <status>", "Filter by status (up, down, degraded)").option("-t, --type <type>", "Filter by type (http, ping, tcp, dns, keyword, heartbeat)").option("--tag <tag>", "Filter by tag").option("-p, --page <n>", "Page number", "1").option("--per-page <n>", "Results per page", "25").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const res = await api(
+        "/api/v1/monitors",
+        { params: { status: opts.status, type: opts.type, tag: opts.tag, page: opts.page, per_page: opts.perPage } }
+      );
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      if (res.data.length === 0) {
+        warn("No monitors found.");
+        return;
+      }
+      heading(`Monitors (${res.pagination.total} total)`);
+      table(
+        ["ID", "Name", "Type", "Status", "Interval", "URL"],
+        res.data.map((m) => [
+          chalk6.dim(m.id.slice(0, 8)),
+          m.name,
+          m.type,
+          m.paused ? statusColor("paused") : statusColor(m.status),
+          `${m.interval_seconds}s`,
+          m.url?.length > 40 ? m.url.slice(0, 37) + "..." : m.url || "\u2014"
+        ])
+      );
+      if (res.pagination.total_pages > 1) {
+        console.log(
+          chalk6.dim(`  Page ${res.pagination.page}/${res.pagination.total_pages}`)
+        );
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function getMonitor() {
+  return new Command("get").description("Show monitor details").argument("<id>", "Monitor ID").option("--json", "Output raw JSON").action(async (id, opts) => {
+    try {
+      const res = await api(
+        `/api/v1/monitors/${id}`
+      );
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      const m = res.data;
+      heading(m.name);
+      kv("ID", m.id);
+      kv("Type", m.type);
+      kv("URL", m.url);
+      kv("Status", statusColor(m.paused ? "paused" : m.status));
+      kv("Interval", `${m.interval_seconds}s`);
+      kv("Regions", m.regions?.join(", ") || "\u2014");
+      if (m.uptime_30d !== void 0) {
+        kv("Uptime (30d)", formatUptime(m.uptime_30d));
+      }
+      kv("Created", timeAgo(m.created_at));
+      console.log();
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function createMonitor() {
+  return new Command("create").description("Create a new monitor").requiredOption("-n, --name <name>", "Monitor name").requiredOption("-u, --url <url>", "URL to monitor").option("-t, --type <type>", "Monitor type", "http").option("-m, --method <method>", "HTTP method", "GET").option("-i, --interval <seconds>", "Check interval in seconds", "60").option("--timeout <ms>", "Timeout in milliseconds", "30000").option("-r, --regions <regions>", "Comma-separated regions", "us-east,eu-west").option("--tag <tags>", "Comma-separated tags").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const body = {
+        name: opts.name,
+        url: opts.url,
+        type: opts.type,
+        method: opts.method,
+        interval_seconds: parseInt(opts.interval),
+        timeout_ms: parseInt(opts.timeout),
+        regions: opts.regions.split(",").map((r) => r.trim())
+      };
+      if (opts.tag) body.tags = opts.tag.split(",").map((t) => t.trim());
+      const res = await api("/api/v1/monitors", {
+        method: "POST",
+        body
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      success(`Monitor "${res.data.name}" created (${res.data.id})`);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function deleteMonitor() {
+  return new Command("delete").alias("rm").description("Delete a monitor").argument("<id>", "Monitor ID").option("-y, --yes", "Skip confirmation").action(async (id, opts) => {
+    if (!opts.yes) {
+      const { default: inquirer } = await import('inquirer');
+      const { confirm } = await inquirer.prompt([
+        { type: "confirm", name: "confirm", message: `Delete monitor ${id}?`, default: false }
+      ]);
+      if (!confirm) return;
+    }
+    try {
+      await api(`/api/v1/monitors/${id}`, { method: "DELETE" });
+      success(`Monitor ${id} deleted.`);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function pauseMonitor() {
+  return new Command("pause").description("Pause a monitor").argument("<id>", "Monitor ID").action(async (id) => {
+    try {
+      await api(`/api/v1/monitors/${id}`, {
+        method: "PUT",
+        body: { paused: true }
+      });
+      success(`Monitor ${id} paused.`);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function resumeMonitor() {
+  return new Command("resume").description("Resume a paused monitor").argument("<id>", "Monitor ID").action(async (id) => {
+    try {
+      await api(`/api/v1/monitors/${id}`, {
+        method: "PUT",
+        body: { paused: false }
+      });
+      success(`Monitor ${id} resumed.`);
+    } catch (e) {
+      handleError(e);
+    }
+  });
+}
+function checkMonitor() {
+  return new Command("check").description("Quick-check a URL from multiple regions").argument("<url>", "URL to check").option("--json", "Output raw JSON").action(async (url, opts) => {
+    const ora = (await import('ora')).default;
+    const spinner = ora(`Testing ${url}...`).start();
+    try {
+      const res = await api("/api/speed-test/run", {
+        method: "POST",
+        body: { url },
+        noAuth: true
+      });
+      spinner.stop();
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      heading(`Results for ${url}`);
+      table(
+        ["Region", "Status", "Code", "Total", "DNS", "Connect", "TLS", "TTFB"],
+        res.results.map((r) => [
+          r.region,
+          statusColor(r.status),
+          r.statusCode || "\u2014",
+          formatMs(r.responseTimeMs),
+          formatMs(r.timingDnsMs),
+          formatMs(r.timingConnectMs),
+          formatMs(r.timingTlsMs),
+          formatMs(r.timingTtfbMs)
+        ])
+      );
+      if (res.id) {
+        console.log(
+          chalk6.dim(`
+  Share: https://happyuptime.com/speed-test?id=${res.id}`)
+        );
+      }
+    } catch (e) {
+      spinner.stop();
+      handleError(e);
+    }
+  });
+}
+function handleError(e) {
+  if (e instanceof ApiError) {
+    error(`${e.message} (${e.status})`);
+  } else if (e instanceof Error) {
+    error(e.message);
+  }
+  process.exit(1);
+}
+var statusCommand = new Command("status").description("Quick overview of all monitors").option("--json", "Output raw JSON").action(async (opts) => {
+  try {
+    const [summary, monitors] = await Promise.all([
+      api("/api/v1/analytics/summary"),
+      api("/api/v1/monitors", {
+        params: { per_page: 100 }
+      })
+    ]);
+    if (opts.json) {
+      console.log(JSON.stringify({ summary: summary.data, monitors: monitors.data }, null, 2));
+      return;
+    }
+    const s = summary.data;
+    const allUp = s.monitors.down === 0 && s.monitors.degraded === 0;
+    console.log();
+    if (allUp) {
+      console.log(chalk6.green.bold("  \u25CF All systems operational"));
+    } else {
+      if (s.monitors.down > 0) {
+        console.log(chalk6.red.bold(`  \u25CF ${s.monitors.down} monitor${s.monitors.down > 1 ? "s" : ""} down`));
+      }
+      if (s.monitors.degraded > 0) {
+        console.log(chalk6.yellow.bold(`  \u25B2 ${s.monitors.degraded} monitor${s.monitors.degraded > 1 ? "s" : ""} degraded`));
+      }
+    }
+    if (s.active_incidents > 0) {
+      console.log(chalk6.red(`  ! ${s.active_incidents} active incident${s.active_incidents > 1 ? "s" : ""}`));
+    }
+    heading("Monitors");
+    const sorted = [...monitors.data].sort((a, b) => {
+      const order = { down: 0, degraded: 1, up: 2 };
+      return (order[a.status] ?? 3) - (order[b.status] ?? 3);
+    });
+    for (const m of sorted) {
+      if (m.paused) {
+        console.log(`  ${chalk6.gray("\u25CB")} ${chalk6.gray(m.name)} ${chalk6.dim("(paused)")}`);
+      } else if (m.status === "up") {
+        console.log(`  ${chalk6.green("\u25CF")} ${m.name}`);
+      } else if (m.status === "degraded") {
+        console.log(`  ${chalk6.yellow("\u25B2")} ${m.name} ${chalk6.yellow("degraded")}`);
+      } else {
+        console.log(`  ${chalk6.red("\u25CF")} ${m.name} ${chalk6.red("DOWN")}`);
+      }
+    }
+    console.log(
+      chalk6.dim(`
+  ${s.monitors.total} monitors | ${s.monitors.up} up | ${s.monitors.down} down | ${s.monitors.degraded} degraded
+`)
+    );
+  } catch (e) {
+    if (e instanceof Error) error(e.message);
+    process.exit(1);
+  }
+});
+var incidentsCommand = new Command("incidents").description("Manage incidents").addCommand(listIncidents()).addCommand(getIncident()).addCommand(createIncident()).addCommand(updateIncident()).addCommand(resolveIncident());
+function listIncidents() {
+  return new Command("list").alias("ls").description("List incidents").option("-s, --status <status>", "Filter (investigating, identified, monitoring, resolved)").option("--severity <severity>", "Filter (critical, major, minor)").option("-p, --page <n>", "Page number", "1").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const res = await api(
+        "/api/v1/incidents",
+        { params: { status: opts.status, severity: opts.severity, page: opts.page } }
+      );
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      if (res.data.length === 0) {
+        success("No incidents found.");
+        return;
+      }
+      heading(`Incidents (${res.pagination.total})`);
+      table(
+        ["ID", "Title", "Status", "Severity", "Started"],
+        res.data.map((i) => [
+          chalk6.dim(i.id.slice(0, 8)),
+          i.title.length > 40 ? i.title.slice(0, 37) + "..." : i.title,
+          statusColor(i.status),
+          statusColor(i.severity),
+          timeAgo(i.started_at || i.created_at)
+        ])
+      );
+    } catch (e) {
+      handleError2(e);
+    }
+  });
+}
+function getIncident() {
+  return new Command("get").description("Show incident details").argument("<id>", "Incident ID").option("--json", "Output raw JSON").action(async (id, opts) => {
+    try {
+      const res = await api(`/api/v1/incidents/${id}`);
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      const inc = res.data;
+      heading(inc.title);
+      kv("ID", inc.id);
+      kv("Status", statusColor(inc.status));
+      kv("Severity", statusColor(inc.severity));
+      kv("Started", inc.started_at || inc.created_at);
+      if (inc.resolved_at) kv("Resolved", inc.resolved_at);
+      if (inc.affected_monitors?.length) {
+        kv(
+          "Affected",
+          inc.affected_monitors.map((m) => m.name).join(", ")
+        );
+      }
+      if (inc.updates?.length) {
+        heading("Timeline");
+        for (const u of inc.updates) {
+          console.log(
+            `  ${chalk6.dim(timeAgo(u.created_at))} ${statusColor(u.status)} \u2014 ${u.message}`
+          );
+        }
+      }
+      console.log();
+    } catch (e) {
+      handleError2(e);
+    }
+  });
+}
+function createIncident() {
+  return new Command("create").description("Create a new incident").argument("<title>", "Incident title").option("-s, --severity <severity>", "Severity (critical, major, minor)", "major").option("--status <status>", "Initial status", "investigating").option("-m, --message <message>", "Initial status update message").option("--json", "Output raw JSON").action(async (title, opts) => {
+    try {
+      const body = {
+        title,
+        severity: opts.severity,
+        status: opts.status
+      };
+      if (opts.message) body.message = opts.message;
+      const res = await api("/api/v1/incidents", {
+        method: "POST",
+        body
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      success(`Incident created: ${res.data.id}`);
+    } catch (e) {
+      handleError2(e);
+    }
+  });
+}
+function updateIncident() {
+  return new Command("update").description("Add a status update to an incident").argument("<id>", "Incident ID").requiredOption("-m, --message <message>", "Update message").option("-s, --status <status>", "New status (investigating, identified, monitoring)").option("--json", "Output raw JSON").action(async (id, opts) => {
+    try {
+      const body = { message: opts.message };
+      if (opts.status) body.status = opts.status;
+      const res = await api(`/api/v1/incidents/${id}/updates`, {
+        method: "POST",
+        body
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      success("Incident updated.");
+    } catch (e) {
+      handleError2(e);
+    }
+  });
+}
+function resolveIncident() {
+  return new Command("resolve").description("Resolve an incident").argument("<id>", "Incident ID").option("-m, --message <message>", "Resolution message").option("--json", "Output raw JSON").action(async (id, opts) => {
+    try {
+      const body = {};
+      if (opts.message) body.message = opts.message;
+      const res = await api(`/api/v1/incidents/${id}/resolve`, {
+        method: "POST",
+        body
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      success(`Incident ${id} resolved.`);
+    } catch (e) {
+      handleError2(e);
+    }
+  });
+}
+function handleError2(e) {
+  if (e instanceof ApiError) error(`${e.message} (${e.status})`);
+  else if (e instanceof Error) error(e.message);
+  process.exit(1);
+}
+var speedTestCommand = new Command("speed-test").description("Test any URL from 6 global regions").argument("<url>", "URL to test").option("--json", "Output raw JSON").action(async (url, opts) => {
+  const ora = (await import('ora')).default;
+  const spinner = ora(`Testing ${url} from 6 regions...`).start();
+  try {
+    const res = await api("/api/speed-test/run", {
+      method: "POST",
+      body: { url },
+      noAuth: true
+    });
+    spinner.stop();
+    if (opts.json) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    heading(`Speed Test: ${url}`);
+    const times = res.results.filter((r) => r.status === "up").map((r) => r.responseTimeMs);
+    if (times.length > 0) {
+      const avg = times.reduce((a, b) => a + b, 0) / times.length;
+      const min = Math.min(...times);
+      const max = Math.max(...times);
+      console.log(
+        `  ${chalk6.dim("Avg:")} ${formatMs(avg)}  ${chalk6.dim("Min:")} ${formatMs(min)}  ${chalk6.dim("Max:")} ${formatMs(max)}`
+      );
+    }
+    console.log();
+    table(
+      ["Region", "Status", "Code", "Total", "DNS", "Connect", "TLS", "TTFB", "Transfer"],
+      res.results.map((r) => [
+        r.region,
+        r.errorMessage ? chalk6.red("fail") : statusColor(r.status),
+        r.statusCode || "\u2014",
+        formatMs(r.responseTimeMs),
+        formatMs(r.timingDnsMs),
+        formatMs(r.timingConnectMs),
+        formatMs(r.timingTlsMs),
+        formatMs(r.timingTtfbMs),
+        formatMs(r.timingTransferMs)
+      ])
+    );
+    heading("Waterfall");
+    const maxTime = Math.max(...res.results.map((r) => r.responseTimeMs), 1);
+    for (const r of res.results) {
+      const barLen = Math.round(r.responseTimeMs / maxTime * 40);
+      const dnsBar = Math.max(1, Math.round(r.timingDnsMs / maxTime * 40));
+      const connectBar = Math.max(1, Math.round(r.timingConnectMs / maxTime * 40));
+      const tlsBar = Math.max(1, Math.round(r.timingTlsMs / maxTime * 40));
+      const ttfbBar = Math.max(1, Math.round(r.timingTtfbMs / maxTime * 40));
+      const transferBar = Math.max(0, barLen - dnsBar - connectBar - tlsBar - ttfbBar);
+      const bar = chalk6.blue("\u2588".repeat(dnsBar)) + chalk6.cyan("\u2588".repeat(connectBar)) + chalk6.magenta("\u2588".repeat(tlsBar)) + chalk6.yellow("\u2588".repeat(ttfbBar)) + chalk6.green("\u2588".repeat(transferBar));
+      console.log(`  ${r.region.padEnd(15)} ${bar} ${formatMs(r.responseTimeMs)}`);
+    }
+    console.log(
+      chalk6.dim(
+        `
+  ${chalk6.blue("\u25A0")} DNS  ${chalk6.cyan("\u25A0")} Connect  ${chalk6.magenta("\u25A0")} TLS  ${chalk6.yellow("\u25A0")} TTFB  ${chalk6.green("\u25A0")} Transfer`
+      )
+    );
+    const sslResult = res.results.find((r) => r.sslExpiryDays !== void 0);
+    if (sslResult?.sslExpiryDays) {
+      const days = sslResult.sslExpiryDays;
+      const sslColor = days > 30 ? chalk6.green : days > 7 ? chalk6.yellow : chalk6.red;
+      console.log(`
+  ${chalk6.dim("SSL expiry:")} ${sslColor(days + " days")}`);
+    }
+    if (res.id) {
+      console.log(
+        chalk6.dim(`
+  Share: https://happyuptime.com/speed-test?id=${res.id}`)
+      );
+    }
+    console.log();
+  } catch (e) {
+    spinner.stop();
+    if (e instanceof ApiError) error(`${e.message} (${e.status})`);
+    else if (e instanceof Error) error(e.message);
+    process.exit(1);
+  }
+});
+var CONFIG_FILENAME = "happyuptime.yml";
+var configCommand = new Command("config").description("Config-as-code (happyuptime.yml)").addCommand(configPull()).addCommand(configPush()).addCommand(configValidate());
+function configPull() {
+  return new Command("pull").description("Generate happyuptime.yml from current monitors").option("-o, --output <file>", "Output file", CONFIG_FILENAME).action(async (opts) => {
+    const ora = (await import('ora')).default;
+    const spinner = ora("Fetching monitors...").start();
+    try {
+      const res = await api("/api/v1/monitors", {
+        params: { per_page: 200 }
+      });
+      spinner.stop();
+      const yaml = (await import('yaml')).default;
+      const config = {
+        monitors: res.data.map((m) => {
+          const mon = {
+            name: m.name,
+            url: m.url,
+            type: m.type,
+            interval: m.interval_seconds,
+            regions: m.regions
+          };
+          if (m.method && m.method !== "GET") mon.method = m.method;
+          if (m.timeout_ms !== 3e4) mon.timeout = m.timeout_ms;
+          if (m.tags?.length) mon.tags = m.tags;
+          return mon;
+        })
+      };
+      const content = yaml.stringify(config, { indent: 2 });
+      writeFileSync(opts.output, content);
+      success(`Config written to ${opts.output} (${res.data.length} monitors)`);
+    } catch (e) {
+      spinner.stop();
+      handleError3(e);
+    }
+  });
+}
+function configPush() {
+  return new Command("push").description("Sync happyuptime.yml to Happy Uptime").option("-f, --file <file>", "Config file path", CONFIG_FILENAME).option("-y, --yes", "Skip confirmation").option("--dry-run", "Show what would change without applying").action(async (opts) => {
+    if (!existsSync(opts.file)) {
+      error(`${opts.file} not found. Run \`happy config pull\` first.`);
+      process.exit(1);
+    }
+    const yaml = (await import('yaml')).default;
+    let config;
+    try {
+      const raw = readFileSync(opts.file, "utf-8");
+      const substituted = raw.replace(/\$\{(\w+)\}/g, (_, name) => {
+        const val = process.env[name];
+        if (!val) {
+          warn(`Environment variable ${name} is not set`);
+          return "";
+        }
+        return val;
+      });
+      config = yaml.parse(substituted);
+    } catch (e) {
+      error(`Invalid YAML: ${e.message}`);
+      process.exit(1);
+    }
+    if (!config.monitors?.length) {
+      warn("No monitors defined in config.");
+      return;
+    }
+    const ora = (await import('ora')).default;
+    const spinner = ora("Comparing with remote...").start();
+    try {
+      const existing = await api("/api/v1/monitors", {
+        params: { per_page: 200 }
+      });
+      spinner.stop();
+      const existingByName = new Map(existing.data.map((m) => [m.name, m]));
+      const toCreate = [];
+      const toUpdate = [];
+      for (const mon of config.monitors) {
+        const ex = existingByName.get(mon.name);
+        if (!ex) {
+          toCreate.push(mon);
+        } else {
+          const changes = {};
+          if (mon.url && mon.url !== ex.url) changes.url = mon.url;
+          if (mon.type && mon.type !== ex.type) changes.type = mon.type;
+          if (mon.interval && mon.interval !== ex.interval_seconds)
+            changes.interval_seconds = mon.interval;
+          if (mon.regions && JSON.stringify(mon.regions) !== JSON.stringify(ex.regions))
+            changes.regions = mon.regions;
+          if (Object.keys(changes).length > 0) {
+            toUpdate.push({ id: ex.id, body: changes });
+          }
+        }
+      }
+      console.log();
+      if (toCreate.length === 0 && toUpdate.length === 0) {
+        success("Everything is in sync.");
+        return;
+      }
+      if (toCreate.length > 0) {
+        console.log(chalk6.green(`  + ${toCreate.length} monitor(s) to create`));
+        for (const m of toCreate) console.log(chalk6.green(`    + ${m.name}`));
+      }
+      if (toUpdate.length > 0) {
+        console.log(chalk6.yellow(`  ~ ${toUpdate.length} monitor(s) to update`));
+      }
+      if (opts.dryRun) {
+        console.log(chalk6.dim("\n  (dry run \u2014 no changes applied)"));
+        return;
+      }
+      if (!opts.yes) {
+        const { default: inquirer } = await import('inquirer');
+        const { confirm } = await inquirer.prompt([
+          { type: "confirm", name: "confirm", message: "Apply changes?", default: true }
+        ]);
+        if (!confirm) return;
+      }
+      const applySpinner = ora("Applying...").start();
+      let created = 0;
+      let updated = 0;
+      for (const mon of toCreate) {
+        await api("/api/v1/monitors", {
+          method: "POST",
+          body: {
+            name: mon.name,
+            url: mon.url,
+            type: mon.type || "http",
+            method: mon.method || "GET",
+            interval_seconds: mon.interval || 60,
+            timeout_ms: mon.timeout || 3e4,
+            regions: mon.regions || ["us-east", "eu-west"],
+            tags: mon.tags,
+            headers: mon.headers,
+            assertions: mon.assertions
+          }
+        });
+        created++;
+      }
+      for (const { id, body } of toUpdate) {
+        await api(`/api/v1/monitors/${id}`, { method: "PUT", body });
+        updated++;
+      }
+      applySpinner.stop();
+      success(
+        `Done. ${created} created, ${updated} updated.`
+      );
+    } catch (e) {
+      spinner.stop();
+      handleError3(e);
+    }
+  });
+}
+function configValidate() {
+  return new Command("validate").description("Validate happyuptime.yml syntax").option("-f, --file <file>", "Config file path", CONFIG_FILENAME).action(async (opts) => {
+    if (!existsSync(opts.file)) {
+      error(`${opts.file} not found.`);
+      process.exit(1);
+    }
+    const yaml = (await import('yaml')).default;
+    try {
+      const raw = readFileSync(opts.file, "utf-8");
+      const config = yaml.parse(raw);
+      let errors = 0;
+      if (!config.monitors || !Array.isArray(config.monitors)) {
+        error("Missing or invalid 'monitors' array.");
+        errors++;
+      } else {
+        for (let i = 0; i < config.monitors.length; i++) {
+          const m = config.monitors[i];
+          if (!m.name) {
+            error(`monitors[${i}]: missing 'name'`);
+            errors++;
+          }
+          if (!m.url && m.type !== "heartbeat") {
+            error(`monitors[${i}] (${m.name || "unnamed"}): missing 'url'`);
+            errors++;
+          }
+          if (m.type && !["http", "ping", "tcp", "dns", "keyword", "heartbeat"].includes(m.type)) {
+            error(`monitors[${i}] (${m.name}): invalid type '${m.type}'`);
+            errors++;
+          }
+        }
+      }
+      if (errors === 0) {
+        success(
+          `${opts.file} is valid (${config.monitors?.length || 0} monitors defined)`
+        );
+      } else {
+        error(`${errors} error(s) found.`);
+        process.exit(1);
+      }
+    } catch (e) {
+      error(`Parse error: ${e.message}`);
+      process.exit(1);
+    }
+  });
+}
+function handleError3(e) {
+  if (e instanceof ApiError) error(`${e.message} (${e.status})`);
+  else if (e instanceof Error) error(e.message);
+  process.exit(1);
+}
+var alertsCommand = new Command("alerts").description("Manage alert channels").addCommand(listAlerts()).addCommand(createAlert()).addCommand(deleteAlert());
+function listAlerts() {
+  return new Command("list").alias("ls").description("List alert channels").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const res = await api("/api/v1/alerts/channels");
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      if (res.data.length === 0) {
+        warn("No alert channels configured.");
+        return;
+      }
+      heading("Alert Channels");
+      table(
+        ["ID", "Name", "Type", "Default", "Created"],
+        res.data.map((ch) => [
+          chalk6.dim(ch.id.slice(0, 8)),
+          ch.name,
+          ch.type,
+          ch.is_default ? chalk6.green("yes") : "no",
+          timeAgo(ch.created_at)
+        ])
+      );
+    } catch (e) {
+      handleError4(e);
+    }
+  });
+}
+function createAlert() {
+  return new Command("create").description("Create an alert channel").requiredOption("-n, --name <name>", "Channel name").requiredOption("-t, --type <type>", "Type (slack, discord, webhook, email, telegram)").option("--webhook-url <url>", "Webhook URL (for slack, discord, webhook)").option("--email <email>", "Email address (for email type)").option("--default", "Set as default channel").option("--json", "Output raw JSON").action(async (opts) => {
+    try {
+      const config = {};
+      if (opts.webhookUrl) config.webhook_url = opts.webhookUrl;
+      if (opts.email) config.email = opts.email;
+      const res = await api("/api/v1/alerts/channels", {
+        method: "POST",
+        body: {
+          name: opts.name,
+          type: opts.type,
+          config,
+          is_default: opts.default || false
+        }
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      success(`Alert channel "${res.data.name}" created (${res.data.id})`);
+    } catch (e) {
+      handleError4(e);
+    }
+  });
+}
+function deleteAlert() {
+  return new Command("delete").alias("rm").description("Delete an alert channel").argument("<id>", "Channel ID").option("-y, --yes", "Skip confirmation").action(async (id, opts) => {
+    if (!opts.yes) {
+      const { default: inquirer } = await import('inquirer');
+      const { confirm } = await inquirer.prompt([
+        { type: "confirm", name: "confirm", message: `Delete alert channel ${id}?`, default: false }
+      ]);
+      if (!confirm) return;
+    }
+    try {
+      await api(`/api/v1/alerts/channels/${id}`, { method: "DELETE" });
+      success(`Alert channel ${id} deleted.`);
+    } catch (e) {
+      handleError4(e);
+    }
+  });
+}
+function handleError4(e) {
+  if (e instanceof ApiError) error(`${e.message} (${e.status})`);
+  else if (e instanceof Error) error(e.message);
+  process.exit(1);
+}
+
+// src/index.ts
+var program = new Command().name("happy").description("Happy Uptime CLI \u2014 monitor uptime, manage incidents, check speed").version(VERSION, "-v, --version");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(statusCommand);
+program.addCommand(monitorsCommand);
+program.addCommand(incidentsCommand);
+program.addCommand(alertsCommand);
+program.addCommand(speedTestCommand);
+program.addCommand(configCommand);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "happyuptime",
+  "version": "1.0.0",
+  "description": "CLI for Happy Uptime — monitor uptime, manage incidents, and check site speed from the terminal.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "happyuptime": "dist/index.js",
+    "happy": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "uptime",
+    "monitoring",
+    "status-page",
+    "cli",
+    "devops",
+    "incident-management",
+    "speed-test",
+    "alerting",
+    "sla"
+  ],
+  "author": "Happy Uptime <hello@happyuptime.com>",
+  "license": "MIT",
+  "homepage": "https://happyuptime.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seangeng/happyuptime.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/seangeng/happyuptime/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "inquirer": "^12.6.0",
+    "ora": "^8.2.0",
+    "yaml": "^2.7.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
+  }
+}