@delt/claude-alarm 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -73,6 +73,11 @@ type ChannelMessage = {
     originalName?: string;
     content?: string;
     source?: MessageSource;
+} | {
+    type: 'upload_rejected';
+    sessionId: string;
+    reason: string;
+    withText: boolean;
 } | {
     type: 'sessions_list';
     sessions: SessionInfo[];
@@ -323,11 +328,13 @@ declare class TelegramBot {
     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 */
@@ -340,6 +347,7 @@ declare class TelegramBot {
     private deliverToSession;
     private deliverPhotoToSession;
     private deliverPhotoToSessionByFileId;
+    private photoNotDelivered;
     private pendingSession;
     private getLabel;
     /** Send a permission request with inline buttons */
@@ -352,6 +360,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,13 @@ ${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;
+function visibleLength(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/&(?:amp|lt|gt);/g, "&").length;
+}
 var TelegramBot = class _TelegramBot {
   config;
   offset = 0;
@@ -265,9 +272,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 +283,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 +295,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 +395,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 +415,20 @@ ${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) {
+            let delivered = true;
             if (pending.photoFileId) {
-              await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
+              delivered = 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 (delivered) this.sendMessage(`Sent to [${this.getLabel(session)}]`);
           } else {
             this.sendMessage("Invalid session number.");
           }
@@ -415,16 +449,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) {
@@ -439,24 +476,27 @@ ${this.mdToHtml(message)}`;
   }
   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 });
@@ -472,11 +512,18 @@ ${this.mdToHtml(message)}`;
           fs.unlinkSync(filePath);
         } catch {
         }
-      }, 5 * 60 * 1e3);
+      }, 5 * 60 * 1e3).unref();
+      return this.onImageToSession !== void 0;
     } 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 +637,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 +666,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,19 +696,25 @@ ${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);
+    this.selections.delete(selectionId);
     if (pending.photoFileId) {
-      await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
+      const delivered = await this.deliverPhotoToSessionByFileId(session.id, pending.photoFileId, pending.caption);
+      if (!delivered) {
+        await this.answerCallbackQuery(query.id, "Photo not delivered");
+        if (query.message) await this.removeButtons(query.message.chat.id, query.message.message_id);
+        return;
+      }
     } else if (pending.text) {
       this.deliverToSession(session.id, pending.text);
     }
@@ -677,6 +734,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 +845,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 +890,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));
@@ -1615,7 +1699,7 @@ var HubServer = class {
             channelWs.send(JSON.stringify({ ...msg, source: "dashboard" }));
           }
         } 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 +1750,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 });
@@ -1864,7 +1959,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");
   }