@delt/claude-alarm 0.4.8 → 0.5.0

package/dist/cli.js

@@ -48,7 +48,7 @@ function loadConfig() {
     try {
       const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
       const parsed = JSON.parse(raw);
-      config2 = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub } };
+      config2 = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub }, ...parsed.telegram ? { telegram: parsed.telegram } : {} };
     } catch {
       config2 = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
     }
@@ -189,12 +189,17 @@ var init_notifier = __esm({
       desktopEnabled = true;
       notificationSettingsOpened = false;
       dashboardUrl;
+      telegramBot;
       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;
+        if (options.telegramBot) this.telegramBot = options.telegramBot;
       }
       async notify(title, message, level = "info") {
+        await this.notifyWithSession(void 0, void 0, title, message, level);
+      }
+      async notifyWithSession(sessionId2, sessionLabel, title, message, level = "info") {
         const promises = [];
         if (this.desktopEnabled) {
           promises.push(this.sendDesktop(title, message, level));
@@ -202,6 +207,9 @@ var init_notifier = __esm({
         for (const webhook of this.webhooks) {
           promises.push(this.sendWebhook(webhook, title, message, level));
         }
+        if (this.telegramBot && sessionId2 && sessionLabel) {
+          promises.push(this.telegramBot.sendNotification(sessionId2, sessionLabel, title, message));
+        }
         await Promise.allSettled(promises);
       }
       async sendDesktop(title, message, _level) {
@@ -284,6 +292,183 @@ var init_notifier = __esm({
   }
 });
 
+// src/hub/telegram.ts
+var TELEGRAM_API, TelegramBot;
+var init_telegram = __esm({
+  "src/hub/telegram.ts"() {
+    "use strict";
+    init_logger();
+    TELEGRAM_API = "https://api.telegram.org/bot";
+    TelegramBot = class {
+      config;
+      offset = 0;
+      polling = false;
+      pollTimer = null;
+      // message_id -> sessionId mapping for reply-based routing
+      messageSessionMap = /* @__PURE__ */ new Map();
+      // Callback: when a message arrives from Telegram for a session
+      onMessageToSession;
+      // Callback: get current sessions list
+      getSessions;
+      // Callback: when user needs to select a session (sends inline keyboard)
+      pendingMessages = /* @__PURE__ */ new Map();
+      // chatId -> pending message text
+      constructor(config2) {
+        this.config = config2;
+      }
+      get apiUrl() {
+        return `${TELEGRAM_API}${this.config.botToken}`;
+      }
+      /** Send a notification message to Telegram */
+      async sendNotification(sessionId2, sessionLabel, title, message) {
+        const text = `[${sessionLabel}] ${title}
+${message}`;
+        const result = await this.sendMessage(text);
+        if (result?.message_id) {
+          this.messageSessionMap.set(result.message_id, sessionId2);
+          if (this.messageSessionMap.size > 200) {
+            const keys = [...this.messageSessionMap.keys()];
+            for (let i = 0; i < keys.length - 200; i++) {
+              this.messageSessionMap.delete(keys[i]);
+            }
+          }
+        }
+      }
+      /** Send a text message to the configured chat */
+      async sendMessage(text, replyToMessageId, replyMarkup) {
+        try {
+          const body = {
+            chat_id: this.config.chatId,
+            text,
+            parse_mode: "HTML"
+          };
+          if (replyToMessageId) body.reply_to_message_id = replyToMessageId;
+          if (replyMarkup) body.reply_markup = replyMarkup;
+          const res = await fetch(`${this.apiUrl}/sendMessage`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok) {
+            const err = await res.text();
+            logger.warn(`Telegram sendMessage failed: ${res.status} ${err}`);
+            return null;
+          }
+          const data = await res.json();
+          return data.ok ? data.result : null;
+        } catch (err) {
+          logger.warn(`Telegram sendMessage error: ${err.message}`);
+          return null;
+        }
+      }
+      /** Start long polling for incoming messages */
+      startPolling() {
+        if (this.polling) return;
+        this.polling = true;
+        logger.info("Telegram bot polling started");
+        this.poll();
+      }
+      /** Stop polling */
+      stopPolling() {
+        this.polling = false;
+        if (this.pollTimer) {
+          clearTimeout(this.pollTimer);
+          this.pollTimer = null;
+        }
+        logger.info("Telegram bot polling stopped");
+      }
+      async poll() {
+        if (!this.polling) return;
+        try {
+          const res = await fetch(`${this.apiUrl}/getUpdates?offset=${this.offset}&timeout=30`, {
+            signal: AbortSignal.timeout(35e3)
+          });
+          if (!res.ok) {
+            logger.warn(`Telegram getUpdates failed: ${res.status}`);
+            this.scheduleNextPoll(5e3);
+            return;
+          }
+          const data = await res.json();
+          if (data.ok && data.result.length > 0) {
+            for (const update of data.result) {
+              this.offset = update.update_id + 1;
+              if (update.message) {
+                this.handleIncomingMessage(update.message);
+              }
+            }
+          }
+        } catch (err) {
+          if (err.name !== "AbortError") {
+            logger.warn(`Telegram poll error: ${err.message}`);
+          }
+        }
+        this.scheduleNextPoll(1e3);
+      }
+      scheduleNextPoll(delay) {
+        if (!this.polling) return;
+        this.pollTimer = setTimeout(() => this.poll(), delay);
+      }
+      handleIncomingMessage(msg) {
+        if (!msg.text) return;
+        if (String(msg.chat.id) !== String(this.config.chatId)) return;
+        const text = msg.text.trim();
+        if (msg.reply_to_message) {
+          const sessionId2 = this.messageSessionMap.get(msg.reply_to_message.message_id);
+          if (sessionId2) {
+            this.deliverToSession(sessionId2, text);
+            return;
+          }
+        }
+        const selectMatch = text.match(/^\/s_(\d+)$/);
+        if (selectMatch) {
+          const pendingText = this.pendingMessages.get(msg.chat.id);
+          if (pendingText) {
+            this.pendingMessages.delete(msg.chat.id);
+            const sessions2 = this.getSessions?.() ?? [];
+            const idx = parseInt(selectMatch[1], 10) - 1;
+            if (idx >= 0 && idx < sessions2.length) {
+              this.deliverToSession(sessions2[idx].id, pendingText);
+              this.sendMessage(`Sent to [${this.getLabel(sessions2[idx])}]`);
+            } else {
+              this.sendMessage("Invalid session number.");
+            }
+            return;
+          }
+        }
+        const sessions = this.getSessions?.() ?? [];
+        if (sessions.length === 0) {
+          this.sendMessage("No active sessions connected.");
+          return;
+        }
+        if (sessions.length === 1) {
+          this.deliverToSession(sessions[0].id, text);
+          return;
+        }
+        this.pendingMessages.set(msg.chat.id, text);
+        const sessionList = sessions.map((s, i) => `/s_${i + 1} - ${this.getLabel(s)}`).join("\n");
+        this.sendMessage(`Multiple sessions active. Reply with a command to select:
+
+${sessionList}`);
+      }
+      deliverToSession(sessionId2, content) {
+        if (this.onMessageToSession) {
+          this.onMessageToSession(sessionId2, content);
+        }
+      }
+      getLabel(session) {
+        return session.cwd?.replace(/^.*[/\\]/, "") || session.name;
+      }
+      /** Update config (e.g., from dashboard settings) */
+      updateConfig(config2) {
+        const wasPolling = this.polling;
+        if (wasPolling) this.stopPolling();
+        this.config = config2;
+        if (wasPolling && config2.enabled) this.startPolling();
+      }
+    };
+  }
+});
+
 // src/hub/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -303,6 +488,7 @@ var init_server = __esm({
     init_constants();
     init_session_manager();
     init_notifier();
+    init_telegram();
     init_config();
     __dirname = path3.dirname(fileURLToPath(import.meta.url));
     HubServer = class {
@@ -318,6 +504,7 @@ var init_server = __esm({
       localChannels = /* @__PURE__ */ new Set();
       // All connected dashboard WebSockets
       dashboardSockets = /* @__PURE__ */ new Set();
+      telegramBot;
       host;
       port;
       token;
@@ -335,6 +522,10 @@ var init_server = __esm({
         }
         const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
         this.notifier.configure({ dashboardUrl: `http://${displayHost}:${this.port}` });
+        const fullConfig = loadConfig();
+        if (fullConfig.telegram?.enabled && fullConfig.telegram.botToken && fullConfig.telegram.chatId) {
+          this.initTelegram(fullConfig.telegram);
+        }
         this.httpServer = http.createServer((req, res) => this.handleHttp(req, res));
         this.wssChannel = new WebSocketServer({ noServer: true });
         this.wssChannel.on("connection", (ws, req) => this.handleChannelConnection(ws, req));
@@ -376,6 +567,7 @@ var init_server = __esm({
       }
       stop() {
         return new Promise((resolve) => {
+          if (this.telegramBot) this.telegramBot.stopPolling();
           for (const ws of this.channelSockets.values()) ws.terminate();
           for (const ws of this.dashboardSockets) ws.terminate();
           this.channelSockets.clear();
@@ -437,6 +629,16 @@ var init_server = __esm({
           this.jsonResponse(res, 200, { webhooks: config2.webhooks || [] });
         } else if (url.pathname === "/api/webhooks" && req.method === "POST") {
           this.handleWebhookSave(req, res);
+        } else if (url.pathname === "/api/telegram" && req.method === "GET") {
+          const cfg = loadConfig();
+          const tg = cfg.telegram ?? { botToken: "", chatId: "", enabled: false };
+          this.jsonResponse(res, 200, {
+            telegram: { ...tg, botToken: tg.botToken ? `${tg.botToken.slice(0, 8)}...` : "" }
+          });
+        } else if (url.pathname === "/api/telegram" && req.method === "POST") {
+          this.handleTelegramSave(req, res);
+        } else if (url.pathname === "/api/telegram/test" && req.method === "POST") {
+          this.handleTelegramTest(req, res);
         } else {
           this.jsonResponse(res, 404, { error: "Not found" });
         }
@@ -557,7 +759,7 @@ var init_server = __esm({
             this.sessions.updateActivity(msg.sessionId);
             const notifySession = this.sessions.get(msg.sessionId);
             const notifyLabel = this.getSessionLabel(notifySession);
-            this.notifier.notify(`[${notifyLabel}] ${msg.title}`, msg.message, msg.level ?? "info");
+            this.notifier.notifyWithSession(msg.sessionId, notifyLabel, `[${notifyLabel}] ${msg.title}`, msg.message, msg.level ?? "info");
             this.broadcastToDashboards({
               type: "notification",
               sessionId: msg.sessionId,
@@ -572,7 +774,7 @@ var init_server = __esm({
             this.sessions.updateActivity(msg.sessionId);
             const replySession = this.sessions.get(msg.sessionId);
             const replyLabel = this.getSessionLabel(replySession);
-            this.notifier.notify(`[${replyLabel}] Reply`, msg.content.slice(0, 200), "info");
+            this.notifier.notifyWithSession(msg.sessionId, replyLabel, `[${replyLabel}] Reply`, msg.content.slice(0, 200), "info");
             this.broadcastToDashboards({
               type: "reply_from_session",
               sessionId: msg.sessionId,
@@ -675,6 +877,75 @@ var init_server = __esm({
         this.notifier.configure({ webhooks });
         this.jsonResponse(res, 200, { ok: true });
       }
+      initTelegram(config2) {
+        this.telegramBot = new TelegramBot(config2);
+        this.telegramBot.getSessions = () => this.sessions.getAll();
+        this.telegramBot.onMessageToSession = (sessionId2, content) => {
+          const channelWs = this.channelSockets.get(sessionId2);
+          if (channelWs?.readyState === WebSocket.OPEN) {
+            const msg = { type: "message_to_session", sessionId: sessionId2, content };
+            channelWs.send(JSON.stringify(msg));
+            logger.info(`Telegram message forwarded to session: ${sessionId2}`);
+          }
+        };
+        this.notifier.configure({ telegramBot: this.telegramBot });
+        this.telegramBot.startPolling();
+        logger.info("Telegram bot initialized");
+      }
+      async handleTelegramSave(req, res) {
+        const body = await this.readBody(req);
+        if (!body) {
+          this.jsonResponse(res, 400, { error: "Invalid JSON" });
+          return;
+        }
+        const { telegram } = body;
+        if (!telegram) {
+          this.jsonResponse(res, 400, { error: "telegram config required" });
+          return;
+        }
+        const config2 = loadConfig();
+        config2.telegram = telegram;
+        saveConfig(config2);
+        if (this.telegramBot) {
+          this.telegramBot.stopPolling();
+          this.telegramBot = void 0;
+          this.notifier.configure({ telegramBot: void 0 });
+        }
+        if (telegram.enabled && telegram.botToken && telegram.chatId) {
+          this.initTelegram(telegram);
+        }
+        this.jsonResponse(res, 200, { ok: true });
+      }
+      async handleTelegramTest(req, res) {
+        const body = await this.readBody(req);
+        if (!body) {
+          this.jsonResponse(res, 400, { error: "Invalid JSON" });
+          return;
+        }
+        const { botToken, chatId } = body;
+        if (!botToken || !chatId) {
+          this.jsonResponse(res, 400, { error: "botToken and chatId required" });
+          return;
+        }
+        try {
+          const testRes = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              chat_id: chatId,
+              text: "Claude Alarm test message! Connection successful."
+            })
+          });
+          if (testRes.ok) {
+            this.jsonResponse(res, 200, { ok: true });
+          } else {
+            const err = await testRes.json();
+            this.jsonResponse(res, 400, { error: err.description || "Telegram API error" });
+          }
+        } catch (err) {
+          this.jsonResponse(res, 500, { error: err.message });
+        }
+      }
       cleanupUploads() {
         try {
           if (!fs2.existsSync(UPLOADS_DIR)) return;