@delt/claude-alarm 1.2.0 → 1.4.0

package/dist/dashboard/index.html

@@ -1285,6 +1285,24 @@
     el.classList.toggle('show', !!msg);
   }
 
+  function showUploadRejected(msg) {
+    showNotDelivered(msg.sessionId, msg.withText ? 'Image and message not delivered' : 'Image not delivered', msg.reason);
+  }
+
+  function showMessageRejected(msg) {
+    showNotDelivered(msg.sessionId, 'Message not delivered', msg.reason);
+  }
+
+  function showNotDelivered(sessionId, label, reason) {
+    state.waitingReply[sessionId] = false;
+    if (state.selectedSession === sessionId) {
+      renderMessages();
+      showMentionError(`${label}: ${reason}`);
+    }
+    state.notifications.unshift({ sessionId, title: label, message: reason, level: 'warning', time: Date.now() });
+    renderNotifications();
+  }
+
   let mentionState = { open: false, items: [], index: 0, start: -1 };
 
   function currentMentionQuery(input) {
@@ -1448,32 +1466,18 @@
         state.notifications.unshift({ sessionId: msg.sessionId, title: 'Reply', message: msg.content.slice(0, 100), level: 'info', time: msg.timestamp });
         renderNotifications();
         break;
+      case 'upload_rejected':
+        showUploadRejected(msg);
+        break;
+      case 'message_rejected':
+        showMessageRejected(msg);
+        break;
       case 'notification':
         state.notifications.unshift({ sessionId: msg.sessionId, title: msg.title, message: msg.message, level: msg.level || 'info', time: msg.timestamp });
         renderNotifications();
         break;
       case 'permission_request':
-        if (!state.permissionRequests[msg.sessionId]) state.permissionRequests[msg.sessionId] = [];
-        state.permissionRequests[msg.sessionId].unshift({
-          requestId: msg.requestId,
-          toolName: msg.toolName,
-          description: msg.description,
-          inputPreview: msg.inputPreview,
-          timestamp: msg.timestamp,
-          resolved: false,
-          behavior: null,
-          choices: msg.choices || null,
-          sent: null,
-          outcome: null,
-        });
-        // Auto-select session if none selected
-        if (!state.selectedSession && state.sessions[msg.sessionId]) selectSession(msg.sessionId);
-        if (state.selectedSession === msg.sessionId) { renderMessages(); renderPermissionBar(); }
-        // Also show in notifications with permission info
-        state.notifications.unshift({ sessionId: msg.sessionId, title: 'Permission Request', message: `${msg.toolName}: ${msg.description}`, level: 'warning', time: msg.timestamp, permRequestId: msg.requestId });
-        renderNotifications();
-        // Play notification sound effect via title flash
-        flashTitle('Permission Request');
+        showPermissionRequest(msg);
         break;
       case 'permission_response':
         // Another source (Telegram, other dashboard) resolved a permission request
@@ -1487,11 +1491,7 @@
         }
         break;
       case 'permission_pending':
-        for (const m of applyPendingChoices(state.permissionRequests, msg.requests || [])) {
-          handleMessage({ type: 'permission_request', ...m });
-        }
-        renderPermissionBar();
-        renderNotifications();
+        restorePendingRequests(msg.requests || []);
         break;
       case 'codex_adapters': {
         state.codexAdapters = msg.adapters || [];
@@ -2114,6 +2114,46 @@
     return missing;
   }
 
+  function addPermissionRequest(msg) {
+    if (!state.permissionRequests[msg.sessionId]) state.permissionRequests[msg.sessionId] = [];
+    state.permissionRequests[msg.sessionId].unshift({
+      requestId: msg.requestId,
+      toolName: msg.toolName,
+      description: msg.description,
+      inputPreview: msg.inputPreview,
+      timestamp: msg.timestamp,
+      resolved: false,
+      behavior: null,
+      choices: msg.choices || null,
+      sent: null,
+      outcome: null,
+    });
+    if (!state.selectedSession && state.sessions[msg.sessionId]) selectSession(msg.sessionId);
+    if (state.selectedSession === msg.sessionId) { renderMessages(); renderPermissionBar(); }
+  }
+
+  function showPermissionRequest(msg) {
+    addPermissionRequest(msg);
+    state.notifications.unshift({ sessionId: msg.sessionId, title: 'Permission Request', message: `${msg.toolName}: ${msg.description}`, level: 'warning', time: msg.timestamp, permRequestId: msg.requestId });
+    renderNotifications();
+    flashTitle('Permission Request');
+  }
+
+  // A reconnect can bring back many requests at once; one row and one flash keep them from burying the notifications.
+  function restorePendingRequests(requests) {
+    const restored = applyPendingChoices(state.permissionRequests, requests);
+    for (const m of restored) addPermissionRequest(m);
+    if (restored.length) {
+      const label = `${restored.length} approval request(s) waiting`;
+      const listed = restored.slice(0, 3).map(m => `${m.toolName}: ${m.description}`).join(' · ');
+      const message = restored.length > 3 ? `${listed} …and ${restored.length - 3} more` : listed;
+      state.notifications.unshift({ sessionId: restored[0].sessionId, title: label, message, level: 'warning', time: Date.now() });
+      flashTitle(label);
+    }
+    renderPermissionBar();
+    renderNotifications();
+  }
+
   function sendPermissionChoice(sessionId, requestId, choiceId) {
     if (!state.ws || state.ws.readyState !== WebSocket.OPEN) return;
     state.ws.send(JSON.stringify({ type: 'permission_response', sessionId, requestId, choiceId }));
@@ -2197,23 +2237,28 @@
   }, true);
 
   // Flash title for attention
-  let flashInterval = null;
+  let flash = null;
   function flashTitle(msg) {
-    const original = document.title;
-    let on = true;
-    clearInterval(flashInterval);
-    flashInterval = setInterval(() => {
-      document.title = on ? `** ${msg} **` : original;
-      on = !on;
-    }, 500);
-    const stopFlash = () => {
-      clearInterval(flashInterval);
-      flashInterval = null;
-      document.title = original;
-      window.removeEventListener('focus', stopFlash);
+    // While flashing, document.title may hold the flash text, so only a flash that starts from rest reads the real title.
+    if (flash) {
+      flash.msg = msg;
+      return;
+    }
+    const current = { msg, original: document.title, on: true, interval: null, timeout: null };
+    const stop = () => {
+      clearInterval(current.interval);
+      clearTimeout(current.timeout);
+      window.removeEventListener('focus', stop);
+      document.title = current.original;
+      flash = null;
     };
-    window.addEventListener('focus', stopFlash);
-    setTimeout(stopFlash, 30000);
+    current.interval = setInterval(() => {
+      document.title = current.on ? `** ${current.msg} **` : current.original;
+      current.on = !current.on;
+    }, 500);
+    current.timeout = setTimeout(stop, 30000);
+    window.addEventListener('focus', stop);
+    flash = current;
   }
 
   // Clear all notifications

package/dist/hub/server.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));
@@ -1387,7 +1476,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,
@@ -1589,9 +1687,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;
@@ -1642,20 +1745,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 });
@@ -1703,19 +1817,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 })) {
@@ -1840,7 +1960,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");
   }