@delt/claude-alarm 1.1.1 → 1.2.0

package/dist/cli.js

@@ -12,7 +12,7 @@ var __export = (target, all) => {
 // src/shared/constants.ts
 import path from "path";
 import os from "os";
-var DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, CONFIG_DIR, CONFIG_FILE, PID_FILE, LOG_FILE, UPLOADS_DIR, CODEX_PID_FILE, CODEX_LOG_FILE, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION;
+var DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, CONFIG_DIR, CONFIG_FILE, PID_FILE, LOG_FILE, UPLOADS_DIR, CODEX_PID_FILE, CODEX_LOG_FILE, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, WS_PATH_CODEX, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION;
 var init_constants = __esm({
   "src/shared/constants.ts"() {
     "use strict";
@@ -27,6 +27,7 @@ var init_constants = __esm({
     CODEX_LOG_FILE = path.join(CONFIG_DIR, "codex.log");
     WS_PATH_CHANNEL = "/ws/channel";
     WS_PATH_DASHBOARD = "/ws/dashboard";
+    WS_PATH_CODEX = "/ws/codex";
     CHANNEL_SERVER_NAME = "claude-alarm";
     CHANNEL_SERVER_VERSION = "0.1.0";
   }
@@ -201,6 +202,19 @@ var init_crash_guard = __esm({
   }
 });
 
+// src/shared/hub-url.ts
+import net from "net";
+function hubUrlHost(host) {
+  if (host === "" || host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return net.isIPv6(host) ? `[${host}]` : host;
+}
+var init_hub_url = __esm({
+  "src/shared/hub-url.ts"() {
+    "use strict";
+  }
+});
+
 // src/shared/peer-name.ts
 function isValidPeerName(name) {
   return typeof name === "string" && name.trim() !== "" && SAFE_PEER_NAME.test(name);
@@ -351,6 +365,7 @@ var init_notifier = __esm({
           execFile(
             "powershell",
             ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
+            { windowsHide: true },
             (err, stdout) => {
               if (err) {
                 resolve(true);
@@ -368,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"]);
+          execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
         }
         setTimeout(() => {
           this.notificationSettingsOpened = false;
@@ -425,7 +440,7 @@ var init_permission_key = __esm({
 
 // src/hub/telegram.ts
 import fs4 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var TELEGRAM_API, MAX_CHOICE_MESSAGES, TelegramBot;
 var init_telegram = __esm({
@@ -653,7 +668,7 @@ ${this.mdToHtml(message)}`;
           const mimeType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "webp" ? "image/webp" : "image/jpeg";
           fs4.mkdirSync(UPLOADS_DIR, { recursive: true });
           const filename = `${randomUUID2()}.${ext}`;
-          const filePath = path4.join(UPLOADS_DIR, filename);
+          const filePath = path5.join(UPLOADS_DIR, filename);
           fs4.writeFileSync(filePath, buffer);
           logger.info(`Telegram photo saved: ${filename} (${buffer.length} bytes)`);
           if (this.onImageToSession) {
@@ -913,8 +928,8 @@ ${label}`);
         css: "css",
         scss: "scss"
       };
-      langOf(path10) {
-        const m = /\.([a-z0-9]+)$/i.exec(path10 || "");
+      langOf(path11) {
+        const m = /\.([a-z0-9]+)$/i.exec(path11 || "");
         return m ? _TelegramBot.LANG_BY_EXT[m[1].toLowerCase()] ?? "" : "";
       }
       /** Convert markdown to Telegram HTML (escape first, then apply formatting) */
@@ -962,9 +977,9 @@ ${bodyLines.join("\n")}`;
 // src/hub/codex-supervisor.ts
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 function resolveAdapterScript(baseDir) {
-  return [path5.join(baseDir, "..", "codex", "main.js"), path5.join(baseDir, "codex", "main.js")].find((p) => fs5.existsSync(p));
+  return [path6.join(baseDir, "..", "codex", "main.js"), path6.join(baseDir, "codex", "main.js")].find((p) => fs5.existsSync(p));
 }
 var HEALTHY_RUN_MS, CodexSupervisor;
 var init_codex_supervisor = __esm({
@@ -1030,6 +1045,18 @@ var init_codex_supervisor = __esm({
   }
 });
 
+// src/shared/entry.ts
+function isEntryScript(argv1, suffixes) {
+  if (!argv1) return false;
+  const normalized = argv1.replace(/\\/g, "/");
+  return suffixes.some((suffix) => normalized.endsWith(suffix));
+}
+var init_entry = __esm({
+  "src/shared/entry.ts"() {
+    "use strict";
+  }
+});
+
 // src/hub/auth.ts
 import crypto from "crypto";
 function safeEqual(a, b) {
@@ -1100,7 +1127,7 @@ __export(server_exports, {
 });
 import http from "http";
 import fs6 from "fs";
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 import { randomUUID as randomUUID3 } from "crypto";
@@ -1109,7 +1136,7 @@ function validChoices(choices) {
   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 __dirname, MAX_WS_PAYLOAD, nonEmpty, HubServer;
 var init_server = __esm({
   "src/hub/server.ts"() {
     "use strict";
@@ -1123,9 +1150,12 @@ var init_server = __esm({
     init_session_label();
     init_crash_guard();
     init_permission_key();
+    init_entry();
+    init_hub_url();
     init_auth();
-    __dirname = path6.dirname(fileURLToPath(import.meta.url));
+    __dirname = path7.dirname(fileURLToPath(import.meta.url));
     MAX_WS_PAYLOAD = 16 * 1024 * 1024;
+    nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
     HubServer = class {
       httpServer;
       wssChannel;
@@ -1151,7 +1181,13 @@ var init_server = __esm({
       token;
       codexEnabled;
       codexSupervisor;
-      constructor(config2) {
+      wssCodex;
+      codexAdapters = /* @__PURE__ */ new Map();
+      codexAlive = /* @__PURE__ */ new WeakMap();
+      codexCallTimeoutMs;
+      codexCalls = /* @__PURE__ */ new Map();
+      constructor(config2, options = {}) {
+        this.codexCallTimeoutMs = options.codexCallTimeoutMs ?? 6e4;
         this.host = config2?.hub?.host ?? DEFAULT_HUB_HOST;
         this.port = config2?.hub?.port ?? DEFAULT_HUB_PORT;
         this.token = config2?.hub?.token;
@@ -1164,7 +1200,7 @@ var init_server = __esm({
         if (config2?.webhooks) {
           this.notifier.configure({ webhooks: config2.webhooks });
         }
-        const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+        const displayHost = hubUrlHost(this.host);
         this.notifier.configure({ dashboardUrl: `http://${displayHost}:${this.port}` });
         const fullConfig = loadConfig();
         if (fullConfig.telegram?.enabled && fullConfig.telegram.botToken && fullConfig.telegram.chatId) {
@@ -1177,6 +1213,9 @@ var init_server = __esm({
         this.wssDashboard = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
         this.wssDashboard.on("connection", (ws) => this.handleDashboardConnection(ws));
         this.wssDashboard.on("error", (err) => logger.warn(`Dashboard WebSocket server error: ${err.message}`));
+        this.wssCodex = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
+        this.wssCodex.on("connection", (ws, req) => this.handleCodexConnection(ws, req));
+        this.wssCodex.on("error", (err) => logger.warn(`Codex WebSocket server error: ${err.message}`));
         this.httpServer.on("upgrade", (req, socket, head) => {
           socket.on("error", (err) => logger.debug(`Upgrade socket error: ${err.message}`));
           const url = new URL(req.url ?? "/", "http://hub");
@@ -1197,6 +1236,10 @@ var init_server = __esm({
             this.wssDashboard.handleUpgrade(req, socket, head, (ws) => {
               this.wssDashboard.emit("connection", ws, req);
             });
+          } else if (pathname === WS_PATH_CODEX) {
+            this.wssCodex.handleUpgrade(req, socket, head, (ws) => {
+              this.wssCodex.emit("connection", ws, req);
+            });
           } else {
             socket.destroy();
           }
@@ -1211,7 +1254,7 @@ var init_server = __esm({
           this.httpServer.listen(this.port, this.host, () => {
             this.httpServer.removeListener("error", onStartupError);
             this.httpServer.on("error", (err) => logger.error(`HTTP server error: ${err.message}`));
-            const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+            const displayHost = hubUrlHost(this.host);
             logger.info(`Hub server listening on http://${displayHost}:${this.port}`);
             this.startCodexAdapter();
             resolve();
@@ -1226,10 +1269,12 @@ var init_server = __esm({
           if (this.telegramBot) this.telegramBot.stopPolling();
           for (const ws of this.channelSockets.values()) ws.terminate();
           for (const ws of this.dashboardSockets) ws.terminate();
+          for (const { ws } of this.codexAdapters.values()) ws.terminate();
           this.channelSockets.clear();
           this.dashboardSockets.clear();
           this.wssChannel.close();
           this.wssDashboard.close();
+          this.wssCodex.close();
           this.httpServer.close(() => {
             logger.info("Hub server stopped");
             resolve();
@@ -1294,6 +1339,12 @@ var init_server = __esm({
           this.handleApiSend(req, res);
         } else if (url.pathname === "/api/notify" && req.method === "POST") {
           this.handleApiNotify(req, res);
+        } else if (url.pathname === "/api/codex/folders" && req.method === "GET") {
+          this.handleCodexFolders(url, res);
+        } else if (url.pathname === "/api/codex/threads" && req.method === "POST") {
+          this.handleCodexCreate(req, res);
+        } else if (url.pathname === "/api/codex/threads/close" && req.method === "POST") {
+          this.handleCodexClose(req, res);
         } else if (url.pathname === "/api/webhooks" && req.method === "GET") {
           const config2 = loadConfig();
           this.jsonResponse(res, 200, { webhooks: config2.webhooks || [] });
@@ -1323,17 +1374,17 @@ var init_server = __esm({
           return;
         }
         const candidates = [
-          path6.join(__dirname, "..", "dashboard", "index.html"),
+          path7.join(__dirname, "..", "dashboard", "index.html"),
           // from dist/hub/
-          path6.join(__dirname, "dashboard", "index.html"),
+          path7.join(__dirname, "dashboard", "index.html"),
           // from dist/ (bundled index.js)
-          path6.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
+          path7.join(__dirname, "..", "..", "src", "dashboard", "index.html"),
           // from dist/hub/ -> src/
-          path6.join(__dirname, "..", "src", "dashboard", "index.html"),
+          path7.join(__dirname, "..", "src", "dashboard", "index.html"),
           // from dist/ -> src/
-          path6.join(process.cwd(), "dist", "dashboard", "index.html"),
+          path7.join(process.cwd(), "dist", "dashboard", "index.html"),
           // from cwd
-          path6.join(process.cwd(), "src", "dashboard", "index.html")
+          path7.join(process.cwd(), "src", "dashboard", "index.html")
           // from cwd/src
         ];
         logger.debug(`Dashboard candidates: ${JSON.stringify(candidates)}`);
@@ -1557,6 +1608,114 @@ var init_server = __esm({
           }
         }
       }
+      handleCodexConnection(ws, req) {
+        const isLocal = this.isLocalRequest(req);
+        let adapterId;
+        ws.on("error", (err) => {
+          logger.warn(`Codex adapter WebSocket error: ${err.message}`);
+          ws.terminate();
+        });
+        ws.on("pong", () => this.codexAlive.set(ws, true));
+        ws.on("message", (data) => {
+          let msg;
+          try {
+            msg = JSON.parse(data.toString());
+            if (msg === null || typeof msg !== "object") {
+              logger.warn("Invalid message from Codex adapter");
+              return;
+            }
+          } catch {
+            logger.warn("Invalid message from Codex adapter");
+            return;
+          }
+          if (msg.type === "adapter_hello") {
+            const a = msg.adapter;
+            if (typeof a?.id !== "string" || !a.id || typeof a.host !== "string") return;
+            if (adapterId && adapterId !== a.id) return;
+            const holder = this.codexAdapters.get(a.id);
+            if (holder && holder.ws !== ws) holder.ws.terminate();
+            if (!adapterId) logger.info(`Codex adapter connected: ${a.host} (${a.id}, local: ${isLocal})`);
+            adapterId = a.id;
+            this.codexAdapters.set(a.id, { ws, info: { id: a.id, host: a.host, ready: a.ready === true, isLocal } });
+            this.broadcastCodexAdapters();
+          } else if (msg.type === "adapter_result" && adapterId) {
+            const call = this.codexCalls.get(msg.requestId);
+            if (!call || call.adapterId !== adapterId) return;
+            call.settle(msg.ok ? { status: 200, body: msg.data } : { status: 422, body: { error: String(msg.error) } });
+          }
+        });
+        ws.on("close", () => {
+          if (!adapterId || this.codexAdapters.get(adapterId)?.ws !== ws) return;
+          this.codexAdapters.delete(adapterId);
+          for (const call of [...this.codexCalls.values()]) {
+            if (call.adapterId === adapterId) call.settle({ status: 502, body: { error: "Codex adapter disconnected" } });
+          }
+          logger.info(`Codex adapter disconnected: ${adapterId}`);
+          this.broadcastCodexAdapters();
+        });
+      }
+      callCodexAdapter(adapterId, call) {
+        const adapter = this.codexAdapters.get(adapterId);
+        if (!adapter || adapter.ws.readyState !== WebSocket2.OPEN) {
+          return Promise.resolve({ status: 404, body: { error: "Codex adapter is not connected" } });
+        }
+        const requestId = randomUUID3();
+        return new Promise((resolve) => {
+          const timer = setTimeout(
+            () => settle({ status: 504, body: { error: "Codex did not respond in time. The conversation may still appear." } }),
+            this.codexCallTimeoutMs
+          );
+          const settle = (outcome) => {
+            clearTimeout(timer);
+            this.codexCalls.delete(requestId);
+            resolve(outcome);
+          };
+          this.codexCalls.set(requestId, { adapterId, settle });
+          adapter.ws.send(JSON.stringify({ type: "adapter_call", requestId, call }));
+        });
+      }
+      async handleCodexFolders(url, res) {
+        const adapterId = url.searchParams.get("adapterId");
+        if (!nonEmpty(adapterId)) {
+          this.jsonResponse(res, 400, { error: "adapterId is required" });
+          return;
+        }
+        const out = await this.callCodexAdapter(adapterId, { kind: "folders" });
+        this.jsonResponse(res, out.status, out.body);
+      }
+      async handleCodexCreate(req, res) {
+        const body = await this.readBody(req);
+        const adapterId = body?.adapterId;
+        const cwd = body?.cwd;
+        if (!nonEmpty(adapterId) || !nonEmpty(cwd)) {
+          this.jsonResponse(res, 400, { error: "adapterId and cwd are required" });
+          return;
+        }
+        const out = await this.callCodexAdapter(adapterId, { kind: "create", cwd });
+        this.jsonResponse(res, out.status, out.body);
+      }
+      async handleCodexClose(req, res) {
+        const body = await this.readBody(req);
+        const sessionId2 = body?.sessionId;
+        if (!nonEmpty(sessionId2)) {
+          this.jsonResponse(res, 400, { error: "sessionId is required" });
+          return;
+        }
+        const session = this.sessions.get(sessionId2);
+        const ws = this.channelSockets.get(sessionId2);
+        if (session?.agentKind !== "codex" || !session.closable || ws?.readyState !== WebSocket2.OPEN) {
+          this.jsonResponse(res, 404, { error: "No closable Codex conversation" });
+          return;
+        }
+        ws.send(JSON.stringify({ type: "codex_close", sessionId: sessionId2 }));
+        this.jsonResponse(res, 200, { ok: true });
+      }
+      codexAdapterList() {
+        return [...this.codexAdapters.values()].map((a) => a.info);
+      }
+      broadcastCodexAdapters() {
+        this.broadcastToDashboards({ type: "codex_adapters", adapters: this.codexAdapterList() });
+      }
       // --- Dashboard WebSocket ---
       handleDashboardConnection(ws) {
         this.dashboardSockets.add(ws);
@@ -1575,6 +1734,7 @@ var init_server = __esm({
           requests: [...this.choiceRequests.values()].map((c) => c.request)
         };
         ws.send(JSON.stringify(pendingMsg));
+        ws.send(JSON.stringify({ type: "codex_adapters", adapters: this.codexAdapterList() }));
         ws.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
@@ -1654,7 +1814,7 @@ var init_server = __esm({
         fs6.mkdirSync(UPLOADS_DIR, { recursive: true });
         const ext = mimeType.split("/")[1] === "jpeg" ? "jpg" : mimeType.split("/")[1];
         const filename = `${randomUUID3()}.${ext}`;
-        const filePath = path6.join(UPLOADS_DIR, filename);
+        const filePath = path7.join(UPLOADS_DIR, filename);
         fs6.writeFileSync(filePath, buffer);
         const forwardMsg = {
           type: "image_to_session",
@@ -1662,7 +1822,8 @@ var init_server = __esm({
           imagePath: filePath,
           mimeType,
           originalName,
-          content
+          content,
+          source: "dashboard"
         };
         channelWs.send(JSON.stringify(forwardMsg));
         logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
@@ -1671,7 +1832,7 @@ var init_server = __esm({
             fs6.unlinkSync(filePath);
           } catch {
           }
-        }, 5 * 60 * 1e3);
+        }, 5 * 60 * 1e3).unref();
       }
       async handleWebhookSave(req, res) {
         const body = await this.readBody(req);
@@ -1704,7 +1865,7 @@ var init_server = __esm({
         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 };
+            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}`);
           }
@@ -1847,6 +2008,14 @@ var init_server = __esm({
             this.channelAlive.set(sessionId2, false);
             ws.ping();
           }
+          for (const { ws } of this.codexAdapters.values()) {
+            if (this.codexAlive.get(ws) === false) {
+              ws.terminate();
+              continue;
+            }
+            this.codexAlive.set(ws, false);
+            ws.ping();
+          }
         }, 3e4);
       }
       cleanupUploads() {
@@ -1855,7 +2024,7 @@ var init_server = __esm({
           const files = fs6.readdirSync(UPLOADS_DIR);
           for (const file of files) {
             try {
-              fs6.unlinkSync(path6.join(UPLOADS_DIR, file));
+              fs6.unlinkSync(path7.join(UPLOADS_DIR, file));
             } catch {
             }
           }
@@ -1909,7 +2078,7 @@ Content-Length: 0\r
         });
       }
     };
-    if (process.argv[1] && (process.argv[1].endsWith("hub/server.js") || process.argv[1].endsWith("hub/server.ts"))) {
+    if (isEntryScript(process.argv[1], ["/hub/server.js", "/hub/server.ts"])) {
       installCrashGuard("hub daemon");
       logStartup("Hub daemon");
       const config2 = loadConfig();
@@ -2056,7 +2225,7 @@ var init_hub_client = __esm({
 // src/channel/peer-name.ts
 import fs7 from "fs";
 import os2 from "os";
-import path7 from "path";
+import path8 from "path";
 function findPeerName(records, env) {
   const valid = records.filter((r) => typeof r === "object" && r !== null);
   const nameOf = (match) => {
@@ -2076,8 +2245,8 @@ 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 || path7.join(os2.homedir(), ".claude");
-  const dir = path7.join(configDir, "sessions");
+  const configDir = env.CLAUDE_CONFIG_DIR || path8.join(os2.homedir(), ".claude");
+  const dir = path8.join(configDir, "sessions");
   let files;
   try {
     files = fs7.readdirSync(dir).filter((f) => f.endsWith(".json"));
@@ -2087,7 +2256,7 @@ function readPeerName(env = process.env) {
   const records = [];
   for (const f of files) {
     try {
-      records.push(JSON.parse(fs7.readFileSync(path7.join(dir, f), "utf8")));
+      records.push(JSON.parse(fs7.readFileSync(path8.join(dir, f), "utf8")));
     } catch {
     }
   }
@@ -2110,7 +2279,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { randomUUID as randomUUID4 } from "crypto";
-import path8 from "path";
+import path9 from "path";
 async function main() {
   logger.info(`Starting MCP channel server (session: ${sessionId})`);
   hubClient.connect();
@@ -2179,7 +2348,7 @@ var init_server2 = __esm({
     init_hub_client();
     init_peer_name2();
     sessionId = randomUUID4();
-    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path8.basename(process.cwd());
+    sessionName = process.env.CLAUDE_ALARM_SESSION_NAME ?? path9.basename(process.cwd());
     peerName = readPeerName();
     server = new Server(
       {
@@ -2357,7 +2526,7 @@ NOTIFICATIONS:
 init_config();
 import { spawn as spawn3 } from "child_process";
 import fs8 from "fs";
-import path9 from "path";
+import path10 from "path";
 import readline from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -2368,6 +2537,11 @@ 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 };
+  const file = findCodex(command, platform, env);
+  return file ? { file, shell: file.endsWith(".cmd") } : { file: command, shell: false };
+}
 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"] : [""]) {
@@ -2378,12 +2552,620 @@ function findOnPath(command, platform = process.platform, env = process.env) {
   }
   return void 0;
 }
+function findCodex(command, platform = process.platform, env = process.env) {
+  const onPath = findOnPath(command, platform, env);
+  if (onPath || platform !== "win32") return onPath;
+  const candidates = [
+    env.LOCALAPPDATA && path3.join(env.LOCALAPPDATA, "Programs", "OpenAI", "Codex", "bin", `${command}.exe`),
+    env.APPDATA && path3.join(env.APPDATA, "npm", `${command}.cmd`)
+  ];
+  return candidates.find((file) => !!file && fs2.existsSync(file));
+}
+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 });
+};
+function connectProxy(command, spawnFn = defaultSpawn) {
+  const child = spawnFn(command, ["app-server", "proxy"]);
+  child.stdin?.on("error", () => {
+  });
+  child.stderr?.on("data", (d) => logger.debug(`codex proxy: ${String(d).trim()}`));
+  const stream = new Duplex({
+    read() {
+    },
+    write(chunk, _encoding, callback) {
+      if (child.stdin?.writable) child.stdin.write(chunk, callback);
+      else callback();
+    },
+    final(callback) {
+      child.stdin?.end();
+      callback();
+    }
+  });
+  child.stdout?.on("data", (d) => stream.push(d));
+  child.stdout?.on("end", () => stream.push(null));
+  Object.assign(stream, { setNoDelay() {
+  }, setTimeout() {
+  }, setKeepAlive() {
+  }, ref() {
+  }, unref() {
+  } });
+  const ws = new WebSocket("ws://localhost/", {
+    createConnection: (() => stream)
+  });
+  const close = () => {
+    ws.terminate();
+    child.kill();
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      close();
+      reject(err);
+    };
+    child.on("error", fail);
+    child.once("exit", (code) => fail(new Error(`codex proxy exited (code ${code})`)));
+    ws.on("error", fail);
+    ws.once("open", () => {
+      if (settled) return;
+      settled = true;
+      child.on("error", (err) => logger.warn(`codex proxy error: ${err.message}`));
+      ws.on("error", (err) => logger.warn(`codex daemon socket error: ${err.message}`));
+      resolve({ ws, close });
+    });
+  });
+}
+
+// src/codex/run.ts
+import path4 from "path";
+
+// src/codex/rpc.ts
+init_logger();
+import { EventEmitter } from "events";
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var RpcClient = class extends EventEmitter {
+  constructor(ws, timeoutMs = 3e4) {
+    super();
+    this.ws = ws;
+    this.timeoutMs = timeoutMs;
+    ws.on("message", (data) => this.onMessage(String(data)));
+    ws.on("close", () => {
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(new Error("connection closed"));
+      }
+      this.pending.clear();
+      this.emit("close");
+    });
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  request(method, params, timeoutMs = this.timeoutMs) {
+    if (this.ws.readyState !== this.ws.OPEN) return Promise.reject(new Error("connection closed"));
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs === null ? void 0 : setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify(params === void 0 ? { id, method } : { id, method, params }));
+    });
+  }
+  notify(method, params) {
+    if (this.ws.readyState !== this.ws.OPEN) return;
+    this.ws.send(JSON.stringify(params === void 0 ? { method } : { method, params }));
+  }
+  respond(id, result) {
+    if (this.ws.readyState !== this.ws.OPEN) return;
+    this.ws.send(JSON.stringify({ id, result }));
+  }
+  // ws stops reading the socket for good if a 'message' listener throws.
+  guarded(method, fn) {
+    try {
+      fn();
+    } catch (err) {
+      logger.warn(`Codex ${method} handling failed: ${err.message}`);
+    }
+  }
+  onMessage(text) {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!msg || typeof msg !== "object") return;
+    if (msg.method === void 0 && msg.id !== void 0) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      clearTimeout(p.timer);
+      if (msg.error) p.reject(new RpcError(msg.error.code, msg.error.message));
+      else p.resolve(msg.result);
+    } else if (msg.method !== void 0 && msg.id !== void 0) {
+      this.guarded(msg.method, () => this.emit("request", msg.id, msg.method, msg.params));
+    } else if (msg.method !== void 0) {
+      this.guarded(msg.method, () => this.emit("notification", msg.method, msg.params));
+    }
+  }
+};
+
+// src/codex/mapping.ts
+var SOURCE_LABEL = { dashboard: "Dashboard", telegram: "Telegram", api: "API" };
+var SOURCE_PREFIX = new RegExp(`^\\[claude-alarm(?: \xB7 (?:${Object.values(SOURCE_LABEL).join("|")}))?\\] ?`);
+function finalAnswer(messages) {
+  const finals = messages.filter((m) => m.phase === "final_answer").map((m) => m.text);
+  if (finals.length) return finals.join("\n\n");
+  return messages.at(-1)?.text ?? null;
+}
+
+// src/codex/run.ts
+init_constants();
+var MINUTE = 6e4;
+var SUMMARY_MAX = 200;
+var clip = (text) => text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX)}\u2026` : text;
+function relayed(method, params) {
+  switch (method) {
+    case "item/commandExecution/requestApproval": {
+      const command = params.command ?? (params.commandActions ?? []).map((a) => a.command).join("\n");
+      return { kind: "command", summary: clip(String(command || params.reason || "")), decline: { decision: "decline" } };
+    }
+    case "item/fileChange/requestApproval":
+      return { kind: "file change", summary: clip(String(params.reason ?? "")), decline: { decision: "decline" } };
+    case "mcpServer/elicitation/request":
+      if (params._meta?.codex_approval_kind !== "mcp_tool_call") return null;
+      return { kind: "MCP tool", summary: clip(`${params.serverName ?? ""}: ${params.message ?? ""}`), decline: { action: "decline" } };
+    default:
+      return null;
+  }
+}
+function unrelayed(method, params) {
+  switch (method) {
+    case "item/permissions/requestApproval":
+      return { kind: "permissions", summary: clip(String(params.reason ?? "")), answer: { permissions: {} } };
+    case "item/tool/requestUserInput":
+      return {
+        kind: "question",
+        summary: clip((params.questions ?? []).map((q) => q.question ?? "").join(" / ")),
+        answer: { answers: {} }
+      };
+    case "mcpServer/elicitation/request":
+      return { kind: "MCP form", summary: clip(String(params.message ?? "")), answer: { action: "decline" } };
+    default:
+      return null;
+  }
+}
+async function runCodexTask(opts) {
+  const progress = opts.progress ?? (() => {
+  });
+  const approvalTimeoutMs = opts.approvalTimeoutMs ?? 10 * MINUTE;
+  const started = Date.now();
+  const conn = await connectProxy(opts.command ?? "codex", opts.spawnFn ?? defaultSpawn);
+  const rpc = new RpcClient(conn.ws);
+  const timers = /* @__PURE__ */ new Set();
+  try {
+    const init2 = await rpc.request("initialize", {
+      clientInfo: { name: "claude-alarm-run", version: CHANNEL_SERVER_VERSION }
+    });
+    rpc.notify("initialized");
+    const yolo = { sandbox: "danger-full-access", approvalPolicy: "never" };
+    let threadId;
+    if (opts.threadId) {
+      await rpc.request("thread/resume", opts.yolo ? { threadId: opts.threadId, ...yolo } : { threadId: opts.threadId });
+      threadId = opts.threadId;
+    } else {
+      const res = await rpc.request("thread/start", {
+        cwd: opts.cwd,
+        ...opts.yolo ? yolo : { sandbox: "workspace-write", approvalPolicy: "on-request" }
+      });
+      threadId = res.thread.id;
+      if (opts.name) {
+        await rpc.request("thread/name/set", { threadId, name: opts.name }).catch(() => {
+        });
+      }
+    }
+    progress(`thread ${threadId}`);
+    const messages = /* @__PURE__ */ new Map();
+    const approvals = [];
+    const waiting = /* @__PURE__ */ new Map();
+    let finish;
+    let lose;
+    const completed = new Promise((resolve, reject) => {
+      finish = resolve;
+      lose = reject;
+    });
+    completed.catch(() => {
+    });
+    rpc.on("close", () => lose(new Error("connection to the Codex daemon closed")));
+    rpc.on("notification", (method, params) => {
+      if (params?.threadId !== threadId) return;
+      if (method === "item/completed") {
+        const item = params.item ?? {};
+        if (item.type === "agentMessage") {
+          const list = messages.get(params.turnId) ?? [];
+          list.push({ text: item.text, phase: item.phase });
+          messages.set(params.turnId, list);
+        } else if (item.type === "commandExecution") {
+          progress(`ran ${clip(String(item.command ?? ""))} (exit ${item.exitCode ?? "?"})`);
+        }
+      } else if (method === "serverRequest/resolved") {
+        const record = waiting.get(params.requestId);
+        if (record) {
+          waiting.delete(params.requestId);
+          record.outcome = "answered-elsewhere";
+          progress(`approval answered elsewhere: ${record.kind}`);
+        }
+      } else if (method === "turn/completed") {
+        finish(params.turn);
+      }
+    });
+    rpc.on("request", (id, method, params) => {
+      if (params?.threadId !== threadId) return;
+      const wait = relayed(method, params);
+      if (wait) {
+        const record = { kind: wait.kind, summary: wait.summary, outcome: "unanswered" };
+        approvals.push(record);
+        waiting.set(id, record);
+        progress(`approval pending (${Math.round(approvalTimeoutMs / 1e3)}s): ${wait.kind} ${wait.summary}`);
+        const timer = setTimeout(() => {
+          timers.delete(timer);
+          if (!waiting.delete(id)) return;
+          record.outcome = "timeout-declined";
+          rpc.respond(id, wait.decline);
+          progress(`approval declined after timeout: ${wait.kind}`);
+        }, approvalTimeoutMs);
+        timers.add(timer);
+        return;
+      }
+      const answer = unrelayed(method, params);
+      if (answer) {
+        approvals.push({ kind: answer.kind, summary: answer.summary, outcome: "auto-declined" });
+        rpc.respond(id, answer.answer);
+        progress(`declined at once: ${answer.kind}`);
+      }
+    });
+    const turnStart = { threadId, input: [{ type: "text", text: opts.brief }] };
+    if (opts.outputSchema !== void 0) turnStart.outputSchema = opts.outputSchema;
+    const { turn } = await rpc.request("turn/start", turnStart);
+    const turnId = turn.id;
+    progress(`turn ${turnId} started`);
+    let stopReason = null;
+    let interruptRequested;
+    const stopped = new Promise((resolve) => interruptRequested = resolve);
+    const stop = (reason) => {
+      if (stopReason) return;
+      stopReason = reason;
+      progress(reason === "timedOut" ? "timeout reached, interrupting the turn" : "interrupting the turn");
+      rpc.request("turn/interrupt", { threadId, turnId }).catch(() => {
+      });
+      interruptRequested();
+    };
+    const deadline = setTimeout(() => stop("timedOut"), opts.timeoutMs ?? 60 * MINUTE);
+    timers.add(deadline);
+    const onAbort = () => stop("interrupted");
+    if (opts.signal?.aborted) onAbort();
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    const grace = stopped.then(
+      () => new Promise((resolve) => {
+        const t = setTimeout(() => resolve(null), opts.interruptGraceMs ?? 15e3);
+        timers.add(t);
+      })
+    );
+    let ended;
+    let lost = null;
+    try {
+      ended = await Promise.race([completed, grace]);
+    } catch (err) {
+      ended = null;
+      lost = err.message;
+    } finally {
+      opts.signal?.removeEventListener("abort", onAbort);
+    }
+    let status;
+    let error = null;
+    if (stopReason) status = stopReason;
+    else if (lost) {
+      status = "failed";
+      error = lost;
+    } else if (ended?.status === "failed" || ended?.error) {
+      status = "failed";
+      error = ended?.error?.message ?? "the turn failed";
+    } else if (ended?.status === "interrupted") status = "interrupted";
+    else status = "completed";
+    const collected = messages.get(turnId) ?? [];
+    const fromTurn = (ended?.items ?? []).filter((i) => i.type === "agentMessage");
+    const finalText = finalAnswer(collected.length ? collected : fromTurn);
+    let result = null;
+    if (opts.outputSchema !== void 0 && finalText) {
+      try {
+        result = JSON.parse(finalText);
+      } catch {
+        result = null;
+      }
+    }
+    return {
+      threadId,
+      turnId,
+      status,
+      error,
+      result,
+      finalText,
+      approvals,
+      durationMs: Date.now() - started,
+      codex: { userAgent: init2.userAgent ?? null }
+    };
+  } finally {
+    for (const t of timers) clearTimeout(t);
+    conn.close();
+  }
+}
+var VALUE_FLAGS = {
+  "--brief": "brief",
+  "--cwd": "cwd",
+  "--thread": "threadId",
+  "--name": "name",
+  "--output-schema": "outputSchema",
+  "--approval-timeout": "approvalTimeoutMs",
+  "--timeout": "timeoutMs"
+};
+function parseRunArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    if (flag === "--yolo") {
+      out.yolo = true;
+      continue;
+    }
+    const key = VALUE_FLAGS[flag];
+    if (!key) throw new Error(`Unknown option: ${flag}`);
+    const value = argv[++i];
+    if (value === void 0) throw new Error(`${flag} needs a value`);
+    if (key === "approvalTimeoutMs" || key === "timeoutMs") {
+      const minutes = Number(value);
+      if (!Number.isFinite(minutes) || minutes <= 0) throw new Error(`${flag} must be a number of minutes`);
+      out[key] = Math.round(minutes * MINUTE);
+    } else {
+      out[key] = value;
+    }
+  }
+  if (out.brief === void 0) throw new Error("--brief <file|-> is required");
+  return out;
+}
+async function runFromCli(argv, io) {
+  let task;
+  try {
+    const args = parseRunArgs(argv);
+    const brief = args.brief === "-" ? await io.readStdin() : await io.readFile(args.brief);
+    if (!brief.trim()) throw new Error("the brief is empty");
+    task = {
+      brief,
+      cwd: path4.resolve(io.cwd, args.cwd ?? "."),
+      threadId: args.threadId,
+      name: args.name,
+      yolo: args.yolo,
+      outputSchema: args.outputSchema === void 0 ? void 0 : JSON.parse(await io.readFile(args.outputSchema)),
+      approvalTimeoutMs: args.approvalTimeoutMs,
+      timeoutMs: args.timeoutMs,
+      signal: io.signal,
+      spawnFn: io.spawnFn,
+      progress: (line) => io.err(`[codex run] ${line}
+`)
+    };
+  } catch (err) {
+    io.err(`codex run: ${err.message}
+`);
+    return 2;
+  }
+  try {
+    const result = await runCodexTask(task);
+    io.out(`${JSON.stringify(result, null, 2)}
+`);
+    return result.status === "completed" ? 0 : 1;
+  } catch (err) {
+    io.err(`codex run: could not start the task: ${err.message}
+`);
+    return 2;
+  }
+}
 
 // src/cli.ts
 init_constants();
 init_logger();
 init_crash_guard();
-var __dirname2 = path9.dirname(fileURLToPath2(import.meta.url));
+
+// src/hub/readiness.ts
+var HUB_START_TIMEOUT_MS = 5e3;
+async function waitForHub(opts) {
+  const timeoutMs = opts.timeoutMs ?? HUB_START_TIMEOUT_MS;
+  const intervalMs = opts.intervalMs ?? 200;
+  const deadline = Date.now() + timeoutMs;
+  const headers = opts.token ? { Authorization: `Bearer ${opts.token}` } : {};
+  for (; ; ) {
+    if (!opts.isAlive()) return "exited";
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return "timeout";
+    try {
+      const res = await fetch(opts.url, { headers, signal: AbortSignal.timeout(Math.min(remaining, 1e3)) });
+      if (res.ok) {
+        const body = await res.json();
+        if (body.pid === opts.pid) return "ready";
+      }
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, Math.max(0, deadline - Date.now()))));
+  }
+}
+
+// src/cli.ts
+init_hub_url();
+
+// src/codex/hub-target.ts
+init_hub_url();
+function resolveAdapterHub(config2, env = process.env) {
+  const envHost = env.CLAUDE_ALARM_HUB_HOST;
+  const envPort = env.CLAUDE_ALARM_HUB_PORT;
+  const envToken = env.CLAUDE_ALARM_HUB_TOKEN;
+  return {
+    host: hubUrlHost(envHost ?? config2.hub.host),
+    port: envPort ? parseInt(envPort, 10) : config2.hub.port,
+    token: envToken ?? config2.hub.token,
+    fromEnv: { host: envHost !== void 0, port: !!envPort, token: envToken !== void 0 }
+  };
+}
+
+// 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 CONFIG_PATH = "~/.claude-alarm/config.json";
+var NOT_CHECKED = { text: "Codex daemon: not checked (the adapter was already running)", warning: false };
+function toOutcome(msg) {
+  if (msg.connected === true) return typeof msg.userAgent === "string" ? { connected: true, userAgent: msg.userAgent } : { connected: true };
+  return { connected: false, error: String(msg.error ?? ""), notFound: msg.notFound === true };
+}
+function waitForAdapterReport(child, timeoutMs = ADAPTER_REPORT_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const finish = (result) => {
+      clearTimeout(timer);
+      child.off("message", onMessage);
+      child.off("exit", onExit);
+      child.off("error", onError);
+      resolve(result);
+    };
+    const onMessage = (msg) => {
+      if (msg && typeof msg === "object" && msg.type === "codex-first-connect") {
+        finish({ kind: "report", outcome: toOutcome(msg) });
+      }
+    };
+    const onExit = (code, signal) => finish({ kind: "exited", code, signal });
+    const onError = (error) => finish({ kind: "exited", code: null, signal: null, error });
+    const timer = setTimeout(() => finish({ kind: "timeout" }), timeoutMs);
+    child.on("message", onMessage);
+    child.on("exit", onExit);
+    child.on("error", onError);
+  });
+}
+function hubUrl(hub) {
+  return `http://${hub.host}:${hub.port}`;
+}
+async function checkHub(hub, timeoutMs = HUB_CHECK_TIMEOUT_MS) {
+  let res;
+  try {
+    res = await fetch(`${hubUrl(hub)}/api/status`, {
+      headers: hub.token ? { Authorization: `Bearer ${hub.token}` } : {},
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    const e = err;
+    return { kind: "unreachable", reason: typeof e.cause?.code === "string" ? e.cause.code : e.name };
+  }
+  if (res.status === 200) {
+    try {
+      const body = await res.json();
+      if (body?.running === true) return { kind: "ok" };
+    } catch {
+    }
+    return { kind: "not-hub", status: 200 };
+  }
+  await res.body?.cancel().catch(() => {
+  });
+  return res.status === 401 ? { kind: "unauthorized" } : { kind: "not-hub", status: res.status };
+}
+function daemonLine(report, command, logFile) {
+  if (report.kind === "timeout") {
+    return { text: `Codex daemon: no answer within ${ADAPTER_REPORT_TIMEOUT_MS / 1e3}s. The adapter keeps trying. See ${logFile}`, warning: true };
+  }
+  const o = report.outcome;
+  if (o.connected) return { text: `Codex daemon: connected (${o.userAgent ?? "unknown version"})`, warning: false };
+  if (o.notFound) {
+    return { text: `Codex daemon: "${command}" not found. Install Codex or set "codex.command" in ${CONFIG_PATH}, and run the restart from a new terminal.`, warning: true };
+  }
+  return { text: `Codex daemon: not connected (${o.error}). Is Codex running? The adapter keeps retrying.`, warning: true };
+}
+function addressSource(hub) {
+  const host = hub.fromEnv.host ? "CLAUDE_ALARM_HUB_HOST" : "hub.host";
+  const port = hub.fromEnv.port ? "CLAUDE_ALARM_HUB_PORT" : "hub.port";
+  const fromConfig = !hub.fromEnv.host || !hub.fromEnv.port;
+  return `${host} and ${port}${fromConfig ? ` in ${CONFIG_PATH}` : ""}`;
+}
+function tokenSource(hub) {
+  return hub.fromEnv.token ? "CLAUDE_ALARM_HUB_TOKEN" : `hub.token in ${CONFIG_PATH}`;
+}
+function hubLine(check, hub) {
+  const url = hubUrl(hub);
+  switch (check.kind) {
+    case "ok":
+      return { text: `Hub: reachable at ${url}`, warning: false };
+    case "unauthorized":
+      return { text: `Hub: ${url} rejected the token (401). Check ${tokenSource(hub)}.`, warning: true };
+    case "not-hub":
+      return { text: `Hub: ${url} answered ${check.status} but is not a claude-alarm hub. Check ${addressSource(hub)}.`, warning: true };
+    case "unreachable":
+      return { text: `Hub: not reachable at ${url} (${check.reason}). Check ${addressSource(hub)} and that the hub is running.`, warning: true };
+  }
+}
+function printChecks(d, daemon, hub) {
+  d.out(`  ${daemon.text}`);
+  d.out(`  ${hub.text}`);
+  if (daemon.warning || hub.warning) d.out(`  ${RESTART_HINT}`);
+}
+function printAlreadyRunning(d, pid, hub) {
+  d.out(`Codex adapter is already running (PID: ${pid})`);
+  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));
+    return 0;
+  }
+  const child = d.spawnAdapter();
+  const seen = {};
+  child.on("exit", (code, signal) => {
+    seen.exit ??= { code, signal };
+  });
+  child.on("error", (error) => {
+    seen.exit ??= { code: null, signal: null, error };
+  });
+  const [report, hub] = await Promise.all([
+    waitForAdapterReport(child, d.reportTimeoutMs),
+    checkHub(d.hub, d.hubTimeoutMs)
+  ]);
+  if (child.connected) child.disconnect();
+  child.unref();
+  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));
+    return 0;
+  }
+  const exit = seen.exit ?? (report.kind === "exited" ? report : void 0);
+  if (!exit || exit.error) {
+    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);
+    return 0;
+  }
+  const how = exit.code !== null ? `code ${exit.code}` : `signal ${exit.signal}`;
+  d.err(`Codex adapter exited during startup (${how}). See ${d.logFile}`);
+  return 1;
+}
+
+// src/cli.ts
+var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
 function authHeaders(token) {
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
@@ -2407,6 +3189,10 @@ Usage:
   claude-alarm codex start      Run the Codex adapter on its own (e.g. Codex on another PC)
   claude-alarm codex stop       Stop a running Codex adapter
   claude-alarm codex status     Show Codex adapter status
+  claude-alarm codex run --brief <file|-> [--cwd <dir>] [--thread <id>] [--name <title>]
+                         [--output-schema <file>] [--approval-timeout <min>] [--timeout <min>] [--yolo]
+                                Hand a task to Codex through the shared daemon and print the result as JSON
+                                (--yolo: no sandbox and no approvals, like codex --yolo)
   claude-alarm help             Show this help
 
 Quick start:
@@ -2415,7 +3201,7 @@ Quick start:
 }
 async function checkForUpdates() {
   try {
-    const pkgPath = path9.join(__dirname2, "..", "package.json");
+    const pkgPath = path10.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", {
@@ -2437,7 +3223,7 @@ async function hubStart(daemon) {
   const config2 = loadConfig();
   const host = config2.hub.host ?? DEFAULT_HUB_HOST;
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
-  const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+  const displayHost = hubUrlHost(host);
   checkForUpdates();
   if (fs8.existsSync(PID_FILE)) {
     const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
@@ -2450,23 +3236,39 @@ async function hubStart(daemon) {
   if (daemon) {
     ensureConfigDir();
     const logFd = fs8.openSync(LOG_FILE, "a");
-    const hubScript = path9.join(__dirname2, "hub", "server.js");
+    const hubScript = path10.join(__dirname2, "hub", "server.js");
     const child = spawn3(process.execPath, [hubScript], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env }
     });
-    if (child.pid) {
-      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)}`);
-      console.log(`Token: ${config2.hub.token}`);
-      console.log(`Logs: ${LOG_FILE}`);
-    } else {
+    const pid = child.pid;
+    if (!pid) {
       console.error("Failed to start hub daemon");
       process.exit(1);
     }
+    fs8.writeFileSync(PID_FILE, String(pid), "utf-8");
+    let exited = false;
+    child.once("exit", () => {
+      exited = true;
+    });
+    child.unref();
+    const startup = await waitForHub({
+      url: `http://${displayHost}:${port}/api/status`,
+      token: config2.hub.token,
+      pid,
+      isAlive: () => !exited
+    });
+    if (startup !== "ready") {
+      if (!exited) child.kill();
+      if (fs8.existsSync(PID_FILE)) fs8.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);
+    }
+    console.log(`Hub started as daemon (PID: ${pid})`);
+    console.log(`Dashboard: ${loginLink(displayHost, port, config2.hub.token)}`);
+    console.log(`Token: ${config2.hub.token}`);
+    console.log(`Logs: ${LOG_FILE}`);
   } else {
     console.log(`Starting hub on http://${displayHost}:${port} (press Ctrl+C to stop)`);
     console.log(`Dashboard: ${loginLink(displayHost, port, config2.hub.token)}`);
@@ -2507,7 +3309,7 @@ async function hubStatus() {
   const config2 = loadConfig();
   const host = config2.hub.host ?? DEFAULT_HUB_HOST;
   const port = config2.hub.port ?? DEFAULT_HUB_PORT;
-  const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+  const displayHost = hubUrlHost(host);
   let pidInfo = "not running";
   if (fs8.existsSync(PID_FILE)) {
     const pid = parseInt(fs8.readFileSync(PID_FILE, "utf-8").trim(), 10);
@@ -2518,7 +3320,7 @@ async function hubStatus() {
     }
   }
   try {
-    const res = await fetch(`http://${host}:${port}/api/status`, { headers: authHeaders(config2.hub.token) });
+    const res = await fetch(`http://${displayHost}:${port}/api/status`, { headers: authHeaders(config2.hub.token) });
     if (res.ok) {
       const data = await res.json();
       console.log(`Hub: running (PID: ${data.pid})`);
@@ -2553,7 +3355,7 @@ async function test() {
     if (config2.hub.token) {
       headers["Authorization"] = `Bearer ${config2.hub.token}`;
     }
-    const res = await fetch(`http://${host}:${port}/api/notify`, {
+    const res = await fetch(`http://${hubUrlHost(host)}:${port}/api/notify`, {
       method: "POST",
       headers,
       body: JSON.stringify({
@@ -2582,7 +3384,7 @@ function ask(question) {
 }
 async function init() {
   const dir = process.cwd();
-  const projectName = path9.basename(dir);
+  const projectName = path10.basename(dir);
   console.log(`
 claude-alarm init for "${projectName}"
 `);
@@ -2602,7 +3404,7 @@ claude-alarm init for "${projectName}"
     if (port) env.CLAUDE_ALARM_HUB_PORT = port;
     if (token) env.CLAUDE_ALARM_HUB_TOKEN = token;
   }
-  const mcpPath = path9.join(dir, ".mcp.json");
+  const mcpPath = path10.join(dir, ".mcp.json");
   let mcpConfig = {};
   if (fs8.existsSync(mcpPath)) {
     try {
@@ -2624,10 +3426,10 @@ claude-alarm init for "${projectName}"
     const config2 = loadConfig();
     const host = config2.hub.host ?? DEFAULT_HUB_HOST;
     const port = config2.hub.port ?? DEFAULT_HUB_PORT;
-    const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    const displayHost = hubUrlHost(host);
     let hubRunning = false;
     try {
-      const res = await fetch(`http://${host}:${port}/api/status`, { headers: authHeaders(config2.hub.token) });
+      const res = await fetch(`http://${displayHost}:${port}/api/status`, { headers: authHeaders(config2.hub.token) });
       hubRunning = res.ok;
     } catch {
     }
@@ -2638,7 +3440,7 @@ claude-alarm init for "${projectName}"
       console.log(`  claude-alarm hub start`);
     }
     console.log(`  Dashboard: http://${displayHost}:${port}`);
-    if (shouldOfferCodex(config2, findOnPath("codex") !== void 0)) {
+    if (shouldOfferCodex(config2, findCodex("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);
@@ -2676,21 +3478,34 @@ function codexEnable(enabled) {
   setCodexEnabled(enabled);
   console.log(enabled ? "Codex adapter enabled. Restart the hub to apply: claude-alarm hub stop, then claude-alarm hub start" : "Codex adapter disabled. Restart the hub to apply.");
 }
-function codexStart() {
-  const pid = readCodexPid();
-  if (pid !== void 0 && isProcessRunning(pid)) {
-    console.log(`Codex adapter is already running (PID: ${pid})`);
-    return;
-  }
+async function codexStart() {
+  const config2 = loadConfig();
   ensureConfigDir();
-  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 }
+  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 {
+      }
+    },
+    spawnAdapter: () => {
+      const logFd = fs8.openSync(CODEX_LOG_FILE, "a");
+      return spawn3(process.execPath, [path10.join(__dirname2, "codex", "main.js")], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd, "ipc"],
+        windowsHide: true,
+        env: { ...process.env }
+      });
+    },
+    out: (line) => console.log(line),
+    err: (line) => console.error(line)
   });
-  child.unref();
-  console.log(`Codex adapter started (PID: ${child.pid}). Logs: ${CODEX_LOG_FILE}`);
+  if (code !== 0) process.exit(code);
 }
 function codexStop() {
   const pid = readCodexPid();
@@ -2715,6 +3530,29 @@ function codexStatus() {
   console.log(`Codex adapter: ${state}`);
   console.log(`Start with hub: ${loadConfig().codex?.enabled ? "enabled" : "disabled"}`);
 }
+async function codexRun(argv) {
+  const abort = new AbortController();
+  const stop = () => abort.abort();
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  try {
+    return await runFromCli(argv, {
+      readFile: (file) => fs8.promises.readFile(file, "utf-8"),
+      readStdin: async () => {
+        let text = "";
+        for await (const chunk of process.stdin) text += chunk;
+        return text;
+      },
+      out: (text) => process.stdout.write(text),
+      err: (text) => process.stderr.write(text),
+      cwd: process.cwd(),
+      signal: abort.signal
+    });
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
+}
 async function main2() {
   const args = process.argv.slice(2);
   const cmd = args[0];
@@ -2749,9 +3587,10 @@ async function main2() {
   if (cmd === "codex") {
     if (sub === "enable") codexEnable(true);
     else if (sub === "disable") codexEnable(false);
-    else if (sub === "start") codexStart();
+    else if (sub === "start") await codexStart();
     else if (sub === "stop") codexStop();
     else if (sub === "status") codexStatus();
+    else if (sub === "run") process.exitCode = await codexRun(args.slice(2));
     else {
       console.error(`Unknown codex command: ${sub}`);
       printUsage();