@delt/claude-alarm 1.1.1 → 1.3.0

package/dist/index.js

@@ -40,6 +40,7 @@ var CODEX_PID_FILE = path.join(CONFIG_DIR, "codex.pid");
 var CODEX_LOG_FILE = path.join(CONFIG_DIR, "codex.log");
 var WS_PATH_CHANNEL = "/ws/channel";
 var WS_PATH_DASHBOARD = "/ws/dashboard";
+var WS_PATH_CODEX = "/ws/codex";
 var CHANNEL_SERVER_NAME = "claude-alarm";
 var CHANNEL_SERVER_VERSION = "0.1.0";
 
@@ -175,6 +176,7 @@ var Notifier = class {
       execFile(
         "powershell",
         ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
+        { windowsHide: true },
         (err, stdout) => {
           if (err) {
             resolve(true);
@@ -192,7 +194,7 @@ var Notifier = class {
     logger.warn("Windows notifications are disabled. Opening notification settings...");
     logger.warn("Please enable notifications for this app, then try again.");
     if (process.platform === "win32") {
-      execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"]);
+      execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
     }
     setTimeout(() => {
       this.notificationSettingsOpened = false;
@@ -243,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;
@@ -263,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;
   }
@@ -274,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);
@@ -287,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 {
@@ -368,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) {
@@ -381,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.");
           }
@@ -413,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) {
@@ -437,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 });
@@ -470,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];
@@ -588,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);
@@ -617,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;
@@ -643,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);
     }
@@ -675,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`, {
@@ -771,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();
@@ -805,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));
@@ -944,6 +1030,21 @@ function logStartup(context) {
 `);
 }
 
+// src/shared/entry.ts
+function isEntryScript(argv1, suffixes) {
+  if (!argv1) return false;
+  const normalized = argv1.replace(/\\/g, "/");
+  return suffixes.some((suffix) => normalized.endsWith(suffix));
+}
+
+// src/shared/hub-url.ts
+import net from "net";
+function hubUrlHost(host) {
+  if (host === "" || host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return net.isIPv6(host) ? `[${host}]` : host;
+}
+
 // src/hub/auth.ts
 import crypto from "crypto";
 var SESSION_COOKIE = "ca_session";
@@ -1009,6 +1110,7 @@ function validChoices(choices) {
   const valid = choices.filter((c) => typeof c?.id === "string" && typeof c?.label === "string");
   return valid.length ? valid : void 0;
 }
+var nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
 var HubServer = class {
   httpServer;
   wssChannel;
@@ -1034,7 +1136,13 @@ var HubServer = class {
   token;
   codexEnabled;
   codexSupervisor;
-  constructor(config) {
+  wssCodex;
+  codexAdapters = /* @__PURE__ */ new Map();
+  codexAlive = /* @__PURE__ */ new WeakMap();
+  codexCallTimeoutMs;
+  codexCalls = /* @__PURE__ */ new Map();
+  constructor(config, options = {}) {
+    this.codexCallTimeoutMs = options.codexCallTimeoutMs ?? 6e4;
     this.host = config?.hub?.host ?? DEFAULT_HUB_HOST;
     this.port = config?.hub?.port ?? DEFAULT_HUB_PORT;
     this.token = config?.hub?.token;
@@ -1047,7 +1155,7 @@ var HubServer = class {
     if (config?.webhooks) {
       this.notifier.configure({ webhooks: config.webhooks });
     }
-    const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+    const displayHost = hubUrlHost(this.host);
     this.notifier.configure({ dashboardUrl: `http://${displayHost}:${this.port}` });
     const fullConfig = loadConfig();
     if (fullConfig.telegram?.enabled && fullConfig.telegram.botToken && fullConfig.telegram.chatId) {
@@ -1060,6 +1168,9 @@ var HubServer = class {
     this.wssDashboard = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
     this.wssDashboard.on("connection", (ws) => this.handleDashboardConnection(ws));
     this.wssDashboard.on("error", (err) => logger.warn(`Dashboard WebSocket server error: ${err.message}`));
+    this.wssCodex = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
+    this.wssCodex.on("connection", (ws, req) => this.handleCodexConnection(ws, req));
+    this.wssCodex.on("error", (err) => logger.warn(`Codex WebSocket server error: ${err.message}`));
     this.httpServer.on("upgrade", (req, socket, head) => {
       socket.on("error", (err) => logger.debug(`Upgrade socket error: ${err.message}`));
       const url = new URL(req.url ?? "/", "http://hub");
@@ -1080,6 +1191,10 @@ var HubServer = class {
         this.wssDashboard.handleUpgrade(req, socket, head, (ws) => {
           this.wssDashboard.emit("connection", ws, req);
         });
+      } else if (pathname === WS_PATH_CODEX) {
+        this.wssCodex.handleUpgrade(req, socket, head, (ws) => {
+          this.wssCodex.emit("connection", ws, req);
+        });
       } else {
         socket.destroy();
       }
@@ -1094,7 +1209,7 @@ var HubServer = class {
       this.httpServer.listen(this.port, this.host, () => {
         this.httpServer.removeListener("error", onStartupError);
         this.httpServer.on("error", (err) => logger.error(`HTTP server error: ${err.message}`));
-        const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+        const displayHost = hubUrlHost(this.host);
         logger.info(`Hub server listening on http://${displayHost}:${this.port}`);
         this.startCodexAdapter();
         resolve();
@@ -1109,10 +1224,12 @@ var HubServer = class {
       if (this.telegramBot) this.telegramBot.stopPolling();
       for (const ws of this.channelSockets.values()) ws.terminate();
       for (const ws of this.dashboardSockets) ws.terminate();
+      for (const { ws } of this.codexAdapters.values()) ws.terminate();
       this.channelSockets.clear();
       this.dashboardSockets.clear();
       this.wssChannel.close();
       this.wssDashboard.close();
+      this.wssCodex.close();
       this.httpServer.close(() => {
         logger.info("Hub server stopped");
         resolve();
@@ -1177,6 +1294,12 @@ var HubServer = class {
       this.handleApiSend(req, res);
     } else if (url.pathname === "/api/notify" && req.method === "POST") {
       this.handleApiNotify(req, res);
+    } else if (url.pathname === "/api/codex/folders" && req.method === "GET") {
+      this.handleCodexFolders(url, res);
+    } else if (url.pathname === "/api/codex/threads" && req.method === "POST") {
+      this.handleCodexCreate(req, res);
+    } else if (url.pathname === "/api/codex/threads/close" && req.method === "POST") {
+      this.handleCodexClose(req, res);
     } else if (url.pathname === "/api/webhooks" && req.method === "GET") {
       const config = loadConfig();
       this.jsonResponse(res, 200, { webhooks: config.webhooks || [] });
@@ -1440,6 +1563,114 @@ var HubServer = class {
       }
     }
   }
+  handleCodexConnection(ws, req) {
+    const isLocal = this.isLocalRequest(req);
+    let adapterId;
+    ws.on("error", (err) => {
+      logger.warn(`Codex adapter WebSocket error: ${err.message}`);
+      ws.terminate();
+    });
+    ws.on("pong", () => this.codexAlive.set(ws, true));
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+        if (msg === null || typeof msg !== "object") {
+          logger.warn("Invalid message from Codex adapter");
+          return;
+        }
+      } catch {
+        logger.warn("Invalid message from Codex adapter");
+        return;
+      }
+      if (msg.type === "adapter_hello") {
+        const a = msg.adapter;
+        if (typeof a?.id !== "string" || !a.id || typeof a.host !== "string") return;
+        if (adapterId && adapterId !== a.id) return;
+        const holder = this.codexAdapters.get(a.id);
+        if (holder && holder.ws !== ws) holder.ws.terminate();
+        if (!adapterId) logger.info(`Codex adapter connected: ${a.host} (${a.id}, local: ${isLocal})`);
+        adapterId = a.id;
+        this.codexAdapters.set(a.id, { ws, info: { id: a.id, host: a.host, ready: a.ready === true, isLocal } });
+        this.broadcastCodexAdapters();
+      } else if (msg.type === "adapter_result" && adapterId) {
+        const call = this.codexCalls.get(msg.requestId);
+        if (!call || call.adapterId !== adapterId) return;
+        call.settle(msg.ok ? { status: 200, body: msg.data } : { status: 422, body: { error: String(msg.error) } });
+      }
+    });
+    ws.on("close", () => {
+      if (!adapterId || this.codexAdapters.get(adapterId)?.ws !== ws) return;
+      this.codexAdapters.delete(adapterId);
+      for (const call of [...this.codexCalls.values()]) {
+        if (call.adapterId === adapterId) call.settle({ status: 502, body: { error: "Codex adapter disconnected" } });
+      }
+      logger.info(`Codex adapter disconnected: ${adapterId}`);
+      this.broadcastCodexAdapters();
+    });
+  }
+  callCodexAdapter(adapterId, call) {
+    const adapter = this.codexAdapters.get(adapterId);
+    if (!adapter || adapter.ws.readyState !== WebSocket.OPEN) {
+      return Promise.resolve({ status: 404, body: { error: "Codex adapter is not connected" } });
+    }
+    const requestId = randomUUID3();
+    return new Promise((resolve) => {
+      const timer = setTimeout(
+        () => settle({ status: 504, body: { error: "Codex did not respond in time. The conversation may still appear." } }),
+        this.codexCallTimeoutMs
+      );
+      const settle = (outcome) => {
+        clearTimeout(timer);
+        this.codexCalls.delete(requestId);
+        resolve(outcome);
+      };
+      this.codexCalls.set(requestId, { adapterId, settle });
+      adapter.ws.send(JSON.stringify({ type: "adapter_call", requestId, call }));
+    });
+  }
+  async handleCodexFolders(url, res) {
+    const adapterId = url.searchParams.get("adapterId");
+    if (!nonEmpty(adapterId)) {
+      this.jsonResponse(res, 400, { error: "adapterId is required" });
+      return;
+    }
+    const out = await this.callCodexAdapter(adapterId, { kind: "folders" });
+    this.jsonResponse(res, out.status, out.body);
+  }
+  async handleCodexCreate(req, res) {
+    const body = await this.readBody(req);
+    const adapterId = body?.adapterId;
+    const cwd = body?.cwd;
+    if (!nonEmpty(adapterId) || !nonEmpty(cwd)) {
+      this.jsonResponse(res, 400, { error: "adapterId and cwd are required" });
+      return;
+    }
+    const out = await this.callCodexAdapter(adapterId, { kind: "create", cwd });
+    this.jsonResponse(res, out.status, out.body);
+  }
+  async handleCodexClose(req, res) {
+    const body = await this.readBody(req);
+    const sessionId = body?.sessionId;
+    if (!nonEmpty(sessionId)) {
+      this.jsonResponse(res, 400, { error: "sessionId is required" });
+      return;
+    }
+    const session = this.sessions.get(sessionId);
+    const ws = this.channelSockets.get(sessionId);
+    if (session?.agentKind !== "codex" || !session.closable || ws?.readyState !== WebSocket.OPEN) {
+      this.jsonResponse(res, 404, { error: "No closable Codex conversation" });
+      return;
+    }
+    ws.send(JSON.stringify({ type: "codex_close", sessionId }));
+    this.jsonResponse(res, 200, { ok: true });
+  }
+  codexAdapterList() {
+    return [...this.codexAdapters.values()].map((a) => a.info);
+  }
+  broadcastCodexAdapters() {
+    this.broadcastToDashboards({ type: "codex_adapters", adapters: this.codexAdapterList() });
+  }
   // --- Dashboard WebSocket ---
   handleDashboardConnection(ws) {
     this.dashboardSockets.add(ws);
@@ -1458,6 +1689,7 @@ var HubServer = class {
       requests: [...this.choiceRequests.values()].map((c) => c.request)
     };
     ws.send(JSON.stringify(pendingMsg));
+    ws.send(JSON.stringify({ type: "codex_adapters", adapters: this.codexAdapterList() }));
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
@@ -1467,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;
@@ -1518,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 });
@@ -1545,7 +1788,8 @@ var HubServer = class {
       imagePath: filePath,
       mimeType,
       originalName,
-      content
+      content,
+      source: "dashboard"
     };
     channelWs.send(JSON.stringify(forwardMsg));
     logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
@@ -1554,7 +1798,7 @@ var HubServer = class {
         fs5.unlinkSync(filePath);
       } catch {
       }
-    }, 5 * 60 * 1e3);
+    }, 5 * 60 * 1e3).unref();
   }
   async handleWebhookSave(req, res) {
     const body = await this.readBody(req);
@@ -1587,7 +1831,7 @@ var HubServer = class {
     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 };
+        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}`);
       }
@@ -1715,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");
   }
@@ -1730,6 +1974,14 @@ var HubServer = class {
         this.channelAlive.set(sessionId, false);
         ws.ping();
       }
+      for (const { ws } of this.codexAdapters.values()) {
+        if (this.codexAlive.get(ws) === false) {
+          ws.terminate();
+          continue;
+        }
+        this.codexAlive.set(ws, false);
+        ws.ping();
+      }
     }, 3e4);
   }
   cleanupUploads() {
@@ -1792,7 +2044,7 @@ Content-Length: 0\r
     });
   }
 };
-if (process.argv[1] && (process.argv[1].endsWith("hub/server.js") || process.argv[1].endsWith("hub/server.ts"))) {
+if (isEntryScript(process.argv[1], ["/hub/server.js", "/hub/server.ts"])) {
   installCrashGuard("hub daemon");
   logStartup("Hub daemon");
   const config = loadConfig();
@@ -1942,6 +2194,7 @@ export {
   SessionManager,
   UPLOADS_DIR,
   WS_PATH_CHANNEL,
+  WS_PATH_CODEX,
   WS_PATH_DASHBOARD,
   loadConfig,
   logger,