@delt/claude-alarm 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -49,6 +49,7 @@ type ChannelMessage = {
     title: string;
     message: string;
     level?: NotifyLevel;
+    to?: MessageSource;
 } | {
     type: 'reply';
     sessionId: string;
@@ -73,6 +74,15 @@ type ChannelMessage = {
     originalName?: string;
     content?: string;
     source?: MessageSource;
+} | {
+    type: 'upload_rejected';
+    sessionId: string;
+    reason: string;
+    withText: boolean;
+} | {
+    type: 'message_rejected';
+    sessionId: string;
+    reason: string;
 } | {
     type: 'sessions_list';
     sessions: SessionInfo[];
@@ -316,18 +326,20 @@ declare class TelegramBot {
     private polling;
     private pollTimer;
     private messageSessionMap;
-    onMessageToSession?: (sessionId: string, content: string) => void;
-    onImageToSession?: (sessionId: string, imagePath: string, mimeType: string, caption?: string) => void;
+    onMessageToSession?: (sessionId: string, content: string) => boolean;
+    onImageToSession?: (sessionId: string, imagePath: string, mimeType: string, caption?: string) => boolean;
     onPermissionVerdict?: (sessionId: string, requestId: string, behavior: 'allow' | 'deny') => void;
     onChoiceVerdict?: (sessionId: string, requestId: string, choiceId: string) => void;
     private choiceTokens;
     private choiceMessages;
     getSessions?: () => SessionInfo[];
-    private pendingMessages;
+    private latestSelection;
+    private selections;
     constructor(config: TelegramConfig);
     private get apiUrl();
     /** Send a notification message to Telegram */
     sendNotification(sessionId: string, _sessionLabel: string, title: string, message: string): Promise<void>;
+    private fitNotification;
     /** Send a text message to the configured chat */
     private sendMessage;
     /** Start long polling for incoming messages */
@@ -338,8 +350,10 @@ declare class TelegramBot {
     private scheduleNextPoll;
     private handleIncomingMessage;
     private deliverToSession;
+    private deliverPending;
     private deliverPhotoToSession;
     private deliverPhotoToSessionByFileId;
+    private photoNotDelivered;
     private pendingSession;
     private getLabel;
     /** Send a permission request with inline buttons */
@@ -352,6 +366,8 @@ declare class TelegramBot {
     private handleCallbackQuery;
     private handleSessionSelectCallback;
     private answerCallbackQuery;
+    private expire;
+    private removeButtons;
     private editMessageText;
     private escHtml;
     private static readonly LANG_BY_EXT;

package/dist/index.js

@@ -245,6 +245,14 @@ ${requestId}`;
 // src/hub/telegram.ts
 var TELEGRAM_API = "https://api.telegram.org/bot";
 var MAX_CHOICE_MESSAGES = 200;
+var MAX_SELECTIONS = 20;
+var MAX_VISIBLE_CHARS = 4e3;
+var TRUNCATED = "\u2026(truncated)";
+var MAX_PHOTO_BYTES = 10 * 1024 * 1024;
+var NO_LONGER_CONNECTED = "the session is no longer connected";
+function visibleLength(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/&(?:amp|lt|gt);/g, "&").length;
+}
 var TelegramBot = class _TelegramBot {
   config;
   offset = 0;
@@ -265,9 +273,9 @@ var TelegramBot = class _TelegramBot {
   choiceMessages = /* @__PURE__ */ new Map();
   // Callback: get current sessions list
   getSessions;
-  // Pending messages for session selection
-  pendingMessages = /* @__PURE__ */ new Map();
-  // chatId -> pending
+  latestSelection;
+  // Keyed by prompt, not by chat: buttons from an older prompt must still send that prompt's message.
+  selections = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = config;
   }
@@ -276,8 +284,7 @@ var TelegramBot = class _TelegramBot {
   }
   /** Send a notification message to Telegram */
   async sendNotification(sessionId, _sessionLabel, title, message) {
-    const text = `<b>${this.escHtml(title)}</b>
-${this.mdToHtml(message)}`;
+    const text = this.fitNotification(title, message);
     const result = await this.sendMessage(text);
     if (result?.message_id) {
       this.messageSessionMap.set(result.message_id, sessionId);
@@ -289,6 +296,25 @@ ${this.mdToHtml(message)}`;
       }
     }
   }
+  fitNotification(title, message) {
+    const render = (body) => `<b>${this.escHtml(title)}</b>
+${this.mdToHtml(body)}`;
+    const full = render(message);
+    if (visibleLength(full) <= MAX_VISIBLE_CHARS) return full;
+    const cut = (n) => {
+      const end = n > 0 && /[\uD800-\uDBFF]/.test(message[n - 1]) ? n - 1 : n;
+      return render(`${message.slice(0, end)}
+${TRUNCATED}`);
+    };
+    let lo = 0;
+    let hi = message.length;
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (visibleLength(cut(mid)) <= MAX_VISIBLE_CHARS) lo = mid;
+      else hi = mid - 1;
+    }
+    return cut(lo);
+  }
   /** Send a text message to the configured chat */
   async sendMessage(text, replyToMessageId, replyMarkup) {
     try {
@@ -370,6 +396,13 @@ ${this.mdToHtml(message)}`;
     const hasPhoto = msg.photo && msg.photo.length > 0;
     const text = (msg.text || msg.caption || "").trim();
     if (!text && !hasPhoto) return;
+    if (hasPhoto) {
+      const size = msg.photo[msg.photo.length - 1].file_size;
+      if (size !== void 0 && size > MAX_PHOTO_BYTES) {
+        this.photoNotDelivered("it is larger than 10 MB");
+        return;
+      }
+    }
     if (msg.reply_to_message) {
       const sessionId = this.messageSessionMap.get(msg.reply_to_message.message_id);
       if (sessionId) {
@@ -383,18 +416,14 @@ ${this.mdToHtml(message)}`;
     }
     if (text) {
       const selectMatch = text.match(/^\/s_(\d+)$/);
-      if (selectMatch) {
-        const pending = this.pendingMessages.get(msg.chat.id);
+      const latest = this.latestSelection;
+      if (selectMatch && latest !== void 0) {
+        const pending = this.selections.get(latest);
         if (pending) {
-          this.pendingMessages.delete(msg.chat.id);
+          this.selections.delete(latest);
           const session = this.pendingSession(pending, parseInt(selectMatch[1], 10) - 1);
           if (session) {
-            if (pending.photoFileId) {
-              await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
-            } else if (pending.text) {
-              this.deliverToSession(session.id, pending.text);
-            }
-            this.sendMessage(`Sent to [${this.getLabel(session)}]`);
+            if (await this.deliverPending(session.id, pending)) this.sendMessage(`Sent to [${this.getLabel(session)}]`);
           } else {
             this.sendMessage("Invalid session number.");
           }
@@ -415,16 +444,19 @@ ${this.mdToHtml(message)}`;
       }
       return;
     }
+    const selectionId = randomUUID().replace(/-/g, "").slice(0, 8);
+    this.latestSelection = selectionId;
     const sessionIds = sessions.map((s) => s.id);
     if (hasPhoto) {
       const largest = msg.photo[msg.photo.length - 1];
-      this.pendingMessages.set(msg.chat.id, { photoFileId: largest.file_id, caption: text, sessionIds });
+      this.selections.set(selectionId, { photoFileId: largest.file_id, caption: text, sessionIds });
     } else {
-      this.pendingMessages.set(msg.chat.id, { text, sessionIds });
+      this.selections.set(selectionId, { text, sessionIds });
     }
+    while (this.selections.size > MAX_SELECTIONS) this.selections.delete(this.selections.keys().next().value);
     const buttons = sessions.map((s, i) => ({
       text: this.getLabel(s),
-      callback_data: `sess:${i}:${msg.chat.id}`
+      callback_data: `sel:${selectionId}:${i}`
     }));
     const rows = [];
     for (let i = 0; i < buttons.length; i += 2) {
@@ -433,30 +465,37 @@ ${this.mdToHtml(message)}`;
     this.sendMessage("Multiple sessions active. Select one:", void 0, { inline_keyboard: rows });
   }
   deliverToSession(sessionId, content) {
-    if (this.onMessageToSession) {
-      this.onMessageToSession(sessionId, content);
-    }
+    const delivered = this.onMessageToSession?.(sessionId, content) === true;
+    if (!delivered) void this.sendMessage(`Not delivered: ${NO_LONGER_CONNECTED}`);
+    return delivered;
+  }
+  async deliverPending(sessionId, pending) {
+    if (pending.photoFileId) return this.deliverPhotoToSessionByFileId(sessionId, pending.photoFileId, pending.caption);
+    return pending.text ? this.deliverToSession(sessionId, pending.text) : false;
   }
   async deliverPhotoToSession(sessionId, photos, caption) {
     const largest = photos[photos.length - 1];
-    await this.deliverPhotoToSessionByFileId(sessionId, largest.file_id, caption);
+    return 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 = fileRes.ok ? await fileRes.json() : void 0;
+      if (!fileData?.ok || !fileData.result) {
+        this.photoNotDelivered("Telegram did not return the file");
+        return false;
       }
-      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;
+        this.photoNotDelivered("the download failed");
+        return false;
       }
       const buffer = Buffer.from(await imgRes.arrayBuffer());
+      if (buffer.length > MAX_PHOTO_BYTES) {
+        this.photoNotDelivered("it is larger than 10 MB");
+        return false;
+      }
       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 });
@@ -464,19 +503,37 @@ ${this.mdToHtml(message)}`;
       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);
+      let accepted = false;
+      try {
+        accepted = this.onImageToSession?.(sessionId, filePath, mimeType, caption) === true;
+      } catch (err) {
+        logger.warn(`Telegram photo hand-off failed: ${err.message}`);
+      }
+      if (!accepted) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+        }
+        this.photoNotDelivered(NO_LONGER_CONNECTED);
+        return false;
       }
       setTimeout(() => {
         try {
           fs.unlinkSync(filePath);
         } catch {
         }
-      }, 5 * 60 * 1e3);
+      }, 5 * 60 * 1e3).unref();
+      return true;
     } catch (err) {
       logger.warn(`Telegram photo download failed: ${err.message}`);
+      this.photoNotDelivered("the download failed");
+      return false;
     }
   }
+  photoNotDelivered(reason) {
+    logger.warn(`Telegram photo not delivered: ${reason}`);
+    void this.sendMessage(`Photo not delivered: ${reason}`);
+  }
   // Buttons are numbered against the list shown when they were sent; Codex sessions come and go, so the live list may have shifted.
   pendingSession(pending, idx) {
     const id = pending.sessionIds[idx];
@@ -590,7 +647,7 @@ ${this.escHtml(description)}` : "") + (slice ? `
   async handleChoiceCallback(query) {
     const choice = this.choiceTokens.get(query.data.slice("pc:".length));
     if (!choice) {
-      await this.answerCallbackQuery(query.id, "Expired");
+      await this.expire(query);
       return;
     }
     this.dropChoiceTokens(choice.sessionId, choice.requestId);
@@ -619,10 +676,14 @@ ${this.escHtml(description)}` : "") + (slice ? `
   async handleCallbackQuery(query) {
     if (!query.data) return;
     if (String(query.message?.chat.id) !== String(this.config.chatId)) return;
-    if (query.data.startsWith("sess:")) {
+    if (query.data.startsWith("sel:")) {
       await this.handleSessionSelectCallback(query);
       return;
     }
+    if (query.data.startsWith("sess:")) {
+      await this.expire(query);
+      return;
+    }
     if (query.data.startsWith("pc:")) {
       await this.handleChoiceCallback(query);
       return;
@@ -645,21 +706,22 @@ ${label}`);
     }
   }
   async handleSessionSelectCallback(query) {
-    const parts = query.data.split(":");
-    if (parts.length < 3) return;
-    const [, idxStr, chatIdStr] = parts;
-    const chatId = parseInt(chatIdStr, 10);
-    const pending = this.pendingMessages.get(chatId);
-    const session = pending ? this.pendingSession(pending, parseInt(idxStr, 10)) : void 0;
-    if (!pending || !session) {
+    const [, selectionId, idxStr] = query.data.split(":");
+    const pending = this.selections.get(selectionId);
+    if (!pending) {
+      await this.expire(query);
+      return;
+    }
+    const session = this.pendingSession(pending, parseInt(idxStr, 10));
+    if (!session) {
       await this.answerCallbackQuery(query.id, "Session not found");
       return;
     }
-    this.pendingMessages.delete(chatId);
-    if (pending.photoFileId) {
-      await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
-    } else if (pending.text) {
-      this.deliverToSession(session.id, pending.text);
+    this.selections.delete(selectionId);
+    if (!await this.deliverPending(session.id, pending)) {
+      await this.answerCallbackQuery(query.id, pending.photoFileId ? "Photo not delivered" : "Not delivered");
+      if (query.message) await this.removeButtons(query.message.chat.id, query.message.message_id);
+      return;
     }
     await this.answerCallbackQuery(query.id, `Sent to ${this.getLabel(session)}`);
     if (query.message) {
@@ -677,6 +739,21 @@ ${label}`);
       logger.warn(`Telegram answerCallbackQuery error: ${err.message}`);
     }
   }
+  async expire(query) {
+    await this.answerCallbackQuery(query.id, "Expired");
+    if (query.message) await this.removeButtons(query.message.chat.id, query.message.message_id);
+  }
+  async removeButtons(chatId, messageId) {
+    try {
+      await fetch(`${this.apiUrl}/editMessageReplyMarkup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId, message_id: messageId, reply_markup: { inline_keyboard: [] } })
+      });
+    } catch (err) {
+      logger.warn(`Telegram editMessageReplyMarkup error: ${err.message}`);
+    }
+  }
   async editMessageText(chatId, messageId, text) {
     try {
       await fetch(`${this.apiUrl}/editMessageText`, {
@@ -773,19 +850,30 @@ var HEALTHY_RUN_MS = 6e4;
 function resolveAdapterScript(baseDir) {
   return [path3.join(baseDir, "..", "codex", "main.js"), path3.join(baseDir, "codex", "main.js")].find((p) => fs2.existsSync(p));
 }
+function adapterEnv(base, hub) {
+  const env = { ...base, CLAUDE_ALARM_HUB_HOST: hub.host, CLAUDE_ALARM_HUB_PORT: String(hub.port) };
+  delete env.CLAUDE_ALARM_HUB_TOKEN;
+  return env;
+}
 var CodexSupervisor = class {
-  constructor(script, spawnFn = spawn, minDelayMs = 2e3, maxDelayMs = 6e4, stopGraceMs = 3e3) {
+  constructor(script, opts = {}) {
     this.script = script;
-    this.spawnFn = spawnFn;
-    this.minDelayMs = minDelayMs;
-    this.maxDelayMs = maxDelayMs;
-    this.stopGraceMs = stopGraceMs;
-    this.delay = minDelayMs;
+    this.spawnFn = opts.spawnFn ?? spawn;
+    this.minDelayMs = opts.minDelayMs ?? 2e3;
+    this.maxDelayMs = opts.maxDelayMs ?? 6e4;
+    this.stopGraceMs = opts.stopGraceMs ?? 3e3;
+    this.env = opts.env;
+    this.delay = this.minDelayMs;
   }
   child;
   timer;
   stopped = true;
   delay;
+  spawnFn;
+  minDelayMs;
+  maxDelayMs;
+  stopGraceMs;
+  env;
   start() {
     this.stopped = false;
     this.launch();
@@ -807,7 +895,8 @@ var CodexSupervisor = class {
     const child = this.spawnFn(process.execPath, [this.script, "--watch-stdin"], {
       detached: true,
       stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
+      windowsHide: true,
+      ...this.env ? { env: this.env } : {}
     });
     this.child = child;
     child.stdout?.on("data", (d) => process.stdout.write(d));
@@ -1411,7 +1500,16 @@ var HubServer = class {
         this.sessions.updateActivity(msg.sessionId);
         const notifySession = this.sessions.get(msg.sessionId);
         const notifyLabel = this.getSessionLabel(notifySession);
-        this.notifier.notifyWithSession(msg.sessionId, notifyLabel, `[${notifyLabel}] ${msg.title}`, msg.message, msg.level ?? "info");
+        const notifyTitle = `[${notifyLabel}] ${msg.title}`;
+        if (msg.to === "api") {
+          logger.info(`${notifyTitle}: ${msg.message}`);
+          break;
+        }
+        if (msg.to === "telegram") {
+          void this.telegramBot?.sendNotification(msg.sessionId, notifyLabel, notifyTitle, msg.message);
+          break;
+        }
+        if (msg.to !== "dashboard") this.notifier.notifyWithSession(msg.sessionId, notifyLabel, notifyTitle, msg.message, msg.level ?? "info");
         this.broadcastToDashboards({
           type: "notification",
           sessionId: msg.sessionId,
@@ -1613,9 +1711,14 @@ var HubServer = class {
           const channelWs = this.channelSockets.get(msg.sessionId);
           if (channelWs?.readyState === WebSocket.OPEN) {
             channelWs.send(JSON.stringify({ ...msg, source: "dashboard" }));
+          } else {
+            const reason = "the session is not connected";
+            logger.warn(`Message rejected for ${msg.sessionId}: ${reason}`);
+            const rejected = { type: "message_rejected", sessionId: msg.sessionId, reason };
+            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(rejected));
           }
         } else if (msg.type === "image_upload") {
-          this.handleImageUpload(msg);
+          this.handleImageUpload(ws, msg);
         } else if (msg.type === "permission_response") {
           if (this.forwardPermissionResponse(msg)) {
             const verdict = msg.choiceId !== void 0 ? `choice ${msg.choiceId}` : msg.behavior;
@@ -1666,20 +1769,31 @@ var HubServer = class {
       }
     }
   }
-  handleImageUpload(msg) {
+  handleImageUpload(ws, msg) {
     const { sessionId, imageData, mimeType, originalName, content } = msg;
+    const reject = (reason) => {
+      logger.warn(`Image upload rejected for ${sessionId}: ${reason}`);
+      const rejected = { type: "upload_rejected", sessionId, reason, withText: typeof content === "string" && content.trim().length > 0 };
+      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(rejected));
+    };
+    const channelWs = this.channelSockets.get(sessionId);
+    if (!channelWs || channelWs.readyState !== WebSocket.OPEN) {
+      reject("the session is not connected");
+      return;
+    }
     if (!this.localChannels.has(sessionId)) {
-      logger.warn(`Image upload rejected: session ${sessionId} is not local`);
+      reject("this session is on another PC; images can only go to sessions on the hub's PC");
       return;
     }
-    const channelWs = this.channelSockets.get(sessionId);
-    if (!channelWs || channelWs.readyState !== WebSocket.OPEN) return;
     const allowedTypes = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-    if (!allowedTypes.includes(mimeType)) return;
+    if (!allowedTypes.includes(mimeType)) {
+      reject("only PNG, JPEG, GIF and WebP images are supported");
+      return;
+    }
     const base64Data = imageData.replace(/^data:image\/\w+;base64,/, "");
     const buffer = Buffer.from(base64Data, "base64");
     if (buffer.length > 10 * 1024 * 1024) {
-      logger.warn("Image upload rejected: exceeds 10MB");
+      reject("the image is larger than 10 MB");
       return;
     }
     fs5.mkdirSync(UPLOADS_DIR, { recursive: true });
@@ -1727,19 +1841,25 @@ var HubServer = class {
     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, source: "telegram" };
-        channelWs.send(JSON.stringify(msg));
-        logger.info(`Telegram message forwarded to session: ${sessionId}`);
+      if (channelWs?.readyState !== WebSocket.OPEN) {
+        logger.warn(`Telegram message not delivered to ${sessionId}: the session is not connected`);
+        return false;
       }
+      const msg = { type: "message_to_session", sessionId, content, source: "telegram" };
+      channelWs.send(JSON.stringify(msg));
+      logger.info(`Telegram message forwarded to session: ${sessionId}`);
+      return true;
     };
     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, source: "telegram" };
-        channelWs.send(JSON.stringify(msg));
-        logger.info(`Telegram photo forwarded to session: ${sessionId}`);
+      if (channelWs?.readyState !== WebSocket.OPEN) {
+        logger.warn(`Telegram photo not delivered to ${sessionId}: the session is not connected`);
+        return false;
       }
+      const msg = { type: "image_to_session", sessionId, imagePath, mimeType, content: caption, source: "telegram" };
+      channelWs.send(JSON.stringify(msg));
+      logger.info(`Telegram photo forwarded to session: ${sessionId}`);
+      return true;
     };
     this.telegramBot.onPermissionVerdict = (sessionId, requestId, behavior) => {
       if (this.forwardPermissionResponse({ sessionId, requestId, behavior })) {
@@ -1864,7 +1984,7 @@ var HubServer = class {
       logger.warn("Codex adapter is enabled but codex/main.js was not found next to the hub");
       return;
     }
-    this.codexSupervisor = new CodexSupervisor(script);
+    this.codexSupervisor = new CodexSupervisor(script, { env: adapterEnv(process.env, { host: this.host, port: this.port }) });
     this.codexSupervisor.start();
     logger.info("Codex adapter started");
   }