@delt/claude-alarm 1.0.0 → 1.1.0

package/dist/cli.js

@@ -75,6 +75,9 @@ function setCodexEnabled(enabled) {
   saveConfig(config2);
   return config2;
 }
+function shouldOfferCodex(config2, installed) {
+  return installed && config2.codex === void 0;
+}
 function setupMcpConfig(targetDir) {
   const dir = targetDir ?? process.cwd();
   const mcpPath = path2.join(dir, ".mcp.json");
@@ -143,11 +146,11 @@ var init_logger = __esm({
 });
 
 // src/shared/crash-guard.ts
-import fs2 from "fs";
+import fs3 from "fs";
 function appendToLog(text) {
   try {
-    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs2.appendFileSync(LOG_FILE, text, "utf-8");
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs3.appendFileSync(LOG_FILE, text, "utf-8");
   } catch {
   }
 }
@@ -409,18 +412,31 @@ var init_session_label = __esm({
   }
 });
 
+// src/shared/permission-key.ts
+function permissionKey(sessionId2, requestId) {
+  return `${sessionId2}
+${requestId}`;
+}
+var init_permission_key = __esm({
+  "src/shared/permission-key.ts"() {
+    "use strict";
+  }
+});
+
 // src/hub/telegram.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-var TELEGRAM_API, TelegramBot;
+var TELEGRAM_API, MAX_CHOICE_MESSAGES, TelegramBot;
 var init_telegram = __esm({
   "src/hub/telegram.ts"() {
     "use strict";
     init_logger();
     init_constants();
     init_session_label();
+    init_permission_key();
     TELEGRAM_API = "https://api.telegram.org/bot";
+    MAX_CHOICE_MESSAGES = 200;
     TelegramBot = class _TelegramBot {
       config;
       offset = 0;
@@ -434,6 +450,11 @@ var init_telegram = __esm({
       onImageToSession;
       // Callback: when a permission verdict arrives from Telegram
       onPermissionVerdict;
+      // Callback: when a Codex approval choice arrives from Telegram
+      onChoiceVerdict;
+      // Telegram caps callback_data at 64 bytes, so buttons carry a short token instead of the ids.
+      choiceTokens = /* @__PURE__ */ new Map();
+      choiceMessages = /* @__PURE__ */ new Map();
       // Callback: get current sessions list
       getSessions;
       // Pending messages for session selection
@@ -630,17 +651,17 @@ ${this.mdToHtml(message)}`;
           const buffer = Buffer.from(await imgRes.arrayBuffer());
           const ext = fileData.result.file_path.split(".").pop() || "jpg";
           const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : "image/jpeg";
-          fs3.mkdirSync(UPLOADS_DIR, { recursive: true });
+          fs4.mkdirSync(UPLOADS_DIR, { recursive: true });
           const filename = `${randomUUID2()}.${ext}`;
-          const filePath = path3.join(UPLOADS_DIR, filename);
-          fs3.writeFileSync(filePath, buffer);
+          const filePath = path4.join(UPLOADS_DIR, filename);
+          fs4.writeFileSync(filePath, buffer);
           logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
           if (this.onImageToSession) {
             this.onImageToSession(sessionId2, filePath, mimeType, caption);
           }
           setTimeout(() => {
             try {
-              fs3.unlinkSync(filePath);
+              fs4.unlinkSync(filePath);
             } catch {
             }
           }, 5 * 60 * 1e3);
@@ -722,6 +743,71 @@ ${previewHtml}${truncNote}`;
         };
         await this.sendMessage(text, void 0, replyMarkup);
       }
+      async sendChoiceRequest(sessionId2, sessionLabel2, requestId, toolName, description, inputPreview, choices) {
+        let preview = inputPreview;
+        try {
+          const p = JSON.parse(inputPreview);
+          if (typeof p.command === "string") preview = `$ ${p.command}`;
+          else if (typeof p.content === "string") preview = p.content;
+        } catch {
+        }
+        const slice = preview.slice(0, 3e3);
+        const html = `\u26A0\uFE0F <b>Permission Request</b> \u2014 ${this.escHtml(sessionLabel2)}
+
+\u{1F527} <b>${this.escHtml(toolName)}</b>` + (description ? `
+${this.escHtml(description)}` : "") + (slice ? `
+<pre>${this.escHtml(slice)}</pre>` : "") + (preview.length > slice.length ? "\n<i>...truncated</i>" : "");
+        const entry = { html };
+        this.choiceMessages.set(permissionKey(sessionId2, requestId), entry);
+        const rows = choices.map((c) => {
+          const token = randomUUID2().replace(/-/g, "").slice(0, 16);
+          this.choiceTokens.set(token, { sessionId: sessionId2, requestId, choiceId: c.id, label: c.label });
+          return [{ text: c.label, callback_data: `pc:${token}` }];
+        });
+        this.trimChoiceMessages();
+        const sent = await this.sendMessage(html, void 0, { inline_keyboard: rows });
+        if (!sent) return;
+        entry.messageId = sent.message_id;
+        if (entry.outcome) await this.editMessageText(this.config.chatId, sent.message_id, html + entry.outcome);
+      }
+      async resolveChoiceRequest(sessionId2, requestId, state) {
+        this.dropChoiceTokens(sessionId2, requestId);
+        const key = permissionKey(sessionId2, requestId);
+        const entry = this.choiceMessages.get(key);
+        if (!entry) return;
+        this.choiceMessages.delete(key);
+        entry.outcome = state === "resolved" ? "\n\n\u2705 <b>Resolved</b>" : "\n\n\u231B <b>Expired</b>";
+        if (entry.messageId !== void 0) await this.editMessageText(this.config.chatId, entry.messageId, entry.html + entry.outcome);
+      }
+      async handleChoiceCallback(query) {
+        const choice = this.choiceTokens.get(query.data.slice("pc:".length));
+        if (!choice) {
+          await this.answerCallbackQuery(query.id, "Expired");
+          return;
+        }
+        this.dropChoiceTokens(choice.sessionId, choice.requestId);
+        this.onChoiceVerdict?.(choice.sessionId, choice.requestId, choice.choiceId);
+        await this.answerCallbackQuery(query.id, `Sent: ${choice.label}`);
+        const entry = this.choiceMessages.get(permissionKey(choice.sessionId, choice.requestId));
+        if (entry?.messageId !== void 0 && !entry.outcome) {
+          await this.editMessageText(this.config.chatId, entry.messageId, `${entry.html}
+
+\u23F3 <b>Sent: ${this.escHtml(choice.label)}</b>`);
+        }
+      }
+      dropChoiceTokens(sessionId2, requestId) {
+        for (const [token, c] of this.choiceTokens) {
+          if (c.sessionId === sessionId2 && c.requestId === requestId) this.choiceTokens.delete(token);
+        }
+      }
+      trimChoiceMessages() {
+        while (this.choiceMessages.size > MAX_CHOICE_MESSAGES) {
+          const oldest = this.choiceMessages.keys().next().value;
+          this.choiceMessages.delete(oldest);
+          const [sessionId2, requestId] = oldest.split("\n");
+          this.dropChoiceTokens(sessionId2, requestId);
+        }
+      }
       async handleCallbackQuery(query) {
         if (!query.data) return;
         if (String(query.message?.chat.id) !== String(this.config.chatId)) return;
@@ -729,6 +815,10 @@ ${previewHtml}${truncNote}`;
           await this.handleSessionSelectCallback(query);
           return;
         }
+        if (query.data.startsWith("pc:")) {
+          await this.handleChoiceCallback(query);
+          return;
+        }
         if (!query.data.startsWith("perm:")) return;
         const parts = query.data.split(":");
         if (parts.length < 4) return;
@@ -823,8 +913,8 @@ ${label}`);
         css: "css",
         scss: "scss"
       };
-      langOf(path9) {
-        const m = /\.([a-z0-9]+)$/i.exec(path9 || "");
+      langOf(path10) {
+        const m = /\.([a-z0-9]+)$/i.exec(path10 || "");
         return m ? _TelegramBot.LANG_BY_EXT[m[1].toLowerCase()] ?? "" : "";
       }
       /** Convert markdown to Telegram HTML (escape first, then apply formatting) */
@@ -870,11 +960,11 @@ ${bodyLines.join("\n")}`;
 });
 
 // src/hub/codex-supervisor.ts
-import { spawn } from "child_process";
-import fs4 from "fs";
-import path4 from "path";
+import { spawn as spawn2 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
 function resolveAdapterScript(baseDir) {
-  return [path4.join(baseDir, "..", "codex", "main.js"), path4.join(baseDir, "codex", "main.js")].find((p) => fs4.existsSync(p));
+  return [path5.join(baseDir, "..", "codex", "main.js"), path5.join(baseDir, "codex", "main.js")].find((p) => fs5.existsSync(p));
 }
 var HEALTHY_RUN_MS, CodexSupervisor;
 var init_codex_supervisor = __esm({
@@ -883,7 +973,7 @@ var init_codex_supervisor = __esm({
     init_logger();
     HEALTHY_RUN_MS = 6e4;
     CodexSupervisor = class {
-      constructor(script, spawnFn = spawn, minDelayMs = 2e3, maxDelayMs = 6e4, stopGraceMs = 3e3) {
+      constructor(script, spawnFn = spawn2, minDelayMs = 2e3, maxDelayMs = 6e4, stopGraceMs = 3e3) {
         this.script = script;
         this.spawnFn = spawnFn;
         this.minDelayMs = minDelayMs;
@@ -1009,11 +1099,16 @@ __export(server_exports, {
   HubServer: () => HubServer
 });
 import http from "http";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import { fileURLToPath } from "url";
-import { WebSocketServer, WebSocket } from "ws";
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 import { randomUUID as randomUUID3 } from "crypto";
+function validChoices(choices) {
+  if (!Array.isArray(choices)) return void 0;
+  const valid = choices.filter((c) => typeof c?.id === "string" && typeof c?.label === "string");
+  return valid.length ? valid : void 0;
+}
 var __dirname, MAX_WS_PAYLOAD, HubServer;
 var init_server = __esm({
   "src/hub/server.ts"() {
@@ -1027,8 +1122,9 @@ var init_server = __esm({
     init_config();
     init_session_label();
     init_crash_guard();
+    init_permission_key();
     init_auth();
-    __dirname = path5.dirname(fileURLToPath(import.meta.url));
+    __dirname = path6.dirname(fileURLToPath(import.meta.url));
     MAX_WS_PAYLOAD = 16 * 1024 * 1024;
     HubServer = class {
       httpServer;
@@ -1048,6 +1144,8 @@ var init_server = __esm({
       channelAlive = /* @__PURE__ */ new Map();
       // sessionId -> alive flag
       socketOwners = /* @__PURE__ */ new WeakMap();
+      // Codex approvals carry their own choices; a response is forwarded only in the mode of the request it answers.
+      choiceRequests = /* @__PURE__ */ new Map();
       host;
       port;
       token;
@@ -1185,6 +1283,7 @@ var init_server = __esm({
           this.channelSockets.delete(sessionId2);
           this.localChannels.delete(sessionId2);
           this.channelAlive.delete(sessionId2);
+          this.expireChoices(sessionId2);
           if (session) {
             this.broadcastToDashboards({ type: "session_disconnected", sessionId: sessionId2 });
             this.jsonResponse(res, 200, { ok: true });
@@ -1224,23 +1323,23 @@ var init_server = __esm({
           return;
         }
         const candidates = [
-          path5.join(__dirname, "..", "dashboard", "index.html"),
+          path6.join(__dirname, "..", "dashboard", "index.html"),
           // from dist/hub/
-          path5.join(__dirname, "dashboard", "index.html"),
+          path6.join(__dirname, "dashboard", "index.html"),
           // from dist/ (bundled index.js)
-          path5.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+          path6.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
           // from dist/hub/ -> src/
-          path5.join(__dirname, "..", "src", "dashboard", "index.html"),
+          path6.join(__dirname, "..", "src", "dashboard", "index.html"),
           // from dist/ -> src/
-          path5.join(process.cwd(), "dist", "dashboard", "index.html"),
+          path6.join(process.cwd(), "dist", "dashboard", "index.html"),
           // from cwd
-          path5.join(process.cwd(), "src", "dashboard", "index.html")
+          path6.join(process.cwd(), "src", "dashboard", "index.html")
           // from cwd/src
         ];
         logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
         for (const candidate of candidates) {
-          if (fs5.existsSync(candidate)) {
-            const html = fs5.readFileSync(candidate, "utf-8");
+          if (fs6.existsSync(candidate)) {
+            const html = fs6.readFileSync(candidate, "utf-8");
             res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
             res.end(html);
             return;
@@ -1275,7 +1374,7 @@ var init_server = __esm({
           return;
         }
         const ws = this.channelSockets.get(sessionId2);
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
+        if (!ws || ws.readyState !== WebSocket2.OPEN) {
           this.jsonResponse(res, 404, { error: "Session not connected" });
           return;
         }
@@ -1328,6 +1427,7 @@ var init_server = __esm({
               this.channelSockets.delete(sessionId2);
               this.localChannels.delete(sessionId2);
               this.channelAlive.delete(sessionId2);
+              this.expireChoices(sessionId2);
               logger.info(`Channel disconnected: ${sessionId2}`);
               this.broadcastToDashboards({
                 type: "session_disconnected",
@@ -1415,7 +1515,22 @@ var init_server = __esm({
           }
           case "permission_request": {
             this.sessions.updateActivity(msg.sessionId);
+            const choices = validChoices(msg.choices);
             logger.info(`Permission request [${msg.requestId}] from ${msg.sessionId}: ${msg.toolName}`);
+            if (choices) {
+              this.choiceRequests.set(permissionKey(msg.sessionId, msg.requestId), {
+                request: {
+                  sessionId: msg.sessionId,
+                  requestId: msg.requestId,
+                  toolName: msg.toolName,
+                  description: msg.description,
+                  inputPreview: msg.inputPreview,
+                  timestamp: msg.timestamp,
+                  choices
+                },
+                choiceIds: new Set(choices.map((c) => c.id))
+              });
+            }
             this.broadcastToDashboards({
               type: "permission_request",
               sessionId: msg.sessionId,
@@ -1423,15 +1538,23 @@ var init_server = __esm({
               toolName: msg.toolName,
               description: msg.description,
               inputPreview: msg.inputPreview,
-              timestamp: msg.timestamp
+              timestamp: msg.timestamp,
+              ...choices ? { choices } : {}
             });
             if (this.telegramBot) {
-              const session = this.sessions.get(msg.sessionId);
-              const label = this.getSessionLabel(session);
-              this.telegramBot.sendPermissionRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview);
+              const label = this.getSessionLabel(this.sessions.get(msg.sessionId));
+              if (choices) {
+                void this.telegramBot.sendChoiceRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview, choices);
+              } else {
+                this.telegramBot.sendPermissionRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview);
+              }
             }
             break;
           }
+          case "permission_resolved": {
+            this.resolveChoice(msg.sessionId, msg.requestId, msg.state === "expired" ? "expired" : "resolved");
+            break;
+          }
         }
       }
       // --- Dashboard WebSocket ---
@@ -1447,21 +1570,25 @@ var init_server = __esm({
           sessions: this.sessions.getAll()
         };
         ws.send(JSON.stringify(sessionsMsg));
+        const pendingMsg = {
+          type: "permission_pending",
+          requests: [...this.choiceRequests.values()].map((c) => c.request)
+        };
+        ws.send(JSON.stringify(pendingMsg));
         ws.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.type === "message_to_session") {
               const channelWs = this.channelSockets.get(msg.sessionId);
-              if (channelWs?.readyState === WebSocket.OPEN) {
+              if (channelWs?.readyState === WebSocket2.OPEN) {
                 channelWs.send(JSON.stringify({ ...msg, source: "dashboard" }));
               }
             } else if (msg.type === "image_upload") {
               this.handleImageUpload(msg);
             } else if (msg.type === "permission_response") {
-              const channelWs = this.channelSockets.get(msg.sessionId);
-              if (channelWs?.readyState === WebSocket.OPEN) {
-                channelWs.send(JSON.stringify(msg));
-                logger.info(`Permission verdict [${msg.requestId}]: ${msg.behavior} -> session ${msg.sessionId}`);
+              if (this.forwardPermissionResponse(msg)) {
+                const verdict = msg.choiceId !== void 0 ? `choice ${msg.choiceId}` : msg.behavior;
+                logger.info(`Permission verdict [${msg.requestId}]: ${verdict} -> session ${msg.sessionId}`);
               }
             }
           } catch {
@@ -1474,10 +1601,36 @@ var init_server = __esm({
         });
       }
       // --- Helpers ---
+      forwardPermissionResponse(msg) {
+        const pending = this.choiceRequests.get(permissionKey(msg.sessionId, msg.requestId));
+        let out;
+        if (pending) {
+          if (typeof msg.choiceId !== "string" || !pending.choiceIds.has(msg.choiceId)) return false;
+          out = { type: "permission_response", sessionId: msg.sessionId, requestId: msg.requestId, choiceId: msg.choiceId };
+        } else {
+          if (msg.behavior !== "allow" && msg.behavior !== "deny" || msg.choiceId !== void 0) return false;
+          if (this.sessions.get(msg.sessionId)?.agentKind === "codex") return false;
+          out = { type: "permission_response", sessionId: msg.sessionId, requestId: msg.requestId, behavior: msg.behavior };
+        }
+        const channelWs = this.channelSockets.get(msg.sessionId);
+        if (channelWs?.readyState !== WebSocket2.OPEN) return false;
+        channelWs.send(JSON.stringify(out));
+        return true;
+      }
+      resolveChoice(sessionId2, requestId, state) {
+        if (!this.choiceRequests.delete(permissionKey(sessionId2, requestId))) return;
+        this.broadcastToDashboards({ type: "permission_resolved", sessionId: sessionId2, requestId, state });
+        void this.telegramBot?.resolveChoiceRequest(sessionId2, requestId, state);
+      }
+      expireChoices(sessionId2) {
+        for (const pending of [...this.choiceRequests.values()]) {
+          if (pending.request.sessionId === sessionId2) this.resolveChoice(sessionId2, pending.request.requestId, "expired");
+        }
+      }
       broadcastToDashboards(msg) {
         const payload = JSON.stringify(msg);
         for (const ws of this.dashboardSockets) {
-          if (ws.readyState === WebSocket.OPEN) {
+          if (ws.readyState === WebSocket2.OPEN) {
             ws.send(payload);
           }
         }
@@ -1489,7 +1642,7 @@ var init_server = __esm({
           return;
         }
         const channelWs = this.channelSockets.get(sessionId2);
-        if (!channelWs || channelWs.readyState !== WebSocket.OPEN) return;
+        if (!channelWs || channelWs.readyState !== WebSocket2.OPEN) return;
         const allowedTypes = ["image/png", "image/jpeg", "image/gif", "image/webp"];
         if (!allowedTypes.includes(mimeType)) return;
         const base64Data = imageData.replace(/^data:image\/\w+;base64,/, "");
@@ -1498,11 +1651,11 @@ var init_server = __esm({
           logger.warn("Image upload rejected: exceeds 10MB");
           return;
         }
-        fs5.mkdirSync(UPLOADS_DIR, { recursive: true });
+        fs6.mkdirSync(UPLOADS_DIR, { recursive: true });
         const ext = mimeType.split("/")[1] === "jpeg" ? "jpg" : mimeType.split("/")[1];
         const filename = `${randomUUID3()}.${ext}`;
-        const filePath = path5.join(UPLOADS_DIR, filename);
-        fs5.writeFileSync(filePath, buffer);
+        const filePath = path6.join(UPLOADS_DIR, filename);
+        fs6.writeFileSync(filePath, buffer);
         const forwardMsg = {
           type: "image_to_session",
           sessionId: sessionId2,
@@ -1515,7 +1668,7 @@ var init_server = __esm({
         logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
         setTimeout(() => {
           try {
-            fs5.unlinkSync(filePath);
+            fs6.unlinkSync(filePath);
           } catch {
           }
         }, 5 * 60 * 1e3);
@@ -1542,7 +1695,7 @@ var init_server = __esm({
         this.telegramBot.getSessions = () => this.sessions.getAll();
         this.telegramBot.onMessageToSession = (sessionId2, content) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket.OPEN) {
+          if (channelWs?.readyState === WebSocket2.OPEN) {
             const msg = { type: "message_to_session", sessionId: sessionId2, content, source: "telegram" };
             channelWs.send(JSON.stringify(msg));
             logger.info(`Telegram message forwarded to session: ${sessionId2}`);
@@ -1550,21 +1703,23 @@ var init_server = __esm({
         };
         this.telegramBot.onImageToSession = (sessionId2, imagePath, mimeType, caption) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket.OPEN) {
+          if (channelWs?.readyState === WebSocket2.OPEN) {
             const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption };
             channelWs.send(JSON.stringify(msg));
             logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
           }
         };
         this.telegramBot.onPermissionVerdict = (sessionId2, requestId, behavior) => {
-          const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket.OPEN) {
-            const msg = { type: "permission_response", sessionId: sessionId2, requestId, behavior };
-            channelWs.send(JSON.stringify(msg));
+          if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, behavior })) {
             logger.info(`Telegram permission verdict [${requestId}]: ${behavior} -> session ${sessionId2}`);
           }
           this.broadcastToDashboards({ type: "permission_response", sessionId: sessionId2, requestId, behavior });
         };
+        this.telegramBot.onChoiceVerdict = (sessionId2, requestId, choiceId) => {
+          if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, choiceId })) {
+            logger.info(`Telegram choice [${requestId}]: ${choiceId} -> session ${sessionId2}`);
+          }
+        };
         this.notifier.configure({ telegramBot: this.telegramBot });
         this.telegramBot.startPolling();
         logger.info("Telegram bot initialized");
@@ -1696,11 +1851,11 @@ var init_server = __esm({
       }
       cleanupUploads() {
         try {
-          if (!fs5.existsSync(UPLOADS_DIR)) return;
-          const files = fs5.readdirSync(UPLOADS_DIR);
+          if (!fs6.existsSync(UPLOADS_DIR)) return;
+          const files = fs6.readdirSync(UPLOADS_DIR);
           for (const file of files) {
             try {
-              fs5.unlinkSync(path5.join(UPLOADS_DIR, file));
+              fs6.unlinkSync(path6.join(UPLOADS_DIR, file));
             } catch {
             }
           }
@@ -1773,7 +1928,7 @@ Content-Length: 0\r
 });
 
 // src/channel/hub-client.ts
-import WebSocket2 from "ws";
+import WebSocket3 from "ws";
 var HubClient;
 var init_hub_client = __esm({
   "src/channel/hub-client.ts"() {
@@ -1802,7 +1957,7 @@ var init_hub_client = __esm({
         const url = `ws://${this.hubHost}:${this.hubPort}${WS_PATH_CHANNEL}${tokenQuery}`;
         logger.debug(`Connecting to hub at ${url}`);
         try {
-          const ws = new WebSocket2(url);
+          const ws = new WebSocket3(url);
           this.ws = ws;
           ws.on("open", () => {
             if (this.ws !== ws) return;
@@ -1842,7 +1997,7 @@ var init_hub_client = __esm({
         }
       }
       send(msg) {
-        if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
+        if (this.connected && this.ws?.readyState === WebSocket3.OPEN) {
           this.ws.send(JSON.stringify(msg));
         } else {
           if (this.queue.length < 100) {
@@ -1867,7 +2022,7 @@ var init_hub_client = __esm({
         this.connected = false;
       }
       reregister() {
-        if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
+        if (this.connected && this.ws?.readyState === WebSocket3.OPEN) {
           this.ws.send(JSON.stringify(this.registration()));
         }
       }
@@ -1899,9 +2054,9 @@ var init_hub_client = __esm({
 });
 
 // src/channel/peer-name.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import os2 from "os";
-import path6 from "path";
+import path7 from "path";
 function findPeerName(records, env) {
   const valid = records.filter((r) => typeof r === "object" && r !== null);
   const nameOf = (match) => {
@@ -1921,18 +2076,18 @@ function readPeerName(env = process.env) {
     sessionId: env.CLAUDE_CODE_SESSION_ID
   };
   if (!lookup.messagingSocket && !lookup.sessionId) return void 0;
-  const configDir = env.CLAUDE_CONFIG_DIR || path6.join(os2.homedir(), ".claude");
-  const dir = path6.join(configDir, "sessions");
+  const configDir = env.CLAUDE_CONFIG_DIR || path7.join(os2.homedir(), ".claude");
+  const dir = path7.join(configDir, "sessions");
   let files;
   try {
-    files = fs6.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    files = fs7.readdirSync(dir).filter((f) => f.endsWith(".json"));
   } catch {
     return void 0;
   }
   const records = [];
   for (const f of files) {
     try {
-      records.push(JSON.parse(fs6.readFileSync(path6.join(dir, f), "utf8")));
+      records.push(JSON.parse(fs7.readFileSync(path7.join(dir, f), "utf8")));
     } catch {
     }
   }
@@ -1955,7 +2110,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { randomUUID as randomUUID4 } from "crypto";
-import path7 from "path";
+import path8 from "path";
 async function main() {
   logger.info(`Starting MCP channel server (session: ${sessionId})`);
   hubClient.connect();
@@ -2024,7 +2179,7 @@ var init_server2 = __esm({
     init_hub_client();
     init_peer_name2();
     sessionId = randomUUID4();
-    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path7.basename(process.cwd());
+    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path8.basename(process.cwd());
     peerName = readPeerName();
     server = new Server(
       {
@@ -2200,15 +2355,35 @@ NOTIFICATIONS:
 
 // src/cli.ts
 init_config();
+import { spawn as spawn3 } from "child_process";
+import fs8 from "fs";
+import path9 from "path";
+import readline from "readline";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/codex/transport.ts
+init_logger();
+import { spawn } from "child_process";
+import fs2 from "fs";
+import path3 from "path";
+import { Duplex } from "stream";
+import WebSocket from "ws";
+function findOnPath(command, platform = process.platform, env = process.env) {
+  const dirs = (env.PATH ?? env.Path ?? "").split(path3.delimiter).filter(Boolean);
+  for (const ext of platform === "win32" ? [".exe", ".cmd"] : [""]) {
+    for (const dir of dirs) {
+      const file = path3.join(dir, command + ext);
+      if (fs2.existsSync(file)) return file;
+    }
+  }
+  return void 0;
+}
+
+// src/cli.ts
 init_constants();
 init_logger();
 init_crash_guard();
-import { spawn as spawn2 } from "child_process";
-import fs7 from "fs";
-import path8 from "path";
-import readline from "readline";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path9.dirname(fileURLToPath2(import.meta.url));
 function authHeaders(token) {
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
@@ -2240,8 +2415,8 @@ Quick start:
 }
 async function checkForUpdates() {
   try {
-    const pkgPath = path8.join(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path9.join(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     const currentVersion = pkg.version;
     const res = await fetch("https://registry.npmjs.org/@delt/claude-alarm/latest", {
       signal: AbortSignal.timeout(3e3)
@@ -2264,25 +2439,25 @@ async function hubStart(daemon) {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   checkForUpdates();
-  if (fs7.existsSync(PID_FILE)) {
-    const pid = parseInt(fs7.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs8.existsSync(PID_FILE)) {
+    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       console.log(`Hub is already running (PID: ${pid}). Dashboard: ${loginLink(displayHost, port, config2.hub.token)}`);
       return;
     }
-    fs7.unlinkSync(PID_FILE);
+    fs8.unlinkSync(PID_FILE);
   }
   if (daemon) {
     ensureConfigDir();
-    const logFd = fs7.openSync(LOG_FILE, "a");
-    const hubScript = path8.join(__dirname2, "hub", "server.js");
-    const child = spawn2(process.execPath, [hubScript], {
+    const logFd = fs8.openSync(LOG_FILE, "a");
+    const hubScript = path9.join(__dirname2, "hub", "server.js");
+    const child = spawn3(process.execPath, [hubScript], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env }
     });
     if (child.pid) {
-      fs7.writeFileSync(PID_FILE, String(child.pid), "utf-8");
+      fs8.writeFileSync(PID_FILE, String(child.pid), "utf-8");
       child.unref();
       console.log(`Hub started as daemon (PID: ${child.pid})`);
       console.log(`Dashboard: ${loginLink(displayHost, port, config2.hub.token)}`);
@@ -2303,11 +2478,11 @@ async function hubStart(daemon) {
     const hub = new HubServer2(config2);
     await hub.start();
     ensureConfigDir();
-    fs7.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    fs8.writeFileSync(PID_FILE, String(process.pid), "utf-8");
     const shutdown = async () => {
       console.log("\nShutting down...");
       await hub.stop();
-      if (fs7.existsSync(PID_FILE)) fs7.unlinkSync(PID_FILE);
+      if (fs8.existsSync(PID_FILE)) fs8.unlinkSync(PID_FILE);
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -2315,18 +2490,18 @@ async function hubStart(daemon) {
   }
 }
 function hubStop() {
-  if (!fs7.existsSync(PID_FILE)) {
+  if (!fs8.existsSync(PID_FILE)) {
     console.log("Hub is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs7.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Hub stopped (PID: ${pid})`);
   } catch {
     console.log("Hub process not found (may have already stopped)");
   }
-  fs7.unlinkSync(PID_FILE);
+  fs8.unlinkSync(PID_FILE);
 }
 async function hubStatus() {
   const config2 = loadConfig();
@@ -2334,8 +2509,8 @@ async function hubStatus() {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
   let pidInfo = "not running";
-  if (fs7.existsSync(PID_FILE)) {
-    const pid = parseInt(fs7.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs8.existsSync(PID_FILE)) {
+    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       pidInfo = `running (PID: ${pid})`;
     } else {
@@ -2407,7 +2582,7 @@ function ask(question) {
 }
 async function init() {
   const dir = process.cwd();
-  const projectName = path8.basename(dir);
+  const projectName = path9.basename(dir);
   console.log(`
 claude-alarm init for "${projectName}"
 `);
@@ -2427,11 +2602,11 @@ claude-alarm init for "${projectName}"
     if (port) env.CLAUDE_ALARM_HUB_PORT = port;
     if (token) env.CLAUDE_ALARM_HUB_TOKEN = token;
   }
-  const mcpPath = path8.join(dir, ".mcp.json");
+  const mcpPath = path9.join(dir, ".mcp.json");
   let mcpConfig = {};
-  if (fs7.existsSync(mcpPath)) {
+  if (fs8.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs7.readFileSync(mcpPath, "utf-8"));
+      mcpConfig = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
     } catch {
       mcpConfig = {};
     }
@@ -2442,7 +2617,7 @@ claude-alarm init for "${projectName}"
     args: ["-y", "@delt/claude-alarm", "serve"],
     env
   };
-  fs7.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  fs8.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(`
 \u2713 Created ${mcpPath}`);
   if (remote.toLowerCase() !== "y") {
@@ -2463,6 +2638,11 @@ claude-alarm init for "${projectName}"
       console.log(`  claude-alarm hub start`);
     }
     console.log(`  Dashboard: http://${displayHost}:${port}`);
+    if (shouldOfferCodex(config2, findOnPath("codex") !== void 0)) {
+      const answer = await ask("\nCodex is installed. Show Codex conversations on the dashboard too? (y/N): ");
+      if (answer.toLowerCase() === "y") codexEnable(true);
+      else setCodexEnabled(false);
+    }
   }
   console.log(`
 Next step:`);
@@ -2488,8 +2668,8 @@ function isProcessRunning(pid) {
   }
 }
 function readCodexPid() {
-  if (!fs7.existsSync(CODEX_PID_FILE)) return void 0;
-  const pid = parseInt(fs7.readFileSync(CODEX_PID_FILE, "utf-8").trim(), 10);
+  if (!fs8.existsSync(CODEX_PID_FILE)) return void 0;
+  const pid = parseInt(fs8.readFileSync(CODEX_PID_FILE, "utf-8").trim(), 10);
   return Number.isNaN(pid) ? void 0 : pid;
 }
 function codexEnable(enabled) {
@@ -2503,8 +2683,8 @@ function codexStart() {
     return;
   }
   ensureConfigDir();
-  const logFd = fs7.openSync(CODEX_LOG_FILE, "a");
-  const child = spawn2(process.execPath, [path8.join(__dirname2, "codex", "main.js")], {
+  const logFd = fs8.openSync(CODEX_LOG_FILE, "a");
+  const child = spawn3(process.execPath, [path9.join(__dirname2, "codex", "main.js")], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env }
@@ -2525,7 +2705,7 @@ function codexStop() {
     console.log("Codex adapter process not found (may have already stopped)");
   }
   try {
-    fs7.unlinkSync(CODEX_PID_FILE);
+    fs8.unlinkSync(CODEX_PID_FILE);
   } catch {
   }
 }