@delt/claude-alarm 0.1.0

package/dist/cli.js

@@ -0,0 +1,921 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/constants.ts
+import path from "path";
+import os from "os";
+var DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, CONFIG_DIR, CONFIG_FILE, PID_FILE, LOG_FILE, WS_PATH_CHANNEL, WS_PATH_DASHBOARD;
+var init_constants = __esm({
+  "src/shared/constants.ts"() {
+    "use strict";
+    DEFAULT_HUB_HOST = "127.0.0.1";
+    DEFAULT_HUB_PORT = 7890;
+    CONFIG_DIR = path.join(os.homedir(), ".claude-alarm");
+    CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+    PID_FILE = path.join(CONFIG_DIR, "hub.pid");
+    LOG_FILE = path.join(CONFIG_DIR, "hub.log");
+    WS_PATH_CHANNEL = "/ws/channel";
+    WS_PATH_DASHBOARD = "/ws/dashboard";
+  }
+});
+
+// src/shared/logger.ts
+var logger;
+var init_logger = __esm({
+  "src/shared/logger.ts"() {
+    "use strict";
+    logger = {
+      info(msg, ...args) {
+        console.error(`[claude-alarm] ${msg}`, ...args);
+      },
+      warn(msg, ...args) {
+        console.error(`[claude-alarm WARN] ${msg}`, ...args);
+      },
+      error(msg, ...args) {
+        console.error(`[claude-alarm ERROR] ${msg}`, ...args);
+      },
+      debug(msg, ...args) {
+        if (process.env.CLAUDE_ALARM_DEBUG) {
+          console.error(`[claude-alarm DEBUG] ${msg}`, ...args);
+        }
+      }
+    };
+  }
+});
+
+// src/hub/session-manager.ts
+var SessionManager;
+var init_session_manager = __esm({
+  "src/hub/session-manager.ts"() {
+    "use strict";
+    SessionManager = class {
+      sessions = /* @__PURE__ */ new Map();
+      register(session) {
+        this.sessions.set(session.id, { ...session });
+      }
+      unregister(sessionId) {
+        const session = this.sessions.get(sessionId);
+        this.sessions.delete(sessionId);
+        return session;
+      }
+      updateStatus(sessionId, status) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+          session.status = status;
+          session.lastActivity = Date.now();
+        }
+        return session;
+      }
+      updateActivity(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+          session.lastActivity = Date.now();
+        }
+      }
+      get(sessionId) {
+        return this.sessions.get(sessionId);
+      }
+      getAll() {
+        return Array.from(this.sessions.values());
+      }
+      count() {
+        return this.sessions.size;
+      }
+    };
+  }
+});
+
+// src/hub/notifier.ts
+import notifier from "node-notifier";
+import { execFile } from "child_process";
+var Notifier;
+var init_notifier = __esm({
+  "src/hub/notifier.ts"() {
+    "use strict";
+    init_logger();
+    Notifier = class {
+      webhooks = [];
+      desktopEnabled = true;
+      notificationSettingsOpened = false;
+      dashboardUrl;
+      configure(options) {
+        if (options.dashboardUrl) this.dashboardUrl = options.dashboardUrl;
+        if (options.desktop !== void 0) this.desktopEnabled = options.desktop;
+        if (options.webhooks) this.webhooks = options.webhooks;
+      }
+      async notify(title, message, level = "info") {
+        const promises = [];
+        if (this.desktopEnabled) {
+          promises.push(this.sendDesktop(title, message, level));
+        }
+        for (const webhook of this.webhooks) {
+          promises.push(this.sendWebhook(webhook, title, message, level));
+        }
+        await Promise.allSettled(promises);
+      }
+      async sendDesktop(title, message, _level) {
+        if (process.platform === "win32") {
+          const enabled = await this.checkWindowsNotifications();
+          if (!enabled) {
+            this.openNotificationSettings();
+            return;
+          }
+        }
+        return new Promise((resolve) => {
+          const notification = notifier.notify(
+            {
+              title: `Claude Alarm: ${title}`,
+              message,
+              sound: true,
+              wait: true
+            },
+            (err) => {
+              if (err) {
+                logger.warn(`Desktop notification failed: ${err.message}`);
+              }
+              resolve();
+            }
+          );
+          if (this.dashboardUrl && notification) {
+            const url = this.dashboardUrl;
+            notification.on("click", () => {
+              execFile("powershell", ["-Command", `Start-Process "${url}"`]);
+            });
+          }
+        });
+      }
+      checkWindowsNotifications() {
+        return new Promise((resolve) => {
+          execFile(
+            "powershell",
+            ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
+            (err, stdout) => {
+              if (err) {
+                resolve(true);
+                return;
+              }
+              const value = stdout.trim();
+              resolve(value !== "0");
+            }
+          );
+        });
+      }
+      openNotificationSettings() {
+        if (this.notificationSettingsOpened) return;
+        this.notificationSettingsOpened = true;
+        logger.warn("Windows notifications are disabled. Opening notification settings...");
+        logger.warn("Please enable notifications for this app, then try again.");
+        if (process.platform === "win32") {
+          execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"]);
+        }
+        setTimeout(() => {
+          this.notificationSettingsOpened = false;
+        }, 5 * 60 * 1e3);
+      }
+      async sendWebhook(webhook, title, message, level) {
+        try {
+          const response = await fetch(webhook.url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...webhook.headers
+            },
+            body: JSON.stringify({
+              title,
+              message,
+              level,
+              timestamp: Date.now(),
+              source: "claude-alarm"
+            })
+          });
+          if (!response.ok) {
+            logger.warn(`Webhook ${webhook.url} returned ${response.status}`);
+          }
+        } catch (err) {
+          logger.warn(`Webhook ${webhook.url} failed: ${err.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/hub/server.ts
+var server_exports = {};
+__export(server_exports, {
+  HubServer: () => HubServer
+});
+import http from "http";
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer, WebSocket } from "ws";
+var __dirname, HubServer;
+var init_server = __esm({
+  "src/hub/server.ts"() {
+    "use strict";
+    init_logger();
+    init_constants();
+    init_session_manager();
+    init_notifier();
+    __dirname = path3.dirname(fileURLToPath(import.meta.url));
+    HubServer = class {
+      httpServer;
+      wssChannel;
+      wssDashboard;
+      sessions = new SessionManager();
+      notifier = new Notifier();
+      startTime = Date.now();
+      // Map sessionId -> channel WebSocket
+      channelSockets = /* @__PURE__ */ new Map();
+      // All connected dashboard WebSockets
+      dashboardSockets = /* @__PURE__ */ new Set();
+      host;
+      port;
+      token;
+      constructor(config) {
+        this.host = config?.hub?.host ?? DEFAULT_HUB_HOST;
+        this.port = config?.hub?.port ?? DEFAULT_HUB_PORT;
+        this.token = config?.hub?.token;
+        if (config?.notifications) {
+          this.notifier.configure({
+            desktop: config.notifications.desktop
+          });
+        }
+        if (config?.webhooks) {
+          this.notifier.configure({ webhooks: config.webhooks });
+        }
+        this.notifier.configure({ dashboardUrl: `http://${this.host}:${this.port}` });
+        this.httpServer = http.createServer((req, res) => this.handleHttp(req, res));
+        this.wssChannel = new WebSocketServer({ noServer: true });
+        this.wssChannel.on("connection", (ws) => this.handleChannelConnection(ws));
+        this.wssDashboard = new WebSocketServer({ noServer: true });
+        this.wssDashboard.on("connection", (ws) => this.handleDashboardConnection(ws));
+        this.httpServer.on("upgrade", (req, socket, head) => {
+          const url = new URL(req.url, `http://${req.headers.host}`);
+          const pathname = url.pathname;
+          if (this.token && !this.isLocalRequest(req)) {
+            const wsToken = url.searchParams.get("token");
+            if (wsToken !== this.token) {
+              socket.destroy();
+              return;
+            }
+          }
+          if (pathname === WS_PATH_CHANNEL) {
+            this.wssChannel.handleUpgrade(req, socket, head, (ws) => {
+              this.wssChannel.emit("connection", ws, req);
+            });
+          } else if (pathname === WS_PATH_DASHBOARD) {
+            this.wssDashboard.handleUpgrade(req, socket, head, (ws) => {
+              this.wssDashboard.emit("connection", ws, req);
+            });
+          } else {
+            socket.destroy();
+          }
+        });
+      }
+      async start() {
+        return new Promise((resolve, reject) => {
+          this.httpServer.on("error", reject);
+          this.httpServer.listen(this.port, this.host, () => {
+            logger.info(`Hub server listening on http://${this.host}:${this.port}`);
+            resolve();
+          });
+        });
+      }
+      stop() {
+        return new Promise((resolve) => {
+          for (const ws of this.channelSockets.values()) ws.close();
+          for (const ws of this.dashboardSockets) ws.close();
+          this.wssChannel.close();
+          this.wssDashboard.close();
+          this.httpServer.close(() => {
+            logger.info("Hub server stopped");
+            resolve();
+          });
+        });
+      }
+      // --- HTTP Handler ---
+      handleHttp(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const origin = req.headers.origin;
+        if (origin && (origin.includes("127.0.0.1") || origin.includes("localhost"))) {
+          res.setHeader("Access-Control-Allow-Origin", origin);
+        }
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (req.method === "OPTIONS") {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+        if (url.pathname !== "/" && this.token) {
+          if (!this.isLocalRequest(req)) {
+            const authHeader = req.headers["authorization"];
+            const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+            if (bearerToken !== this.token) {
+              this.jsonResponse(res, 401, { error: "Unauthorized" });
+              return;
+            }
+          }
+        }
+        if (url.pathname === "/" && req.method === "GET") {
+          this.serveDashboard(res);
+        } else if (url.pathname === "/api/sessions" && req.method === "GET") {
+          this.jsonResponse(res, 200, { sessions: this.sessions.getAll() });
+        } else if (url.pathname === "/api/status" && req.method === "GET") {
+          this.jsonResponse(res, 200, {
+            running: true,
+            pid: process.pid,
+            port: this.port,
+            sessions: this.sessions.count(),
+            uptime: Date.now() - this.startTime
+          });
+        } else if (url.pathname === "/api/send" && req.method === "POST") {
+          this.handleApiSend(req, res);
+        } else if (url.pathname === "/api/notify" && req.method === "POST") {
+          this.handleApiNotify(req, res);
+        } else {
+          this.jsonResponse(res, 404, { error: "Not found" });
+        }
+      }
+      serveDashboard(res) {
+        const candidates = [
+          path3.join(__dirname, "..", "dashboard", "index.html"),
+          // from dist/hub/
+          path3.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+          // from dist/hub/ -> src/
+          path3.join(process.cwd(), "dist", "dashboard", "index.html"),
+          // from cwd
+          path3.join(process.cwd(), "src", "dashboard", "index.html")
+          // from cwd/src
+        ];
+        logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
+        for (const candidate of candidates) {
+          if (fs2.existsSync(candidate)) {
+            const html = fs2.readFileSync(candidate, "utf-8");
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            res.end(html);
+            return;
+          }
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end("<html><body><h1>claude-alarm</h1><p>Dashboard HTML not found. Reinstall the package.</p></body></html>");
+      }
+      async handleApiSend(req, res) {
+        const body = await this.readBody(req);
+        if (!body) {
+          this.jsonResponse(res, 400, { error: "Invalid JSON" });
+          return;
+        }
+        const { sessionId, content } = body;
+        if (!sessionId || !content) {
+          this.jsonResponse(res, 400, { error: "sessionId and content are required" });
+          return;
+        }
+        const ws = this.channelSockets.get(sessionId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+          this.jsonResponse(res, 404, { error: "Session not connected" });
+          return;
+        }
+        const msg = { type: "message_to_session", sessionId, content };
+        ws.send(JSON.stringify(msg));
+        this.jsonResponse(res, 200, { ok: true });
+      }
+      async handleApiNotify(req, res) {
+        const body = await this.readBody(req);
+        if (!body) {
+          this.jsonResponse(res, 400, { error: "Invalid JSON" });
+          return;
+        }
+        const { title, message, level } = body;
+        if (!title || !message) {
+          this.jsonResponse(res, 400, { error: "title and message are required" });
+          return;
+        }
+        await this.notifier.notify(title, message, level ?? "info");
+        this.jsonResponse(res, 200, { ok: true });
+      }
+      // --- Channel WebSocket ---
+      handleChannelConnection(ws) {
+        logger.info("Channel server connected");
+        ws.on("message", (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this.handleChannelMessage(ws, msg);
+          } catch {
+            logger.warn("Invalid message from channel");
+          }
+        });
+        ws.on("close", () => {
+          for (const [sessionId, sock] of this.channelSockets) {
+            if (sock === ws) {
+              const session = this.sessions.unregister(sessionId);
+              this.channelSockets.delete(sessionId);
+              logger.info(`Channel disconnected: ${sessionId}`);
+              this.broadcastToDashboards({
+                type: "session_disconnected",
+                sessionId
+              });
+              break;
+            }
+          }
+        });
+      }
+      handleChannelMessage(ws, msg) {
+        switch (msg.type) {
+          case "register": {
+            const session = msg.session;
+            this.sessions.register(session);
+            this.channelSockets.set(session.id, ws);
+            logger.info(`Session registered: ${session.id} (${session.name})`);
+            this.broadcastToDashboards({ type: "session_connected", session });
+            break;
+          }
+          case "status": {
+            const updated = this.sessions.updateStatus(msg.sessionId, msg.status);
+            if (updated) {
+              this.broadcastToDashboards({ type: "session_updated", session: updated });
+            }
+            break;
+          }
+          case "notify": {
+            this.sessions.updateActivity(msg.sessionId);
+            this.notifier.notify(msg.title, msg.message, msg.level ?? "info");
+            this.broadcastToDashboards({
+              type: "notification",
+              sessionId: msg.sessionId,
+              title: msg.title,
+              message: msg.message,
+              level: msg.level,
+              timestamp: Date.now()
+            });
+            break;
+          }
+          case "reply": {
+            this.sessions.updateActivity(msg.sessionId);
+            this.broadcastToDashboards({
+              type: "reply_from_session",
+              sessionId: msg.sessionId,
+              content: msg.content,
+              timestamp: Date.now()
+            });
+            break;
+          }
+        }
+      }
+      // --- Dashboard WebSocket ---
+      handleDashboardConnection(ws) {
+        this.dashboardSockets.add(ws);
+        logger.info(`Dashboard connected (total: ${this.dashboardSockets.size})`);
+        const sessionsMsg = {
+          type: "sessions_list",
+          sessions: this.sessions.getAll()
+        };
+        ws.send(JSON.stringify(sessionsMsg));
+        ws.on("message", (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === "message_to_session") {
+              const channelWs = this.channelSockets.get(msg.sessionId);
+              if (channelWs?.readyState === WebSocket.OPEN) {
+                channelWs.send(JSON.stringify(msg));
+              }
+            }
+          } catch {
+            logger.warn("Invalid message from dashboard");
+          }
+        });
+        ws.on("close", () => {
+          this.dashboardSockets.delete(ws);
+          logger.info(`Dashboard disconnected (total: ${this.dashboardSockets.size})`);
+        });
+      }
+      // --- Helpers ---
+      broadcastToDashboards(msg) {
+        const payload = JSON.stringify(msg);
+        for (const ws of this.dashboardSockets) {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(payload);
+          }
+        }
+      }
+      jsonResponse(res, status, body) {
+        res.writeHead(status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+      }
+      isLocalRequest(req) {
+        const addr = req.socket.remoteAddress;
+        return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+      }
+      readBody(req, maxSize = 1024 * 1024) {
+        return new Promise((resolve) => {
+          let data = "";
+          let size = 0;
+          req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxSize) {
+              req.destroy();
+              resolve(null);
+              return;
+            }
+            data += chunk;
+          });
+          req.on("end", () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch {
+              resolve(null);
+            }
+          });
+        });
+      }
+    };
+    if (process.argv[1] && (process.argv[1].endsWith("hub/server.js") || process.argv[1].endsWith("hub/server.ts"))) {
+      const hub = new HubServer();
+      hub.start().catch((err) => {
+        logger.error("Failed to start hub:", err);
+        process.exit(1);
+      });
+      const shutdown = () => {
+        hub.stop().then(() => process.exit(0));
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+    }
+  }
+});
+
+// src/cli.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path4 from "path";
+import readline from "readline";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/shared/config.ts
+init_constants();
+import fs from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
+var DEFAULT_CONFIG = {
+  hub: {
+    host: DEFAULT_HUB_HOST,
+    port: DEFAULT_HUB_PORT
+  },
+  notifications: {
+    desktop: true,
+    sound: true
+  },
+  webhooks: []
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let config;
+  if (!fs.existsSync(CONFIG_FILE)) {
+    config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+  } else {
+    try {
+      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      config = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub } };
+    } catch {
+      config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+    }
+  }
+  if (!config.hub.token) {
+    config.hub.token = randomUUID();
+    saveConfig(config);
+  }
+  return config;
+}
+function getOrCreateToken() {
+  const config = loadConfig();
+  return config.hub.token;
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function setupMcpConfig(targetDir) {
+  const dir = targetDir ?? process.cwd();
+  const mcpPath = path2.join(dir, ".mcp.json");
+  let mcpConfig = {};
+  if (fs.existsSync(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+    } catch {
+      mcpConfig = {};
+    }
+  }
+  if (!mcpConfig.mcpServers) {
+    mcpConfig.mcpServers = {};
+  }
+  mcpConfig.mcpServers["claude-alarm"] = {
+    command: "npx",
+    args: ["-y", "@delt/claude-alarm"],
+    env: {
+      CLAUDE_ALARM_SESSION_NAME: path2.basename(dir)
+    }
+  };
+  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  return mcpPath;
+}
+
+// src/cli.ts
+init_constants();
+init_logger();
+var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+function printUsage() {
+  console.log(`
+claude-alarm - Monitor Claude Code sessions with notifications
+
+Usage:
+  claude-alarm init             Setup everything and show next steps
+  claude-alarm hub start [-d]   Start the hub server (-d for daemon)
+  claude-alarm hub stop         Stop the hub daemon
+  claude-alarm hub status       Show hub status
+  claude-alarm setup [dir]      Add claude-alarm to .mcp.json
+  claude-alarm test             Send a test notification
+  claude-alarm token            Show current auth token
+  claude-alarm help             Show this help
+
+Quick start:
+  claude-alarm init
+`);
+}
+async function hubStart(daemon) {
+  const config = loadConfig();
+  const host = config.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  if (fs3.existsSync(PID_FILE)) {
+    const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (isProcessRunning(pid)) {
+      console.log(`Hub is already running (PID: ${pid}) on http://${host}:${port}`);
+      return;
+    }
+    fs3.unlinkSync(PID_FILE);
+  }
+  if (daemon) {
+    ensureConfigDir();
+    const logFd = fs3.openSync(LOG_FILE, "a");
+    const hubScript = path4.join(__dirname2, "hub", "server.js");
+    const child = spawn(process.execPath, [hubScript], {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env }
+    });
+    if (child.pid) {
+      fs3.writeFileSync(PID_FILE, String(child.pid), "utf-8");
+      child.unref();
+      console.log(`Hub started as daemon (PID: ${child.pid})`);
+      console.log(`Dashboard: http://${host}:${port}`);
+      console.log(`Token: ${config.hub.token}`);
+      console.log(`Logs: ${LOG_FILE}`);
+    } else {
+      console.error("Failed to start hub daemon");
+      process.exit(1);
+    }
+  } else {
+    console.log(`Starting hub on http://${host}:${port} (press Ctrl+C to stop)`);
+    console.log(`Token: ${config.hub.token}`);
+    const { HubServer: HubServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const hub = new HubServer2(config);
+    await hub.start();
+    ensureConfigDir();
+    fs3.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    const shutdown = async () => {
+      console.log("\nShutting down...");
+      await hub.stop();
+      if (fs3.existsSync(PID_FILE)) fs3.unlinkSync(PID_FILE);
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+}
+function hubStop() {
+  if (!fs3.existsSync(PID_FILE)) {
+    console.log("Hub is not running (no PID file found)");
+    return;
+  }
+  const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Hub stopped (PID: ${pid})`);
+  } catch {
+    console.log("Hub process not found (may have already stopped)");
+  }
+  fs3.unlinkSync(PID_FILE);
+}
+async function hubStatus() {
+  const config = loadConfig();
+  const host = config.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  let pidInfo = "not running";
+  if (fs3.existsSync(PID_FILE)) {
+    const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (isProcessRunning(pid)) {
+      pidInfo = `running (PID: ${pid})`;
+    } else {
+      pidInfo = "not running (stale PID file)";
+    }
+  }
+  try {
+    const res = await fetch(`http://${host}:${port}/api/status`);
+    if (res.ok) {
+      const data = await res.json();
+      console.log(`Hub: running (PID: ${data.pid})`);
+      console.log(`Port: ${data.port}`);
+      console.log(`Sessions: ${data.sessions}`);
+      console.log(`Uptime: ${Math.round(data.uptime / 1e3)}s`);
+      console.log(`Dashboard: http://${host}:${port}`);
+      const token = config.hub.token;
+      if (token) {
+        console.log(`Token: ${token.slice(0, 8)}...(masked)`);
+      }
+      return;
+    }
+  } catch {
+  }
+  console.log(`Hub: ${pidInfo}`);
+  console.log(`Configured: http://${host}:${port}`);
+}
+function setup(targetDir) {
+  const mcpPath = setupMcpConfig(targetDir);
+  console.log(`Added claude-alarm to ${mcpPath}`);
+  console.log("\nTo use with Claude Code:");
+  console.log("  1. Start the hub: claude-alarm hub start -d");
+  console.log("  2. Run Claude Code: claude --dangerously-load-development-channels server:claude-alarm");
+}
+async function test() {
+  const config = loadConfig();
+  const host = config.hub.host ?? DEFAULT_HUB_HOST;
+  const port = config.hub.port ?? DEFAULT_HUB_PORT;
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (config.hub.token) {
+      headers["Authorization"] = `Bearer ${config.hub.token}`;
+    }
+    const res = await fetch(`http://${host}:${port}/api/notify`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        title: "Test Notification",
+        message: "Claude Alarm is working! This is a test notification.",
+        level: "success"
+      })
+    });
+    if (res.ok) {
+      console.log("Test notification sent! Check your desktop for the toast.");
+    } else {
+      console.error(`Hub returned ${res.status}. Is the hub running?`);
+    }
+  } catch {
+    console.error("Could not reach hub. Start it first: claude-alarm hub start");
+  }
+}
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function init() {
+  const dir = process.cwd();
+  const projectName = path4.basename(dir);
+  console.log(`
+claude-alarm init for "${projectName}"
+`);
+  const remote = await ask("Connect to a remote hub? (y/N): ");
+  let env = {
+    CLAUDE_ALARM_SESSION_NAME: projectName
+  };
+  if (remote.toLowerCase() === "y") {
+    const host = await ask("Hub host (e.g. 192.168.1.100): ");
+    const port = await ask("Hub port (default: 7890): ");
+    const token = await ask("Hub token: ");
+    if (!host) {
+      console.error("Host is required.");
+      process.exit(1);
+    }
+    env.CLAUDE_ALARM_HUB_HOST = host;
+    if (port) env.CLAUDE_ALARM_HUB_PORT = port;
+    if (token) env.CLAUDE_ALARM_HUB_TOKEN = token;
+  }
+  const mcpPath = path4.join(dir, ".mcp.json");
+  let mcpConfig = {};
+  if (fs3.existsSync(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(fs3.readFileSync(mcpPath, "utf-8"));
+    } catch {
+      mcpConfig = {};
+    }
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers["claude-alarm"] = {
+    command: "npx",
+    args: ["-y", "@delt/claude-alarm"],
+    env
+  };
+  fs3.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  console.log(`
+\u2713 Created ${mcpPath}`);
+  if (remote.toLowerCase() !== "y") {
+    const config = loadConfig();
+    const host = config.hub.host ?? DEFAULT_HUB_HOST;
+    const port = config.hub.port ?? DEFAULT_HUB_PORT;
+    let hubRunning = false;
+    try {
+      const res = await fetch(`http://${host}:${port}/api/status`);
+      hubRunning = res.ok;
+    } catch {
+    }
+    if (hubRunning) {
+      console.log("\u2713 Hub is running");
+    } else {
+      console.log("\u2717 Hub is not running. Start it with:");
+      console.log(`  claude-alarm hub start`);
+    }
+    console.log(`  Dashboard: http://${host}:${port}`);
+  }
+  console.log(`
+Next step:`);
+  console.log(`  claude --dangerously-load-development-channels server:claude-alarm
+`);
+}
+function showToken() {
+  const token = getOrCreateToken();
+  console.log(`Token: ${token}`);
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  const sub = args[1];
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    printUsage();
+    return;
+  }
+  if (cmd === "init") {
+    await init();
+    return;
+  }
+  if (cmd === "hub") {
+    if (sub === "start") {
+      const daemon = args.includes("-d") || args.includes("--daemon");
+      await hubStart(daemon);
+    } else if (sub === "stop") {
+      hubStop();
+    } else if (sub === "status") {
+      await hubStatus();
+    } else {
+      console.error(`Unknown hub command: ${sub}`);
+      printUsage();
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "setup") {
+    setup(args[1]);
+    return;
+  }
+  if (cmd === "test") {
+    await test();
+    return;
+  }
+  if (cmd === "token") {
+    showToken();
+    return;
+  }
+  console.error(`Unknown command: ${cmd}`);
+  printUsage();
+  process.exit(1);
+}
+main().catch((err) => {
+  logger.error("CLI error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map