@delt/claude-alarm 0.5.2 → 0.5.4

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/hub/server.ts
 import http from "http";
-import fs2 from "fs";
-import path3 from "path";
+import fs3 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -24,7 +24,7 @@ var logger = {
 };
 
 // src/hub/server.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/shared/constants.ts
 import path from "path";
@@ -187,6 +187,9 @@ var Notifier = class {
 };
 
 // src/hub/telegram.ts
+import fs from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
 var TELEGRAM_API = "https://api.telegram.org/bot";
 var TelegramBot = class {
   config;
@@ -195,13 +198,15 @@ var TelegramBot = class {
   pollTimer = null;
   // message_id -> sessionId mapping for reply-based routing
   messageSessionMap = /* @__PURE__ */ new Map();
-  // Callback: when a message arrives from Telegram for a session
+  // Callback: when a text message arrives from Telegram for a session
   onMessageToSession;
+  // Callback: when an image arrives from Telegram for a session
+  onImageToSession;
   // Callback: get current sessions list
   getSessions;
-  // Callback: when user needs to select a session (sends inline keyboard)
+  // Pending messages for session selection
   pendingMessages = /* @__PURE__ */ new Map();
-  // chatId -> pending message text
+  // chatId -> pending
   constructor(config) {
     this.config = config;
   }
@@ -297,31 +302,42 @@ ${message}`;
     if (!this.polling) return;
     this.pollTimer = setTimeout(() => this.poll(), delay);
   }
-  handleIncomingMessage(msg) {
-    if (!msg.text) return;
+  async handleIncomingMessage(msg) {
     if (String(msg.chat.id) !== String(this.config.chatId)) return;
-    const text = msg.text.trim();
+    const hasPhoto = msg.photo && msg.photo.length > 0;
+    const text = (msg.text || msg.caption || "").trim();
+    if (!text && !hasPhoto) return;
     if (msg.reply_to_message) {
       const sessionId = this.messageSessionMap.get(msg.reply_to_message.message_id);
       if (sessionId) {
-        this.deliverToSession(sessionId, text);
+        if (hasPhoto) {
+          await this.deliverPhotoToSession(sessionId, msg.photo, text);
+        } else {
+          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.");
+    if (text) {
+      const selectMatch = text.match(/^\/s_(\d+)$/);
+      if (selectMatch) {
+        const pending = this.pendingMessages.get(msg.chat.id);
+        if (pending) {
+          this.pendingMessages.delete(msg.chat.id);
+          const sessions2 = this.getSessions?.() ?? [];
+          const idx = parseInt(selectMatch[1], 10) - 1;
+          if (idx >= 0 && idx < sessions2.length) {
+            if (pending.photoFileId) {
+              await this.deliverPhotoToSessionByFileId(sessions2[idx].id, pending.photoFileId, pending.caption);
+            } else if (pending.text) {
+              this.deliverToSession(sessions2[idx].id, pending.text);
+            }
+            this.sendMessage(`Sent to [${this.getLabel(sessions2[idx])}]`);
+          } else {
+            this.sendMessage("Invalid session number.");
+          }
+          return;
         }
-        return;
       }
     }
     const sessions = this.getSessions?.() ?? [];
@@ -330,10 +346,19 @@ ${message}`;
       return;
     }
     if (sessions.length === 1) {
-      this.deliverToSession(sessions[0].id, text);
+      if (hasPhoto) {
+        await this.deliverPhotoToSession(sessions[0].id, msg.photo, text);
+      } else {
+        this.deliverToSession(sessions[0].id, text);
+      }
       return;
     }
-    this.pendingMessages.set(msg.chat.id, text);
+    if (hasPhoto) {
+      const largest = msg.photo[msg.photo.length - 1];
+      this.pendingMessages.set(msg.chat.id, { photoFileId: largest.file_id, caption: text });
+    } else {
+      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:
 
@@ -344,6 +369,46 @@ ${sessionList}`);
       this.onMessageToSession(sessionId, content);
     }
   }
+  async deliverPhotoToSession(sessionId, photos, caption) {
+    const largest = photos[photos.length - 1];
+    await this.deliverPhotoToSessionByFileId(sessionId, largest.file_id, caption);
+  }
+  async deliverPhotoToSessionByFileId(sessionId, fileId, caption) {
+    try {
+      const fileRes = await fetch(`${this.apiUrl}/getFile?file_id=${fileId}`);
+      if (!fileRes.ok) {
+        logger.warn("Failed to get Telegram file info");
+        return;
+      }
+      const fileData = await fileRes.json();
+      if (!fileData.ok) return;
+      const downloadUrl = `https://api.telegram.org/file/bot${this.config.botToken}/${fileData.result.file_path}`;
+      const imgRes = await fetch(downloadUrl);
+      if (!imgRes.ok) {
+        logger.warn("Failed to download Telegram photo");
+        return;
+      }
+      const buffer = Buffer.from(await imgRes.arrayBuffer());
+      const ext = fileData.result.file_path.split(".").pop() || "jpg";
+      const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : "image/jpeg";
+      fs.mkdirSync(UPLOADS_DIR, { recursive: true });
+      const filename = `${randomUUID()}.${ext}`;
+      const filePath = path2.join(UPLOADS_DIR, filename);
+      fs.writeFileSync(filePath, buffer);
+      logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
+      if (this.onImageToSession) {
+        this.onImageToSession(sessionId, filePath, mimeType, caption);
+      }
+      setTimeout(() => {
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+        }
+      }, 5 * 60 * 1e3);
+    } catch (err) {
+      logger.warn(`Telegram photo download failed: ${err.message}`);
+    }
+  }
   getLabel(session) {
     return session.cwd?.replace(/^.*[/\\]/, "") || session.name;
   }
@@ -357,9 +422,9 @@ ${sessionList}`);
 };
 
 // src/shared/config.ts
-import fs from "fs";
-import path2 from "path";
-import { randomUUID } from "crypto";
+import fs2 from "fs";
+import path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 var DEFAULT_CONFIG = {
   hub: {
     host: DEFAULT_HUB_HOST,
@@ -372,18 +437,18 @@ var DEFAULT_CONFIG = {
   webhooks: []
 };
 function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs2.existsSync(CONFIG_DIR)) {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
   ensureConfigDir();
   let config;
-  if (!fs.existsSync(CONFIG_FILE)) {
+  if (!fs2.existsSync(CONFIG_FILE)) {
     config = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
   } else {
     try {
-      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+      const raw = fs2.readFileSync(CONFIG_FILE, "utf-8");
       const parsed = JSON.parse(raw);
       config = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub }, ...parsed.telegram ? { telegram: parsed.telegram } : {} };
     } catch {
@@ -391,22 +456,22 @@ function loadConfig() {
     }
   }
   if (!config.hub.token) {
-    config.hub.token = randomUUID();
+    config.hub.token = randomUUID2();
     saveConfig(config);
   }
   return config;
 }
 function saveConfig(config) {
   ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  fs2.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");
+  const mcpPath = path3.join(dir, ".mcp.json");
   let mcpConfig = {};
-  if (fs.existsSync(mcpPath)) {
+  if (fs2.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+      mcpConfig = JSON.parse(fs2.readFileSync(mcpPath, "utf-8"));
     } catch {
       mcpConfig = {};
     }
@@ -418,15 +483,15 @@ function setupMcpConfig(targetDir) {
     command: "npx",
     args: ["-y", "@delt/claude-alarm", "serve"],
     env: {
-      CLAUDE_ALARM_SESSION_NAME: path2.basename(dir)
+      CLAUDE_ALARM_SESSION_NAME: path3.basename(dir)
     }
   };
-  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  fs2.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   return mcpPath;
 }
 
 // src/hub/server.ts
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
 var HubServer = class {
   httpServer;
   wssChannel;
@@ -575,29 +640,31 @@ var HubServer = class {
       this.handleTelegramSave(req, res);
     } else if (url.pathname === "/api/telegram/test" && req.method === "POST") {
       this.handleTelegramTest(req, res);
+    } else if (url.pathname === "/api/telegram/detect" && req.method === "POST") {
+      this.handleTelegramDetect(req, res);
     } else {
       this.jsonResponse(res, 404, { error: "Not found" });
     }
   }
   serveDashboard(res) {
     const candidates = [
-      path3.join(__dirname, "..", "dashboard", "index.html"),
+      path4.join(__dirname, "..", "dashboard", "index.html"),
       // from dist/hub/
-      path3.join(__dirname, "dashboard", "index.html"),
+      path4.join(__dirname, "dashboard", "index.html"),
       // from dist/ (bundled index.js)
-      path3.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+      path4.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
       // from dist/hub/ -> src/
-      path3.join(__dirname, "..", "src", "dashboard", "index.html"),
+      path4.join(__dirname, "..", "src", "dashboard", "index.html"),
       // from dist/ -> src/
-      path3.join(process.cwd(), "dist", "dashboard", "index.html"),
+      path4.join(process.cwd(), "dist", "dashboard", "index.html"),
       // from cwd
-      path3.join(process.cwd(), "src", "dashboard", "index.html")
+      path4.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");
+      if (fs3.existsSync(candidate)) {
+        const html = fs3.readFileSync(candidate, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return;
@@ -775,11 +842,11 @@ var HubServer = class {
       logger.warn("Image upload rejected: exceeds 10MB");
       return;
     }
-    fs2.mkdirSync(UPLOADS_DIR, { recursive: true });
+    fs3.mkdirSync(UPLOADS_DIR, { recursive: true });
     const ext = mimeType.split("/")[1] === "jpeg" ? "jpg" : mimeType.split("/")[1];
-    const filename = `${randomUUID2()}.${ext}`;
-    const filePath = path3.join(UPLOADS_DIR, filename);
-    fs2.writeFileSync(filePath, buffer);
+    const filename = `${randomUUID3()}.${ext}`;
+    const filePath = path4.join(UPLOADS_DIR, filename);
+    fs3.writeFileSync(filePath, buffer);
     const forwardMsg = {
       type: "image_to_session",
       sessionId,
@@ -792,7 +859,7 @@ var HubServer = class {
     logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
     setTimeout(() => {
       try {
-        fs2.unlinkSync(filePath);
+        fs3.unlinkSync(filePath);
       } catch {
       }
     }, 5 * 60 * 1e3);
@@ -825,6 +892,14 @@ var HubServer = class {
         logger.info(`Telegram message forwarded to session: ${sessionId}`);
       }
     };
+    this.telegramBot.onImageToSession = (sessionId, imagePath, mimeType, caption) => {
+      const channelWs = this.channelSockets.get(sessionId);
+      if (channelWs?.readyState === WebSocket.OPEN) {
+        const msg = { type: "image_to_session", sessionId, imagePath, mimeType, content: caption };
+        channelWs.send(JSON.stringify(msg));
+        logger.info(`Telegram photo forwarded to session: ${sessionId}`);
+      }
+    };
     this.notifier.configure({ telegramBot: this.telegramBot });
     this.telegramBot.startPolling();
     logger.info("Telegram bot initialized");
@@ -883,13 +958,57 @@ var HubServer = class {
       this.jsonResponse(res, 500, { error: err.message });
     }
   }
+  async handleTelegramDetect(req, res) {
+    const body = await this.readBody(req);
+    if (!body) {
+      this.jsonResponse(res, 400, { error: "Invalid JSON" });
+      return;
+    }
+    const { botToken } = body;
+    if (!botToken) {
+      this.jsonResponse(res, 400, { error: "botToken required" });
+      return;
+    }
+    try {
+      const detectRes = await fetch(`https://api.telegram.org/bot${botToken}/getUpdates?timeout=0&limit=10`, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!detectRes.ok) {
+        const err = await detectRes.json();
+        this.jsonResponse(res, 400, { error: err.description || "Invalid bot token" });
+        return;
+      }
+      const data = await detectRes.json();
+      if (!data.ok || !data.result.length) {
+        this.jsonResponse(res, 200, { ok: false, chats: [] });
+        return;
+      }
+      const chatMap = /* @__PURE__ */ new Map();
+      for (const update of data.result) {
+        if (update.message?.chat) {
+          const chat = update.message.chat;
+          const id = String(chat.id);
+          if (!chatMap.has(id)) {
+            chatMap.set(id, {
+              id,
+              name: chat.title || chat.first_name || id,
+              type: chat.type
+            });
+          }
+        }
+      }
+      this.jsonResponse(res, 200, { ok: true, chats: [...chatMap.values()] });
+    } catch (err) {
+      this.jsonResponse(res, 500, { error: err.message });
+    }
+  }
   cleanupUploads() {
     try {
-      if (!fs2.existsSync(UPLOADS_DIR)) return;
-      const files = fs2.readdirSync(UPLOADS_DIR);
+      if (!fs3.existsSync(UPLOADS_DIR)) return;
+      const files = fs3.readdirSync(UPLOADS_DIR);
       for (const file of files) {
         try {
-          fs2.unlinkSync(path3.join(UPLOADS_DIR, file));
+          fs3.unlinkSync(path4.join(UPLOADS_DIR, file));
         } catch {
         }
       }