@delt/claude-alarm 0.4.9 → 0.5.1

package/dist/index.d.ts

@@ -80,6 +80,12 @@ interface WebhookConfig {
     events?: string[];
     headers?: Record<string, string>;
 }
+/** Telegram bot configuration */
+interface TelegramConfig {
+    botToken: string;
+    chatId: string;
+    enabled: boolean;
+}
 /** App configuration stored in ~/.claude-alarm/config.json */
 interface AppConfig {
     hub: {
@@ -92,6 +98,7 @@ interface AppConfig {
         sound: boolean;
     };
     webhooks: WebhookConfig[];
+    telegram?: TelegramConfig;
 }
 /** Hub status response */
 interface HubStatus {
@@ -112,6 +119,7 @@ declare class HubServer {
     private channelSockets;
     private localChannels;
     private dashboardSockets;
+    private telegramBot?;
     private host;
     private port;
     private token?;
@@ -128,6 +136,9 @@ declare class HubServer {
     private broadcastToDashboards;
     private handleImageUpload;
     private handleWebhookSave;
+    private initTelegram;
+    private handleTelegramSave;
+    private handleTelegramTest;
     private cleanupUploads;
     private getSessionLabel;
     private jsonResponse;
@@ -165,17 +176,48 @@ declare class SessionManager {
     count(): number;
 }
 
+declare class TelegramBot {
+    private config;
+    private offset;
+    private polling;
+    private pollTimer;
+    private messageSessionMap;
+    onMessageToSession?: (sessionId: string, content: string) => void;
+    getSessions?: () => SessionInfo[];
+    private pendingMessages;
+    constructor(config: TelegramConfig);
+    private get apiUrl();
+    /** Send a notification message to Telegram */
+    sendNotification(sessionId: string, _sessionLabel: string, title: string, message: string): Promise<void>;
+    /** Send a text message to the configured chat */
+    private sendMessage;
+    /** Start long polling for incoming messages */
+    startPolling(): void;
+    /** Stop polling */
+    stopPolling(): void;
+    private poll;
+    private scheduleNextPoll;
+    private handleIncomingMessage;
+    private deliverToSession;
+    private getLabel;
+    /** Update config (e.g., from dashboard settings) */
+    updateConfig(config: TelegramConfig): void;
+}
+
 declare class Notifier {
     private webhooks;
     private desktopEnabled;
     private notificationSettingsOpened;
     private dashboardUrl?;
+    private telegramBot?;
     configure(options: {
         desktop?: boolean;
         webhooks?: WebhookConfig[];
         dashboardUrl?: string;
+        telegramBot?: TelegramBot;
     }): void;
     notify(title: string, message: string, level?: NotifyLevel): Promise<void>;
+    notifyWithSession(sessionId: string | undefined, sessionLabel: string | undefined, title: string, message: string, level?: NotifyLevel): Promise<void>;
     private sendDesktop;
     private checkWindowsNotifications;
     private openNotificationSettings;
@@ -213,4 +255,4 @@ declare const WS_PATH_DASHBOARD = "/ws/dashboard";
 declare const CHANNEL_SERVER_NAME = "claude-alarm";
 declare const CHANNEL_SERVER_VERSION = "0.1.0";
 
-export { type AppConfig, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION, CONFIG_DIR, CONFIG_FILE, type ChannelMessage, DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, HubClient, HubServer, type HubStatus, LOG_FILE, Notifier, type NotifyLevel, PID_FILE, type SessionInfo, SessionManager, type SessionStatus, UPLOADS_DIR, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, type WebhookConfig, loadConfig, logger, saveConfig, setupMcpConfig };
+export { type AppConfig, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION, CONFIG_DIR, CONFIG_FILE, type ChannelMessage, DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, HubClient, HubServer, type HubStatus, LOG_FILE, Notifier, type NotifyLevel, PID_FILE, type SessionInfo, SessionManager, type SessionStatus, type TelegramConfig, UPLOADS_DIR, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, type WebhookConfig, loadConfig, logger, saveConfig, setupMcpConfig };

package/dist/index.js

@@ -85,12 +85,17 @@ var Notifier = class {
   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(sessionId, sessionLabel, title, message, level = "info") {
     const promises = [];
     if (this.desktopEnabled) {
       promises.push(this.sendDesktop(title, message, level));
@@ -98,6 +103,9 @@ var Notifier = class {
     for (const webhook of this.webhooks) {
       promises.push(this.sendWebhook(webhook, title, message, level));
     }
+    if (this.telegramBot && sessionId && sessionLabel) {
+      promises.push(this.telegramBot.sendNotification(sessionId, sessionLabel, title, message));
+    }
     await Promise.allSettled(promises);
   }
   async sendDesktop(title, message, _level) {
@@ -178,6 +186,176 @@ var Notifier = class {
   }
 };
 
+// src/hub/telegram.ts
+var TELEGRAM_API = "https://api.telegram.org/bot";
+var 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(config) {
+    this.config = config;
+  }
+  get apiUrl() {
+    return `${TELEGRAM_API}${this.config.botToken}`;
+  }
+  /** Send a notification message to Telegram */
+  async sendNotification(sessionId, _sessionLabel, title, message) {
+    const text = `${title}
+${message}`;
+    const result = await this.sendMessage(text);
+    if (result?.message_id) {
+      this.messageSessionMap.set(result.message_id, sessionId);
+      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 sessionId = this.messageSessionMap.get(msg.reply_to_message.message_id);
+      if (sessionId) {
+        this.deliverToSession(sessionId, 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(sessionId, content) {
+    if (this.onMessageToSession) {
+      this.onMessageToSession(sessionId, content);
+    }
+  }
+  getLabel(session) {
+    return session.cwd?.replace(/^.*[/\\]/, "") || session.name;
+  }
+  /** Update config (e.g., from dashboard settings) */
+  updateConfig(config) {
+    const wasPolling = this.polling;
+    if (wasPolling) this.stopPolling();
+    this.config = config;
+    if (wasPolling && config.enabled) this.startPolling();
+  }
+};
+
 // src/shared/config.ts
 import fs from "fs";
 import path2 from "path";
@@ -207,7 +385,7 @@ function loadConfig() {
     try {
       const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
       const parsed = JSON.parse(raw);
-      config = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub } };
+      config = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub }, ...parsed.telegram ? { telegram: parsed.telegram } : {} };
     } catch {
       config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
     }
@@ -262,6 +440,7 @@ var HubServer = class {
   localChannels = /* @__PURE__ */ new Set();
   // All connected dashboard WebSockets
   dashboardSockets = /* @__PURE__ */ new Set();
+  telegramBot;
   host;
   port;
   token;
@@ -279,6 +458,10 @@ var HubServer = class {
     }
     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));
@@ -320,6 +503,7 @@ var HubServer = class {
   }
   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();
@@ -381,6 +565,16 @@ var HubServer = class {
       this.jsonResponse(res, 200, { webhooks: config.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" });
     }
@@ -501,7 +695,7 @@ var HubServer = class {
         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,
@@ -516,7 +710,7 @@ var HubServer = class {
         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,
@@ -619,6 +813,75 @@ var HubServer = class {
     this.notifier.configure({ webhooks });
     this.jsonResponse(res, 200, { ok: true });
   }
+  initTelegram(config) {
+    this.telegramBot = new TelegramBot(config);
+    this.telegramBot.getSessions = () => this.sessions.getAll();
+    this.telegramBot.onMessageToSession = (sessionId, content) => {
+      const channelWs = this.channelSockets.get(sessionId);
+      if (channelWs?.readyState === WebSocket.OPEN) {
+        const msg = { type: "message_to_session", sessionId, content };
+        channelWs.send(JSON.stringify(msg));
+        logger.info(`Telegram message forwarded to session: ${sessionId}`);
+      }
+    };
+    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 config = loadConfig();
+    config.telegram = telegram;
+    saveConfig(config);
+    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;