@delt/claude-alarm 0.5.2 → 0.5.4

package/dist/cli.js

@@ -293,11 +293,15 @@ var init_notifier = __esm({
 });
 
 // src/hub/telegram.ts
+import fs2 from "fs";
+import path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 var TELEGRAM_API, TelegramBot;
 var init_telegram = __esm({
   "src/hub/telegram.ts"() {
     "use strict";
     init_logger();
+    init_constants();
     TELEGRAM_API = "https://api.telegram.org/bot";
     TelegramBot = class {
       config;
@@ -306,13 +310,15 @@ var init_telegram = __esm({
       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(config2) {
         this.config = config2;
       }
@@ -408,31 +414,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 sessionId2 = this.messageSessionMap.get(msg.reply_to_message.message_id);
           if (sessionId2) {
-            this.deliverToSession(sessionId2, text);
+            if (hasPhoto) {
+              await this.deliverPhotoToSession(sessionId2, msg.photo, text);
+            } else {
+              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.");
+        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?.() ?? [];
@@ -441,10 +458,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:
 
@@ -455,6 +481,46 @@ ${sessionList}`);
           this.onMessageToSession(sessionId2, content);
         }
       }
+      async deliverPhotoToSession(sessionId2, photos, caption) {
+        const largest = photos[photos.length - 1];
+        await this.deliverPhotoToSessionByFileId(sessionId2, largest.file_id, caption);
+      }
+      async deliverPhotoToSessionByFileId(sessionId2, 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";
+          fs2.mkdirSync(UPLOADS_DIR, { recursive: true });
+          const filename = `${randomUUID2()}.${ext}`;
+          const filePath = path3.join(UPLOADS_DIR, filename);
+          fs2.writeFileSync(filePath, buffer);
+          logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
+          if (this.onImageToSession) {
+            this.onImageToSession(sessionId2, filePath, mimeType, caption);
+          }
+          setTimeout(() => {
+            try {
+              fs2.unlinkSync(filePath);
+            } catch {
+            }
+          }, 5 * 60 * 1e3);
+        } catch (err) {
+          logger.warn(`Telegram photo download failed: ${err.message}`);
+        }
+      }
       getLabel(session) {
         return session.cwd?.replace(/^.*[/\\]/, "") || session.name;
       }
@@ -475,11 +541,11 @@ __export(server_exports, {
   HubServer: () => HubServer
 });
 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";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var __dirname, HubServer;
 var init_server = __esm({
   "src/hub/server.ts"() {
@@ -490,7 +556,7 @@ var init_server = __esm({
     init_notifier();
     init_telegram();
     init_config();
-    __dirname = path3.dirname(fileURLToPath(import.meta.url));
+    __dirname = path4.dirname(fileURLToPath(import.meta.url));
     HubServer = class {
       httpServer;
       wssChannel;
@@ -639,29 +705,31 @@ var init_server = __esm({
           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;
@@ -839,11 +907,11 @@ var init_server = __esm({
           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: sessionId2,
@@ -856,7 +924,7 @@ var init_server = __esm({
         logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
         setTimeout(() => {
           try {
-            fs2.unlinkSync(filePath);
+            fs3.unlinkSync(filePath);
           } catch {
           }
         }, 5 * 60 * 1e3);
@@ -889,6 +957,14 @@ var init_server = __esm({
             logger.info(`Telegram message forwarded to session: ${sessionId2}`);
           }
         };
+        this.telegramBot.onImageToSession = (sessionId2, imagePath, mimeType, caption) => {
+          const channelWs = this.channelSockets.get(sessionId2);
+          if (channelWs?.readyState === WebSocket.OPEN) {
+            const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption };
+            channelWs.send(JSON.stringify(msg));
+            logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
+          }
+        };
         this.notifier.configure({ telegramBot: this.telegramBot });
         this.telegramBot.startPolling();
         logger.info("Telegram bot initialized");
@@ -947,13 +1023,57 @@ var init_server = __esm({
           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 {
             }
           }
@@ -1126,8 +1246,8 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { randomUUID as randomUUID3 } from "crypto";
-import path4 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import path5 from "path";
 async function main() {
   logger.info(`Starting MCP channel server (session: ${sessionId})`);
   hubClient.connect();
@@ -1166,8 +1286,8 @@ var init_server2 = __esm({
     init_constants();
     init_config();
     init_hub_client();
-    sessionId = randomUUID3();
-    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path4.basename(process.cwd());
+    sessionId = randomUUID4();
+    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path5.basename(process.cwd());
     server = new Server(
       {
         name: CHANNEL_SERVER_NAME,
@@ -1301,11 +1421,11 @@ init_config();
 init_constants();
 init_logger();
 import { spawn } from "child_process";
-import fs3 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path6 from "path";
 import readline from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
 function printUsage() {
   console.log(`
 claude-alarm - Monitor Claude Code sessions with notifications
@@ -1326,8 +1446,8 @@ Quick start:
 }
 async function checkForUpdates() {
   try {
-    const pkgPath = path5.join(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path6.join(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
     const currentVersion = pkg.version;
     const res = await fetch("https://registry.npmjs.org/@delt/claude-alarm/latest", {
       signal: AbortSignal.timeout(3e3)
@@ -1350,25 +1470,25 @@ async function hubStart(daemon) {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   checkForUpdates();
-  if (fs3.existsSync(PID_FILE)) {
-    const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs4.existsSync(PID_FILE)) {
+    const pid = parseInt(fs4.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       console.log(`Hub is already running (PID: ${pid}) on http://${displayHost}:${port}`);
       return;
     }
-    fs3.unlinkSync(PID_FILE);
+    fs4.unlinkSync(PID_FILE);
   }
   if (daemon) {
     ensureConfigDir();
-    const logFd = fs3.openSync(LOG_FILE, "a");
-    const hubScript = path5.join(__dirname2, "hub", "server.js");
+    const logFd = fs4.openSync(LOG_FILE, "a");
+    const hubScript = path6.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");
+      fs4.writeFileSync(PID_FILE, String(child.pid), "utf-8");
       child.unref();
       console.log(`Hub started as daemon (PID: ${child.pid})`);
       console.log(`Dashboard: http://${displayHost}:${port}`);
@@ -1385,11 +1505,11 @@ async function hubStart(daemon) {
     const hub = new HubServer2(config2);
     await hub.start();
     ensureConfigDir();
-    fs3.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    fs4.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);
+      if (fs4.existsSync(PID_FILE)) fs4.unlinkSync(PID_FILE);
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -1397,18 +1517,18 @@ async function hubStart(daemon) {
   }
 }
 function hubStop() {
-  if (!fs3.existsSync(PID_FILE)) {
+  if (!fs4.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);
+  const pid = parseInt(fs4.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);
+  fs4.unlinkSync(PID_FILE);
 }
 async function hubStatus() {
   const config2 = loadConfig();
@@ -1416,8 +1536,8 @@ async function hubStatus() {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   let pidInfo = "not running";
-  if (fs3.existsSync(PID_FILE)) {
-    const pid = parseInt(fs3.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs4.existsSync(PID_FILE)) {
+    const pid = parseInt(fs4.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       pidInfo = `running (PID: ${pid})`;
     } else {
@@ -1489,7 +1609,7 @@ function ask(question) {
 }
 async function init() {
   const dir = process.cwd();
-  const projectName = path5.basename(dir);
+  const projectName = path6.basename(dir);
   console.log(`
 claude-alarm init for "${projectName}"
 `);
@@ -1509,11 +1629,11 @@ claude-alarm init for "${projectName}"
     if (port) env.CLAUDE_ALARM_HUB_PORT = port;
     if (token) env.CLAUDE_ALARM_HUB_TOKEN = token;
   }
-  const mcpPath = path5.join(dir, ".mcp.json");
+  const mcpPath = path6.join(dir, ".mcp.json");
   let mcpConfig = {};
-  if (fs3.existsSync(mcpPath)) {
+  if (fs4.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs3.readFileSync(mcpPath, "utf-8"));
+      mcpConfig = JSON.parse(fs4.readFileSync(mcpPath, "utf-8"));
     } catch {
       mcpConfig = {};
     }
@@ -1524,7 +1644,7 @@ claude-alarm init for "${projectName}"
     args: ["-y", "@delt/claude-alarm", "serve"],
     env
   };
-  fs3.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  fs4.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(`
 \u2713 Created ${mcpPath}`);
   if (remote.toLowerCase() !== "y") {