@delt/claude-alarm 1.2.0 → 1.4.0

package/dist/cli.js

@@ -301,7 +301,7 @@ var init_session_manager = __esm({
 
 // src/hub/notifier.ts
 import notifier from "node-notifier";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 var Notifier;
 var init_notifier = __esm({
   "src/hub/notifier.ts"() {
@@ -362,7 +362,7 @@ var init_notifier = __esm({
       }
       checkWindowsNotifications() {
         return new Promise((resolve) => {
-          execFile(
+          execFile2(
             "powershell",
             ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
             { windowsHide: true },
@@ -383,7 +383,7 @@ var init_notifier = __esm({
         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"], { windowsHide: true });
+          execFile2("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
         }
         setTimeout(() => {
           this.notificationSettingsOpened = false;
@@ -439,10 +439,13 @@ var init_permission_key = __esm({
 });
 
 // src/hub/telegram.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-var TELEGRAM_API, MAX_CHOICE_MESSAGES, TelegramBot;
+function visibleLength(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/&(?:amp|lt|gt);/g, "&").length;
+}
+var TELEGRAM_API, MAX_CHOICE_MESSAGES, MAX_SELECTIONS, MAX_VISIBLE_CHARS, TRUNCATED, MAX_PHOTO_BYTES, NO_LONGER_CONNECTED, TelegramBot;
 var init_telegram = __esm({
   "src/hub/telegram.ts"() {
     "use strict";
@@ -452,6 +455,11 @@ var init_telegram = __esm({
     init_permission_key();
     TELEGRAM_API = "https://api.telegram.org/bot";
     MAX_CHOICE_MESSAGES = 200;
+    MAX_SELECTIONS = 20;
+    MAX_VISIBLE_CHARS = 4e3;
+    TRUNCATED = "\u2026(truncated)";
+    MAX_PHOTO_BYTES = 10 * 1024 * 1024;
+    NO_LONGER_CONNECTED = "the session is no longer connected";
     TelegramBot = class _TelegramBot {
       config;
       offset = 0;
@@ -472,9 +480,9 @@ var init_telegram = __esm({
       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(config2) {
         this.config = config2;
       }
@@ -483,8 +491,7 @@ var init_telegram = __esm({
       }
       /** Send a notification message to Telegram */
       async sendNotification(sessionId2, _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, sessionId2);
@@ -496,6 +503,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 {
@@ -577,6 +603,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 sessionId2 = this.messageSessionMap.get(msg.reply_to_message.message_id);
           if (sessionId2) {
@@ -590,18 +623,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.");
               }
@@ -622,16 +651,19 @@ ${this.mdToHtml(message)}`;
           }
           return;
         }
+        const selectionId = randomUUID2().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) {
@@ -640,50 +672,75 @@ ${this.mdToHtml(message)}`;
         this.sendMessage("Multiple sessions active. Select one:", void 0, { inline_keyboard: rows });
       }
       deliverToSession(sessionId2, content) {
-        if (this.onMessageToSession) {
-          this.onMessageToSession(sessionId2, content);
-        }
+        const delivered = this.onMessageToSession?.(sessionId2, content) === true;
+        if (!delivered) void this.sendMessage(`Not delivered: ${NO_LONGER_CONNECTED}`);
+        return delivered;
+      }
+      async deliverPending(sessionId2, pending) {
+        if (pending.photoFileId) return this.deliverPhotoToSessionByFileId(sessionId2, pending.photoFileId, pending.caption);
+        return pending.text ? this.deliverToSession(sessionId2, pending.text) : false;
       }
       async deliverPhotoToSession(sessionId2, photos, caption) {
         const largest = photos[photos.length - 1];
-        await this.deliverPhotoToSessionByFileId(sessionId2, largest.file_id, caption);
+        return this.deliverPhotoToSessionByFileId(sessionId2, largest.file_id, caption);
       }
       async deliverPhotoToSessionByFileId(sessionId2, 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";
-          fs4.mkdirSync(UPLOADS_DIR, { recursive: true });
+          fs5.mkdirSync(UPLOADS_DIR, { recursive: true });
           const filename = `${randomUUID2()}.${ext}`;
-          const filePath = path5.join(UPLOADS_DIR, filename);
-          fs4.writeFileSync(filePath, buffer);
+          const filePath = path6.join(UPLOADS_DIR, filename);
+          fs5.writeFileSync(filePath, buffer);
           logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
-          if (this.onImageToSession) {
-            this.onImageToSession(sessionId2, filePath, mimeType, caption);
+          let accepted = false;
+          try {
+            accepted = this.onImageToSession?.(sessionId2, filePath, mimeType, caption) === true;
+          } catch (err) {
+            logger.warn(`Telegram photo hand-off failed: ${err.message}`);
+          }
+          if (!accepted) {
+            try {
+              fs5.unlinkSync(filePath);
+            } catch {
+            }
+            this.photoNotDelivered(NO_LONGER_CONNECTED);
+            return false;
           }
           setTimeout(() => {
             try {
-              fs4.unlinkSync(filePath);
+              fs5.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];
@@ -797,7 +854,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);
@@ -826,10 +883,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;
@@ -852,21 +913,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) {
@@ -884,6 +946,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`, {
@@ -928,8 +1005,8 @@ ${label}`);
         css: "css",
         scss: "scss"
       };
-      langOf(path11) {
-        const m = /\.([a-z0-9]+)$/i.exec(path11 || "");
+      langOf(path12) {
+        const m = /\.([a-z0-9]+)$/i.exec(path12 || "");
         return m ? _TelegramBot.LANG_BY_EXT[m[1].toLowerCase()] ?? "" : "";
       }
       /** Convert markdown to Telegram HTML (escape first, then apply formatting) */
@@ -976,10 +1053,15 @@ ${bodyLines.join("\n")}`;
 
 // src/hub/codex-supervisor.ts
 import { spawn as spawn2 } from "child_process";
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function resolveAdapterScript(baseDir) {
-  return [path6.join(baseDir, "..", "codex", "main.js"), path6.join(baseDir, "codex", "main.js")].find((p) => fs5.existsSync(p));
+  return [path7.join(baseDir, "..", "codex", "main.js"), path7.join(baseDir, "codex", "main.js")].find((p) => fs6.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 HEALTHY_RUN_MS, CodexSupervisor;
 var init_codex_supervisor = __esm({
@@ -988,18 +1070,24 @@ var init_codex_supervisor = __esm({
     init_logger();
     HEALTHY_RUN_MS = 6e4;
     CodexSupervisor = class {
-      constructor(script, spawnFn = spawn2, 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 ?? spawn2;
+        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();
@@ -1021,7 +1109,8 @@ var init_codex_supervisor = __esm({
         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));
@@ -1058,15 +1147,15 @@ var init_entry = __esm({
 });
 
 // src/hub/auth.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 function safeEqual(a, b) {
   if (typeof a !== "string") return false;
   const x = Buffer.from(a);
   const y = Buffer.from(b);
-  return x.length === y.length && crypto.timingSafeEqual(x, y);
+  return x.length === y.length && crypto2.timingSafeEqual(x, y);
 }
 function dashboardCookieValue(token) {
-  return crypto.createHmac("sha256", token).update("claude-alarm-dashboard").digest("hex");
+  return crypto2.createHmac("sha256", token).update("claude-alarm-dashboard").digest("hex");
 }
 function parseCookies(header) {
   const out = {};
@@ -1126,8 +1215,8 @@ __export(server_exports, {
   HubServer: () => HubServer
 });
 import http from "http";
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 import { randomUUID as randomUUID3 } from "crypto";
@@ -1153,7 +1242,7 @@ var init_server = __esm({
     init_entry();
     init_hub_url();
     init_auth();
-    __dirname = path7.dirname(fileURLToPath(import.meta.url));
+    __dirname = path8.dirname(fileURLToPath(import.meta.url));
     MAX_WS_PAYLOAD = 16 * 1024 * 1024;
     nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
     HubServer = class {
@@ -1374,23 +1463,23 @@ var init_server = __esm({
           return;
         }
         const candidates = [
-          path7.join(__dirname, "..", "dashboard", "index.html"),
+          path8.join(__dirname, "..", "dashboard", "index.html"),
           // from dist/hub/
-          path7.join(__dirname, "dashboard", "index.html"),
+          path8.join(__dirname, "dashboard", "index.html"),
           // from dist/ (bundled index.js)
-          path7.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+          path8.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
           // from dist/hub/ -> src/
-          path7.join(__dirname, "..", "src", "dashboard", "index.html"),
+          path8.join(__dirname, "..", "src", "dashboard", "index.html"),
           // from dist/ -> src/
-          path7.join(process.cwd(), "dist", "dashboard", "index.html"),
+          path8.join(process.cwd(), "dist", "dashboard", "index.html"),
           // from cwd
-          path7.join(process.cwd(), "src", "dashboard", "index.html")
+          path8.join(process.cwd(), "src", "dashboard", "index.html")
           // from cwd/src
         ];
         logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
         for (const candidate of candidates) {
-          if (fs6.existsSync(candidate)) {
-            const html = fs6.readFileSync(candidate, "utf-8");
+          if (fs7.existsSync(candidate)) {
+            const html = fs7.readFileSync(candidate, "utf-8");
             res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
             res.end(html);
             return;
@@ -1540,7 +1629,16 @@ var init_server = __esm({
             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,
@@ -1742,9 +1840,14 @@ var init_server = __esm({
               const channelWs = this.channelSockets.get(msg.sessionId);
               if (channelWs?.readyState === WebSocket2.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 === WebSocket2.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;
@@ -1795,27 +1898,38 @@ var init_server = __esm({
           }
         }
       }
-      handleImageUpload(msg) {
+      handleImageUpload(ws, msg) {
         const { sessionId: sessionId2, imageData, mimeType, originalName, content } = msg;
+        const reject = (reason) => {
+          logger.warn(`Image upload rejected for ${sessionId2}: ${reason}`);
+          const rejected = { type: "upload_rejected", sessionId: sessionId2, reason, withText: typeof content === "string" && content.trim().length > 0 };
+          if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify(rejected));
+        };
+        const channelWs = this.channelSockets.get(sessionId2);
+        if (!channelWs || channelWs.readyState !== WebSocket2.OPEN) {
+          reject("the session is not connected");
+          return;
+        }
         if (!this.localChannels.has(sessionId2)) {
-          logger.warn(`Image upload rejected: session ${sessionId2} 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(sessionId2);
-        if (!channelWs || channelWs.readyState !== WebSocket2.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;
         }
-        fs6.mkdirSync(UPLOADS_DIR, { recursive: true });
+        fs7.mkdirSync(UPLOADS_DIR, { recursive: true });
         const ext = mimeType.split("/")[1] === "jpeg" ? "jpg" : mimeType.split("/")[1];
         const filename = `${randomUUID3()}.${ext}`;
-        const filePath = path7.join(UPLOADS_DIR, filename);
-        fs6.writeFileSync(filePath, buffer);
+        const filePath = path8.join(UPLOADS_DIR, filename);
+        fs7.writeFileSync(filePath, buffer);
         const forwardMsg = {
           type: "image_to_session",
           sessionId: sessionId2,
@@ -1829,7 +1943,7 @@ var init_server = __esm({
         logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
         setTimeout(() => {
           try {
-            fs6.unlinkSync(filePath);
+            fs7.unlinkSync(filePath);
           } catch {
           }
         }, 5 * 60 * 1e3).unref();
@@ -1856,19 +1970,25 @@ var init_server = __esm({
         this.telegramBot.getSessions = () => this.sessions.getAll();
         this.telegramBot.onMessageToSession = (sessionId2, content) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          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}`);
+          if (channelWs?.readyState !== WebSocket2.OPEN) {
+            logger.warn(`Telegram message not delivered to ${sessionId2}: the session is not connected`);
+            return false;
           }
+          const msg = { type: "message_to_session", sessionId: sessionId2, content, source: "telegram" };
+          channelWs.send(JSON.stringify(msg));
+          logger.info(`Telegram message forwarded to session: ${sessionId2}`);
+          return true;
         };
         this.telegramBot.onImageToSession = (sessionId2, imagePath, mimeType, caption) => {
           const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket2.OPEN) {
-            const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption, source: "telegram" };
-            channelWs.send(JSON.stringify(msg));
-            logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
+          if (channelWs?.readyState !== WebSocket2.OPEN) {
+            logger.warn(`Telegram photo not delivered to ${sessionId2}: the session is not connected`);
+            return false;
           }
+          const msg = { type: "image_to_session", sessionId: sessionId2, imagePath, mimeType, content: caption, source: "telegram" };
+          channelWs.send(JSON.stringify(msg));
+          logger.info(`Telegram photo forwarded to session: ${sessionId2}`);
+          return true;
         };
         this.telegramBot.onPermissionVerdict = (sessionId2, requestId, behavior) => {
           if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, behavior })) {
@@ -1993,7 +2113,7 @@ var init_server = __esm({
           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");
       }
@@ -2020,11 +2140,11 @@ var init_server = __esm({
       }
       cleanupUploads() {
         try {
-          if (!fs6.existsSync(UPLOADS_DIR)) return;
-          const files = fs6.readdirSync(UPLOADS_DIR);
+          if (!fs7.existsSync(UPLOADS_DIR)) return;
+          const files = fs7.readdirSync(UPLOADS_DIR);
           for (const file of files) {
             try {
-              fs6.unlinkSync(path7.join(UPLOADS_DIR, file));
+              fs7.unlinkSync(path8.join(UPLOADS_DIR, file));
             } catch {
             }
           }
@@ -2223,9 +2343,9 @@ var init_hub_client = __esm({
 });
 
 // src/channel/peer-name.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os2 from "os";
-import path8 from "path";
+import path9 from "path";
 function findPeerName(records, env) {
   const valid = records.filter((r) => typeof r === "object" && r !== null);
   const nameOf = (match) => {
@@ -2245,18 +2365,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 || path8.join(os2.homedir(), ".claude");
-  const dir = path8.join(configDir, "sessions");
+  const configDir = env.CLAUDE_CONFIG_DIR || path9.join(os2.homedir(), ".claude");
+  const dir = path9.join(configDir, "sessions");
   let files;
   try {
-    files = fs7.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    files = fs8.readdirSync(dir).filter((f) => f.endsWith(".json"));
   } catch {
     return void 0;
   }
   const records = [];
   for (const f of files) {
     try {
-      records.push(JSON.parse(fs7.readFileSync(path8.join(dir, f), "utf8")));
+      records.push(JSON.parse(fs8.readFileSync(path9.join(dir, f), "utf8")));
     } catch {
     }
   }
@@ -2279,7 +2399,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { randomUUID as randomUUID4 } from "crypto";
-import path9 from "path";
+import path10 from "path";
 async function main() {
   logger.info(`Starting MCP channel server (session: ${sessionId})`);
   hubClient.connect();
@@ -2348,7 +2468,7 @@ var init_server2 = __esm({
     init_hub_client();
     init_peer_name2();
     sessionId = randomUUID4();
-    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path9.basename(process.cwd());
+    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path10.basename(process.cwd());
     peerName = readPeerName();
     server = new Server(
       {
@@ -2525,20 +2645,21 @@ NOTIFICATIONS:
 // src/cli.ts
 init_config();
 import { spawn as spawn3 } from "child_process";
-import fs8 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path11 from "path";
 import readline from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/codex/transport.ts
 init_logger();
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import fs2 from "fs";
 import path3 from "path";
 import { Duplex } from "stream";
 import WebSocket from "ws";
 function resolveCommand(command, platform = process.platform, env = process.env) {
-  if (platform !== "win32" || /[\\/]/.test(command) || path3.extname(command)) return { file: command, shell: false };
+  if (platform !== "win32") return { file: command, shell: false };
+  if (/[\\/]/.test(command) || path3.extname(command)) return { file: command, shell: /\.(cmd|bat)$/i.test(command) };
   const file = findCodex(command, platform, env);
   return file ? { file, shell: file.endsWith(".cmd") } : { file: command, shell: false };
 }
@@ -2561,13 +2682,116 @@ function findCodex(command, platform = process.platform, env = process.env) {
   ];
   return candidates.find((file) => !!file && fs2.existsSync(file));
 }
+var shellSpawns = /* @__PURE__ */ new WeakSet();
+var spawnedThroughShell = (child) => shellSpawns.has(child);
 var defaultSpawn = (command, args) => {
   const { file, shell } = resolveCommand(command);
-  if (shell) return spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
-  return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  if (!shell) return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  const child = spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
+  shellSpawns.add(child);
+  return child;
+};
+var queryProcesses = () => new Promise((resolve, reject) => {
+  const script = "@(Get-CimInstance Win32_Process | ForEach-Object { [pscustomobject]@{ pid = [int]$_.ProcessId; parentPid = [int]$_.ParentProcessId; creationTime = $_.CreationDate.ToUniversalTime().ToString('o') } }) | ConvertTo-Json -Compress";
+  execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { windowsHide: true, timeout: 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    try {
+      const rows = JSON.parse(stdout);
+      if (!Array.isArray(rows) || rows.some((row) => !Number.isInteger(row.pid) || !Number.isInteger(row.parentPid) || typeof row.creationTime !== "string")) {
+        throw new Error("invalid process snapshot");
+      }
+      resolve(rows);
+    } catch (error) {
+      reject(error);
+    }
+  });
+});
+var runFile = (file, args, options, callback) => {
+  execFile(file, args, options, (err) => callback(err));
 };
-function connectProxy(command, spawnFn = defaultSpawn) {
+function descendantsOf(rootPid, rows) {
+  const root = rows.find((row) => row.pid === rootPid);
+  if (!root) return void 0;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set([root.pid]);
+  let level = [root];
+  for (let depth = 1; level.length; depth++) {
+    const next = [];
+    for (const parent of level) {
+      for (const row of rows) {
+        if (row.parentPid !== parent.pid || seen.has(row.pid) || row.creationTime < parent.creationTime) continue;
+        seen.add(row.pid);
+        next.push(row);
+        found.push({ ...row, depth });
+      }
+    }
+    level = next;
+  }
+  return found;
+}
+var exited = (child) => child.exitCode !== null || child.signalCode !== null;
+function treeKiller(platform = process.platform, run = runFile, query = queryProcesses, throughShell = spawnedThroughShell) {
+  const recorded = /* @__PURE__ */ new WeakMap();
+  const stop = (pid) => new Promise((resolve) => {
+    run("taskkill", ["/PID", String(pid), "/F"], { windowsHide: true }, (err) => {
+      if (err) logger.debug(`taskkill ${pid} failed: ${err.message}`);
+      resolve();
+    });
+  });
+  const stopDeepestFirst = async (descendants) => {
+    for (const descendant of [...descendants].sort((a, b) => b.depth - a.depth)) await stop(descendant.pid);
+  };
+  const snapshot = async () => {
+    try {
+      return await query();
+    } catch (err) {
+      logger.debug(`codex process query failed: ${String(err)}`);
+      return void 0;
+    }
+  };
+  const isShellTree = (child) => platform === "win32" && child.pid !== void 0 && throughShell(child);
+  const killer = async (child) => {
+    if (!isShellTree(child)) {
+      if (!exited(child)) child.kill();
+      return;
+    }
+    if (!exited(child)) {
+      const rows = await snapshot();
+      if (!exited(child)) {
+        const descendants2 = rows && descendantsOf(child.pid, rows);
+        if (descendants2) await stopDeepestFirst(descendants2);
+        child.kill();
+        return;
+      }
+    }
+    const descendants = await recorded.get(child) ?? [];
+    if (!descendants.length) return;
+    const current = await snapshot();
+    if (!current) return;
+    await stopDeepestFirst(descendants.filter((d) => current.some((row) => row.pid === d.pid && row.creationTime === d.creationTime)));
+  };
+  killer.track = async (child) => {
+    if (!isShellTree(child) || exited(child)) return;
+    const earlier = recorded.get(child);
+    const latest = (async () => {
+      const rows = await snapshot();
+      const found = rows && !exited(child) ? descendantsOf(child.pid, rows) ?? [] : [];
+      const before = await earlier ?? [];
+      return [...before, ...found.filter((d) => !before.some((b) => b.pid === d.pid && b.creationTime === d.creationTime))];
+    })();
+    recorded.set(child, latest);
+    await latest;
+  };
+  return killer;
+}
+var killTree = treeKiller();
+var HANDSHAKE_TIMEOUT_MS = 1e4;
+function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIMEOUT_MS, killTreeFn = killTree) {
   const child = spawnFn(command, ["app-server", "proxy"]);
+  void killTreeFn.track?.(child);
   child.stdin?.on("error", () => {
   });
   child.stderr?.on("data", (d) => logger.debug(`codex proxy: ${String(d).trim()}`));
@@ -2594,17 +2818,20 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   const ws = new WebSocket("ws://localhost/", {
     createConnection: (() => stream)
   });
-  const close = () => {
+  let closing;
+  const close = () => closing ??= (async () => {
     ws.terminate();
-    child.kill();
-  };
+    child.stdin?.end();
+    await killTreeFn(child);
+  })();
   return new Promise((resolve, reject) => {
     let settled = false;
+    const timer = setTimeout(() => fail(new Error(`codex daemon did not answer within ${timeoutMs / 1e3}s`)), timeoutMs);
     const fail = (err) => {
       if (settled) return;
       settled = true;
-      close();
-      reject(err);
+      clearTimeout(timer);
+      void close().then(() => reject(err), () => reject(err));
     };
     child.on("error", fail);
     child.once("exit", (code) => fail(new Error(`codex proxy exited (code ${code})`)));
@@ -2612,8 +2839,10 @@ function connectProxy(command, spawnFn = defaultSpawn) {
     ws.once("open", () => {
       if (settled) return;
       settled = true;
+      clearTimeout(timer);
       child.on("error", (err) => logger.warn(`codex proxy error: ${err.message}`));
       ws.on("error", (err) => logger.warn(`codex daemon socket error: ${err.message}`));
+      void killTreeFn.track?.(child);
       resolve({ ws, close });
     });
   });
@@ -2905,7 +3134,7 @@ async function runCodexTask(opts) {
     };
   } finally {
     for (const t of timers) clearTimeout(t);
-    conn.close();
+    await conn.close();
   }
 }
 var VALUE_FLAGS = {
@@ -3025,7 +3254,7 @@ function resolveAdapterHub(config2, env = process.env) {
 // src/codex/start-check.ts
 var ADAPTER_REPORT_TIMEOUT_MS = 1e4;
 var HUB_CHECK_TIMEOUT_MS = 3e3;
-var RESTART_HINT = "After fixing this, restart the adapter: claude-alarm codex stop, then claude-alarm codex start";
+var RESTART_HINT = "After fixing this, restart the adapter: claude-alarm codex stop, then claude-alarm codex start (if the hub started the adapter, restart the hub instead)";
 var CONFIG_PATH = "~/.claude-alarm/config.json";
 var NOT_CHECKED = { text: "Codex daemon: not checked (the adapter was already running)", warning: false };
 function toOutcome(msg) {
@@ -3042,9 +3271,11 @@ function waitForAdapterReport(child, timeoutMs = ADAPTER_REPORT_TIMEOUT_MS) {
       resolve(result);
     };
     const onMessage = (msg) => {
-      if (msg && typeof msg === "object" && msg.type === "codex-first-connect") {
-        finish({ kind: "report", outcome: toOutcome(msg) });
-      }
+      if (!msg || typeof msg !== "object") return;
+      const m = msg;
+      if (m.type === "codex-first-connect") finish({ kind: "report", outcome: toOutcome(m) });
+      else if (m.type === "codex-already-running" && Number.isInteger(m.pid)) finish({ kind: "already", pid: m.pid });
+      else if (m.type === "codex-lock-failed") finish({ kind: "lockFailed", error: String(m.error ?? "") });
     };
     const onExit = (code, signal) => finish({ kind: "exited", code, signal });
     const onError = (error) => finish({ kind: "exited", code: null, signal: null, error });
@@ -3124,9 +3355,9 @@ function printAlreadyRunning(d, pid, hub) {
   printChecks(d, NOT_CHECKED, hubLine(hub, d.hub));
 }
 async function startAdapter(d) {
-  const existing = d.readPid();
-  if (existing !== void 0 && d.isRunning(existing)) {
-    printAlreadyRunning(d, existing, await checkHub(d.hub, d.hubTimeoutMs));
+  const existing = await d.queryOwner();
+  if (existing.state === "running") {
+    printAlreadyRunning(d, existing.pid, await checkHub(d.hub, d.hubTimeoutMs));
     return 0;
   }
   const child = d.spawnAdapter();
@@ -3143,6 +3374,14 @@ async function startAdapter(d) {
   ]);
   if (child.connected) child.disconnect();
   child.unref();
+  if (report.kind === "already") {
+    printAlreadyRunning(d, report.pid, hub);
+    return 0;
+  }
+  if (report.kind === "lockFailed") {
+    d.err(`Codex adapter cannot start: ${report.error}`);
+    return 1;
+  }
   if (report.kind !== "exited" && !seen.exit && child.pid !== void 0) {
     d.out(`Codex adapter started (PID: ${child.pid}). Logs: ${d.logFile}`);
     printChecks(d, daemonLine(report, d.command, d.logFile), hubLine(hub, d.hub));
@@ -3153,10 +3392,9 @@ async function startAdapter(d) {
     d.err(`Codex adapter failed to start: ${exit?.error?.message ?? "no process id"}`);
     return 1;
   }
-  const owner = d.readPid();
-  if (owner !== void 0 && owner === child.pid) d.removePidFile();
-  else if (owner !== void 0 && d.isRunning(owner)) {
-    printAlreadyRunning(d, owner, hub);
+  const owner = await d.queryOwner();
+  if (owner.state === "running" && owner.pid !== child.pid) {
+    printAlreadyRunning(d, owner.pid, hub);
     return 0;
   }
   const how = exit.code !== null ? `code ${exit.code}` : `signal ${exit.signal}`;
@@ -3164,8 +3402,147 @@ async function startAdapter(d) {
   return 1;
 }
 
+// src/codex/instance-lock.ts
+import crypto from "crypto";
+import fs4 from "fs";
+import net2 from "net";
+import path5 from "path";
+var CONTROL_PROTOCOL = 1;
+var STOP_PROOF_LABEL = "claude-alarm codex stop";
+var MAX_LINE_BYTES = 4096;
+function stopProof(token) {
+  return crypto.createHmac("sha256", token).update(STOP_PROOF_LABEL).digest("hex");
+}
+function controlEndpoint(configDir, platform = process.platform) {
+  if (platform !== "win32") return path5.posix.join(configDir, "codex.sock");
+  let dir;
+  try {
+    dir = fs4.realpathSync.native(configDir);
+  } catch {
+    dir = path5.win32.resolve(configDir);
+  }
+  const hash = crypto.createHash("sha256").update(dir.toLowerCase()).digest("hex").slice(0, 16);
+  return `\\\\.\\pipe\\claude-alarm-codex-${hash}`;
+}
+function ask(endpoint, request, timeoutMs) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let settled = false;
+    const socket = net2.connect(endpoint);
+    const finish = (answer) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(answer);
+    };
+    const timer = setTimeout(() => finish({ state: "unknown", error: `no answer within ${timeoutMs}ms` }), timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(`${JSON.stringify(request)}
+`));
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const end = buffer.indexOf("\n");
+      if (end < 0) {
+        if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) finish({ state: "unknown", error: "reply too long" });
+        return;
+      }
+      try {
+        finish({ reply: JSON.parse(buffer.slice(0, end)) });
+      } catch {
+        finish({ state: "unknown", error: "unreadable reply" });
+      }
+    });
+    socket.on("end", () => finish({ state: "unknown", error: "closed without a reply" }));
+    socket.on("error", (err) => {
+      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") finish({ state: "absent" });
+      else finish({ state: "unknown", error: err.code ?? err.message });
+    });
+  });
+}
+async function queryOwner(endpoint, timeoutMs = 1e3) {
+  const answer = await ask(endpoint, { type: "status" }, timeoutMs);
+  if (!("reply" in answer)) return answer;
+  const reply = answer.reply;
+  if (reply?.type === "status" && reply.protocol === CONTROL_PROTOCOL && Number.isInteger(reply.pid)) {
+    return { state: "running", pid: reply.pid };
+  }
+  return { state: "unknown", error: "unexpected reply" };
+}
+async function requestStop(endpoint, token, timeoutMs = 1e3) {
+  const answer = await ask(endpoint, { type: "stop", proof: stopProof(token) }, timeoutMs);
+  if (!("reply" in answer)) return answer;
+  const reply = answer.reply;
+  if (reply?.type === "stopping" && Number.isInteger(reply.pid)) return { state: "stopping", pid: reply.pid };
+  if (reply?.type === "error" && reply.error === "unauthorized") return { state: "unauthorized" };
+  return { state: "unknown", error: "unexpected reply" };
+}
+
+// src/codex/control-cli.ts
+var STOP_WAIT_MS = 5e3;
+var STOP_POLL_MS = 100;
+function legacyNote(d, ownerPid) {
+  const pid = d.legacyPid();
+  if (pid === void 0 || pid === ownerPid) return;
+  if (!d.isRunning(pid)) {
+    d.removeLegacyPidFile();
+    return;
+  }
+  d.out(`Note: ${d.legacyPidFile} names a running process (PID: ${pid}). claude-alarm 1.2.0 and earlier wrote this file; if that process is an old Codex adapter, restart the hub or end it yourself.`);
+}
+function unavailable(d, error) {
+  d.err(`Codex adapter control endpoint is unavailable: ${error}`);
+  return 1;
+}
+async function stopAdapter(d, startWithHub) {
+  const owner = await d.queryOwner();
+  if (owner.state === "unknown") return unavailable(d, owner.error);
+  if (owner.state === "absent") {
+    d.out("Codex adapter is not running");
+    legacyNote(d);
+    return 0;
+  }
+  const reply = await d.requestStop();
+  if (reply.state === "unknown") return unavailable(d, reply.error);
+  if (reply.state === "unauthorized") {
+    d.err(`Codex adapter refused to stop: the token in ${d.configFile} does not match the one it started with`);
+    return 1;
+  }
+  if (reply.state === "absent") {
+    d.out("Codex adapter is not running");
+    return 0;
+  }
+  const sleep = d.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  for (let waited = 0; waited < (d.stopWaitMs ?? STOP_WAIT_MS); waited += STOP_POLL_MS) {
+    await sleep(STOP_POLL_MS);
+    const now = await d.queryOwner();
+    if (now.state === "absent" || now.state === "running" && now.pid !== reply.pid) {
+      d.out(`Codex adapter stopped (PID: ${reply.pid})`);
+      if (now.state === "running") d.out(`Another Codex adapter took over (PID: ${now.pid})`);
+      else if (startWithHub) d.out("If the hub started it, the hub will not start it again until you restart the hub.");
+      return 0;
+    }
+  }
+  d.err(`Stop requested, but the Codex adapter (PID: ${reply.pid}) is still running. Check with: claude-alarm codex status`);
+  return 1;
+}
+async function adapterStatus(d, startWithHub) {
+  const owner = await d.queryOwner();
+  if (owner.state === "running") {
+    d.out(`Codex adapter: running (PID: ${owner.pid})`);
+    legacyNote(d, owner.pid);
+  } else if (owner.state === "unknown") {
+    d.out(`Codex adapter: unknown (${owner.error})`);
+  } else {
+    d.out("Codex adapter: not running");
+    legacyNote(d);
+  }
+  d.out(`Start with hub: ${startWithHub ? "enabled" : "disabled"}`);
+  return 0;
+}
+
 // src/cli.ts
-var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path11.dirname(fileURLToPath2(import.meta.url));
 function authHeaders(token) {
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
@@ -3201,8 +3578,8 @@ Quick start:
 }
 async function checkForUpdates() {
   try {
-    const pkgPath = path10.join(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path11.join(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     const currentVersion = pkg.version;
     const res = await fetch("https://registry.npmjs.org/@delt/claude-alarm/latest", {
       signal: AbortSignal.timeout(3e3)
@@ -3225,18 +3602,18 @@ async function hubStart(daemon) {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = hubUrlHost(host);
   checkForUpdates();
-  if (fs8.existsSync(PID_FILE)) {
-    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs9.existsSync(PID_FILE)) {
+    const pid = parseInt(fs9.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;
     }
-    fs8.unlinkSync(PID_FILE);
+    fs9.unlinkSync(PID_FILE);
   }
   if (daemon) {
     ensureConfigDir();
-    const logFd = fs8.openSync(LOG_FILE, "a");
-    const hubScript = path10.join(__dirname2, "hub", "server.js");
+    const logFd = fs9.openSync(LOG_FILE, "a");
+    const hubScript = path11.join(__dirname2, "hub", "server.js");
     const child = spawn3(process.execPath, [hubScript], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
@@ -3247,21 +3624,21 @@ async function hubStart(daemon) {
       console.error("Failed to start hub daemon");
       process.exit(1);
     }
-    fs8.writeFileSync(PID_FILE, String(pid), "utf-8");
-    let exited = false;
+    fs9.writeFileSync(PID_FILE, String(pid), "utf-8");
+    let exited2 = false;
     child.once("exit", () => {
-      exited = true;
+      exited2 = true;
     });
     child.unref();
     const startup = await waitForHub({
       url: `http://${displayHost}:${port}/api/status`,
       token: config2.hub.token,
       pid,
-      isAlive: () => !exited
+      isAlive: () => !exited2
     });
     if (startup !== "ready") {
-      if (!exited) child.kill();
-      if (fs8.existsSync(PID_FILE)) fs8.unlinkSync(PID_FILE);
+      if (!exited2) child.kill();
+      if (fs9.existsSync(PID_FILE)) fs9.unlinkSync(PID_FILE);
       console.error(startup === "exited" ? `Hub exited during startup. See ${LOG_FILE}` : `Hub did not answer at http://${displayHost}:${port} within ${HUB_START_TIMEOUT_MS / 1e3}s and was stopped. See ${LOG_FILE}`);
       process.exit(1);
     }
@@ -3280,11 +3657,11 @@ async function hubStart(daemon) {
     const hub = new HubServer2(config2);
     await hub.start();
     ensureConfigDir();
-    fs8.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    fs9.writeFileSync(PID_FILE, String(process.pid), "utf-8");
     const shutdown = async () => {
       console.log("\nShutting down...");
       await hub.stop();
-      if (fs8.existsSync(PID_FILE)) fs8.unlinkSync(PID_FILE);
+      if (fs9.existsSync(PID_FILE)) fs9.unlinkSync(PID_FILE);
       process.exit(0);
     };
     process.on("SIGINT", shutdown);
@@ -3292,18 +3669,18 @@ async function hubStart(daemon) {
   }
 }
 function hubStop() {
-  if (!fs8.existsSync(PID_FILE)) {
+  if (!fs9.existsSync(PID_FILE)) {
     console.log("Hub is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const pid = parseInt(fs9.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)");
   }
-  fs8.unlinkSync(PID_FILE);
+  fs9.unlinkSync(PID_FILE);
 }
 async function hubStatus() {
   const config2 = loadConfig();
@@ -3311,8 +3688,8 @@ async function hubStatus() {
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
   const displayHost = hubUrlHost(host);
   let pidInfo = "not running";
-  if (fs8.existsSync(PID_FILE)) {
-    const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (fs9.existsSync(PID_FILE)) {
+    const pid = parseInt(fs9.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isProcessRunning(pid)) {
       pidInfo = `running (PID: ${pid})`;
     } else {
@@ -3373,7 +3750,7 @@ async function test() {
     console.error("Could not reach hub. Start it first: claude-alarm hub start");
   }
 }
-function ask(question) {
+function ask2(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -3384,18 +3761,18 @@ function ask(question) {
 }
 async function init() {
   const dir = process.cwd();
-  const projectName = path10.basename(dir);
+  const projectName = path11.basename(dir);
   console.log(`
 claude-alarm init for "${projectName}"
 `);
-  const remote = await ask("Connect to a remote hub? (y/N): ");
+  const remote = await ask2("Connect to a remote hub? (y/N): ");
   let env = {
     CLAUDE_ALARM_SESSION_NAME: projectName
   };
   if (remote.toLowerCase() === "y") {
-    const host = await ask("Hub host (e.g. 192.168.1.100): ");
-    const port = await ask("Hub port (default: 7900): ");
-    const token = await ask("Hub token: ");
+    const host = await ask2("Hub host (e.g. 192.168.1.100): ");
+    const port = await ask2("Hub port (default: 7900): ");
+    const token = await ask2("Hub token: ");
     if (!host) {
       console.error("Host is required.");
       process.exit(1);
@@ -3404,11 +3781,11 @@ claude-alarm init for "${projectName}"
     if (port) env.CLAUDE_ALARM_HUB_PORT = port;
     if (token) env.CLAUDE_ALARM_HUB_TOKEN = token;
   }
-  const mcpPath = path10.join(dir, ".mcp.json");
+  const mcpPath = path11.join(dir, ".mcp.json");
   let mcpConfig = {};
-  if (fs8.existsSync(mcpPath)) {
+  if (fs9.existsSync(mcpPath)) {
     try {
-      mcpConfig = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
+      mcpConfig = JSON.parse(fs9.readFileSync(mcpPath, "utf-8"));
     } catch {
       mcpConfig = {};
     }
@@ -3419,7 +3796,7 @@ claude-alarm init for "${projectName}"
     args: ["-y", "@delt/claude-alarm", "serve"],
     env
   };
-  fs8.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+  fs9.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
   console.log(`
 \u2713 Created ${mcpPath}`);
   if (remote.toLowerCase() !== "y") {
@@ -3441,7 +3818,7 @@ claude-alarm init for "${projectName}"
     }
     console.log(`  Dashboard: http://${displayHost}:${port}`);
     if (shouldOfferCodex(config2, findCodex("codex") !== void 0)) {
-      const answer = await ask("\nCodex is installed. Show Codex conversations on the dashboard too? (y/N): ");
+      const answer = await ask2("\nCodex is installed. Show Codex conversations on the dashboard too? (y/N): ");
       if (answer.toLowerCase() === "y") codexEnable(true);
       else setCodexEnabled(false);
     }
@@ -3470,8 +3847,8 @@ function isProcessRunning(pid) {
   }
 }
 function readCodexPid() {
-  if (!fs8.existsSync(CODEX_PID_FILE)) return void 0;
-  const pid = parseInt(fs8.readFileSync(CODEX_PID_FILE, "utf-8").trim(), 10);
+  if (!fs9.existsSync(CODEX_PID_FILE)) return void 0;
+  const pid = parseInt(fs9.readFileSync(CODEX_PID_FILE, "utf-8").trim(), 10);
   return Number.isNaN(pid) ? void 0 : pid;
 }
 function codexEnable(enabled) {
@@ -3481,21 +3858,15 @@ function codexEnable(enabled) {
 async function codexStart() {
   const config2 = loadConfig();
   ensureConfigDir();
+  legacyNote(controlDeps());
   const code = await startAdapter({
     hub: resolveAdapterHub(config2),
     command: config2.codex?.command ?? "codex",
     logFile: CODEX_LOG_FILE,
-    readPid: readCodexPid,
-    isRunning: isProcessRunning,
-    removePidFile: () => {
-      try {
-        fs8.unlinkSync(CODEX_PID_FILE);
-      } catch {
-      }
-    },
+    queryOwner: () => queryOwner(controlEndpoint(CONFIG_DIR)),
     spawnAdapter: () => {
-      const logFd = fs8.openSync(CODEX_LOG_FILE, "a");
-      return spawn3(process.execPath, [path10.join(__dirname2, "codex", "main.js")], {
+      const logFd = fs9.openSync(CODEX_LOG_FILE, "a");
+      return spawn3(process.execPath, [path11.join(__dirname2, "codex", "main.js")], {
         detached: true,
         stdio: ["ignore", logFd, logFd, "ipc"],
         windowsHide: true,
@@ -3507,28 +3878,25 @@ async function codexStart() {
   });
   if (code !== 0) process.exit(code);
 }
-function codexStop() {
-  const pid = readCodexPid();
-  if (pid === void 0) {
-    console.log("Codex adapter is not running");
-    return;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-    console.log(`Codex adapter stopped (PID: ${pid})`);
-  } catch {
-    console.log("Codex adapter process not found (may have already stopped)");
-  }
-  try {
-    fs8.unlinkSync(CODEX_PID_FILE);
-  } catch {
-  }
-}
-function codexStatus() {
-  const pid = readCodexPid();
-  const state = pid === void 0 ? "not running" : isProcessRunning(pid) ? `running (PID: ${pid})` : "not running (stale PID file)";
-  console.log(`Codex adapter: ${state}`);
-  console.log(`Start with hub: ${loadConfig().codex?.enabled ? "enabled" : "disabled"}`);
+function controlDeps() {
+  const endpoint = controlEndpoint(CONFIG_DIR);
+  const token = loadConfig().hub.token ?? "";
+  return {
+    queryOwner: () => queryOwner(endpoint),
+    requestStop: () => requestStop(endpoint, token),
+    legacyPid: readCodexPid,
+    isRunning: isProcessRunning,
+    removeLegacyPidFile: () => {
+      try {
+        fs9.unlinkSync(CODEX_PID_FILE);
+      } catch {
+      }
+    },
+    legacyPidFile: CODEX_PID_FILE,
+    configFile: CONFIG_FILE,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line)
+  };
 }
 async function codexRun(argv) {
   const abort = new AbortController();
@@ -3537,7 +3905,7 @@ async function codexRun(argv) {
   process.on("SIGTERM", stop);
   try {
     return await runFromCli(argv, {
-      readFile: (file) => fs8.promises.readFile(file, "utf-8"),
+      readFile: (file) => fs9.promises.readFile(file, "utf-8"),
       readStdin: async () => {
         let text = "";
         for await (const chunk of process.stdin) text += chunk;
@@ -3588,8 +3956,8 @@ async function main2() {
     if (sub === "enable") codexEnable(true);
     else if (sub === "disable") codexEnable(false);
     else if (sub === "start") await codexStart();
-    else if (sub === "stop") codexStop();
-    else if (sub === "status") codexStatus();
+    else if (sub === "stop") process.exitCode = await stopAdapter(controlDeps(), loadConfig().codex?.enabled === true);
+    else if (sub === "status") process.exitCode = await adapterStatus(controlDeps(), loadConfig().codex?.enabled === true);
     else if (sub === "run") process.exitCode = await codexRun(args.slice(2));
     else {
       console.error(`Unknown codex command: ${sub}`);