@delt/claude-alarm 0.1.0

package/dist/index.js

@@ -0,0 +1,696 @@
+// src/hub/server.ts
+import http from "http";
+import fs from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/shared/logger.ts
+var 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/shared/constants.ts
+import path from "path";
+import os from "os";
+var DEFAULT_HUB_HOST = "127.0.0.1";
+var DEFAULT_HUB_PORT = 7890;
+var CONFIG_DIR = path.join(os.homedir(), ".claude-alarm");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var PID_FILE = path.join(CONFIG_DIR, "hub.pid");
+var LOG_FILE = path.join(CONFIG_DIR, "hub.log");
+var WS_PATH_CHANNEL = "/ws/channel";
+var WS_PATH_DASHBOARD = "/ws/dashboard";
+var CHANNEL_SERVER_NAME = "claude-alarm";
+var CHANNEL_SERVER_VERSION = "0.1.0";
+
+// src/hub/session-manager.ts
+var 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 = 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 __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var 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 = [
+      path2.join(__dirname, "..", "dashboard", "index.html"),
+      // from dist/hub/
+      path2.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+      // from dist/hub/ -> src/
+      path2.join(process.cwd(), "dist", "dashboard", "index.html"),
+      // from cwd
+      path2.join(process.cwd(), "src", "dashboard", "index.html")
+      // from cwd/src
+    ];
+    logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        const html = fs.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/channel/hub-client.ts
+import WebSocket2 from "ws";
+var HubClient = class {
+  constructor(sessionId, sessionName, hubHost = DEFAULT_HUB_HOST, hubPort = DEFAULT_HUB_PORT, token) {
+    this.sessionId = sessionId;
+    this.sessionName = sessionName;
+    this.hubHost = hubHost;
+    this.hubPort = hubPort;
+    this.token = token;
+  }
+  ws = null;
+  reconnectTimer = null;
+  messageHandlers = [];
+  queue = [];
+  connected = false;
+  connect() {
+    const tokenQuery = this.token ? `?token=${encodeURIComponent(this.token)}` : "";
+    const url = `ws://${this.hubHost}:${this.hubPort}${WS_PATH_CHANNEL}${tokenQuery}`;
+    logger.debug(`Connecting to hub at ${url}`);
+    try {
+      this.ws = new WebSocket2(url);
+      this.ws.on("open", () => {
+        logger.info("Connected to hub");
+        this.connected = true;
+        const registration = {
+          type: "register",
+          session: {
+            id: this.sessionId,
+            name: this.sessionName,
+            status: "idle",
+            connectedAt: Date.now(),
+            lastActivity: Date.now(),
+            cwd: process.cwd()
+          }
+        };
+        this.ws.send(JSON.stringify(registration));
+        for (const msg of this.queue) {
+          this.ws.send(JSON.stringify(msg));
+        }
+        this.queue = [];
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          for (const handler of this.messageHandlers) {
+            handler(msg);
+          }
+        } catch (err) {
+          logger.warn("Failed to parse hub message:", err);
+        }
+      });
+      this.ws.on("close", () => {
+        logger.info("Disconnected from hub");
+        this.connected = false;
+        this.scheduleReconnect();
+      });
+      this.ws.on("error", (err) => {
+        logger.debug(`Hub connection error: ${err.message}`);
+        this.connected = false;
+      });
+    } catch {
+      logger.debug("Failed to connect to hub, will retry");
+      this.scheduleReconnect();
+    }
+  }
+  send(msg) {
+    if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    } else {
+      if (this.queue.length < 100) {
+        this.queue.push(msg);
+      }
+      logger.debug("Hub not connected, message queued");
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, 5e3);
+  }
+};
+
+// src/shared/config.ts
+import fs2 from "fs";
+import path3 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 (!fs2.existsSync(CONFIG_DIR)) {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let config;
+  if (!fs2.existsSync(CONFIG_FILE)) {
+    config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+  } else {
+    try {
+      const raw = fs2.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 saveConfig(config) {
+  ensureConfigDir();
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function setupMcpConfig(targetDir) {
+  const dir = targetDir ?? process.cwd();
+  const mcpPath = path3.join(dir, ".mcp.json");
+  let mcpConfig = {};
+  if (fs2.existsSync(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(fs2.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: path3.basename(dir)
+    }
+  };
+  fs2.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  return mcpPath;
+}
+export {
+  CHANNEL_SERVER_NAME,
+  CHANNEL_SERVER_VERSION,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULT_HUB_HOST,
+  DEFAULT_HUB_PORT,
+  HubClient,
+  HubServer,
+  LOG_FILE,
+  Notifier,
+  PID_FILE,
+  SessionManager,
+  WS_PATH_CHANNEL,
+  WS_PATH_DASHBOARD,
+  loadConfig,
+  logger,
+  saveConfig,
+  setupMcpConfig
+};
+//# sourceMappingURL=index.js.map