@delt/claude-alarm 1.1.1 → 1.3.0

package/dist/codex/main.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 
-// src/codex/main.ts
-import fs4 from "fs";
-
 // src/shared/config.ts
 import fs from "fs";
 import path2 from "path";
@@ -21,6 +18,7 @@ var UPLOADS_DIR = path.join(CONFIG_DIR, "uploads");
 var CODEX_PID_FILE = path.join(CONFIG_DIR, "codex.pid");
 var CODEX_LOG_FILE = path.join(CONFIG_DIR, "codex.log");
 var WS_PATH_CHANNEL = "/ws/channel";
+var WS_PATH_CODEX = "/ws/codex";
 var CHANNEL_SERVER_VERSION = "0.1.0";
 
 // src/shared/config.ts
@@ -133,18 +131,122 @@ function logStartup(context) {
 `);
 }
 
+// src/codex/adapter.ts
+import fs5 from "fs";
+import os2 from "os";
+import path4 from "path";
+
+// src/codex/hub-link.ts
+import WebSocket from "ws";
+var CodexHubLink = class {
+  constructor(hub, identity, onCall, reconnectMs = 5e3, pingTimeoutMs = 75e3) {
+    this.hub = hub;
+    this.identity = identity;
+    this.onCall = onCall;
+    this.reconnectMs = reconnectMs;
+    this.pingTimeoutMs = pingTimeoutMs;
+  }
+  ws = null;
+  retryTimer = null;
+  pingTimer = null;
+  closed = true;
+  ready = false;
+  connect() {
+    this.closed = false;
+    const query = this.hub.token ? `?token=${encodeURIComponent(this.hub.token)}` : "";
+    let ws;
+    try {
+      ws = new WebSocket(`ws://${this.hub.host}:${this.hub.port}${WS_PATH_CODEX}${query}`);
+    } catch (err) {
+      logger.debug(`Codex hub link failed: ${err.message}`);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.on("open", () => {
+      if (this.ws !== ws) return;
+      this.armWatchdog(ws);
+      this.hello();
+    });
+    ws.on("ping", () => this.armWatchdog(ws));
+    ws.on("message", (data) => {
+      if (this.ws === ws) this.onMessage(String(data));
+    });
+    ws.on("close", () => {
+      if (this.ws !== ws) return;
+      this.clearWatchdog();
+      this.ws = null;
+      this.scheduleReconnect();
+    });
+    ws.on("error", (err) => logger.debug(`Codex hub link error: ${err.message}`));
+  }
+  setReady(ready) {
+    if (this.ready === ready) return;
+    this.ready = ready;
+    this.hello();
+  }
+  disconnect() {
+    this.closed = true;
+    this.clearWatchdog();
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close();
+  }
+  hello() {
+    this.send({ type: "adapter_hello", adapter: { ...this.identity, ready: this.ready } });
+  }
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(msg));
+  }
+  onMessage(text) {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!msg || typeof msg !== "object") return;
+    if (msg.type !== "adapter_call") return;
+    const { requestId, call } = msg;
+    this.onCall(call).then(
+      (data) => this.send({ type: "adapter_result", requestId, ok: true, data }),
+      (err) => this.send({ type: "adapter_result", requestId, ok: false, error: err.message })
+    );
+  }
+  clearWatchdog() {
+    if (this.pingTimer) clearTimeout(this.pingTimer);
+    this.pingTimer = null;
+  }
+  armWatchdog(ws) {
+    if (this.ws !== ws) return;
+    this.clearWatchdog();
+    this.pingTimer = setTimeout(() => {
+      if (this.ws === ws) ws.terminate();
+    }, this.pingTimeoutMs);
+  }
+  scheduleReconnect() {
+    if (this.closed || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.connect();
+    }, this.reconnectMs);
+  }
+};
+
 // src/codex/adapter.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/channel/hub-client.ts
-import WebSocket from "ws";
+import WebSocket2 from "ws";
 var HubClient = class {
-  constructor(sessionId, sessionName, hubHost = DEFAULT_HUB_HOST, hubPort = DEFAULT_HUB_PORT, token2, getPeerName = () => void 0, getRegistration = () => ({})) {
+  constructor(sessionId, sessionName, hubHost = DEFAULT_HUB_HOST, hubPort = DEFAULT_HUB_PORT, token, getPeerName = () => void 0, getRegistration = () => ({})) {
     this.sessionId = sessionId;
     this.sessionName = sessionName;
     this.hubHost = hubHost;
     this.hubPort = hubPort;
-    this.token = token2;
+    this.token = token;
     this.getPeerName = getPeerName;
     this.getRegistration = getRegistration;
   }
@@ -160,7 +262,7 @@ var HubClient = class {
     const url = `ws://${this.hubHost}:${this.hubPort}${WS_PATH_CHANNEL}${tokenQuery}`;
     logger.debug(`Connecting to hub at ${url}`);
     try {
-      const ws = new WebSocket(url);
+      const ws = new WebSocket2(url);
       this.ws = ws;
       ws.on("open", () => {
         if (this.ws !== ws) return;
@@ -200,7 +302,7 @@ var HubClient = class {
     }
   }
   send(msg) {
-    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+    if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
       this.ws.send(JSON.stringify(msg));
     } else {
       if (this.queue.length < 100) {
@@ -225,7 +327,7 @@ var HubClient = class {
     this.connected = false;
   }
   reregister() {
-    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+    if (this.connected && this.ws?.readyState === WebSocket2.OPEN) {
       this.ws.send(JSON.stringify(this.registration()));
     }
   }
@@ -259,10 +361,11 @@ import { spawn } from "child_process";
 import fs3 from "fs";
 import path3 from "path";
 import { Duplex } from "stream";
-import WebSocket2 from "ws";
+import WebSocket3 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 = findOnPath(command, platform, env);
+  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 };
 }
 function findOnPath(command, platform = process.platform, env = process.env) {
@@ -275,12 +378,22 @@ 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 && fs3.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) {
+var HANDSHAKE_TIMEOUT_MS = 1e4;
+function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIMEOUT_MS) {
   const child = spawnFn(command, ["app-server", "proxy"]);
   child.stdin?.on("error", () => {
   });
@@ -305,7 +418,7 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   }, ref() {
   }, unref() {
   } });
-  const ws = new WebSocket2("ws://localhost/", {
+  const ws = new WebSocket3("ws://localhost/", {
     createConnection: (() => stream)
   });
   const close = () => {
@@ -314,9 +427,11 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   };
   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;
+      clearTimeout(timer);
       close();
       reject(err);
     };
@@ -326,6 +441,7 @@ 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}`));
       resolve({ ws, close });
@@ -333,6 +449,57 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   });
 }
 
+// src/codex/inputs.ts
+import fs4 from "fs/promises";
+
+// src/codex/mapping.ts
+var TITLE_MAX = 30;
+var SOURCE_LABEL = { dashboard: "Dashboard", telegram: "Telegram", api: "API" };
+var SOURCE_PREFIX = new RegExp(`^\\[claude-alarm(?: \xB7 (?:${Object.values(SOURCE_LABEL).join("|")}))?\\] ?`);
+function codexSessionId(threadId) {
+  return `codex:${threadId}`;
+}
+function isTrackable(thread) {
+  return !thread.parentThreadId && !thread.ephemeral && thread.status.type !== "notLoaded";
+}
+function threadTitle(thread) {
+  const name = thread.name?.trim();
+  if (name) return name;
+  const preview = (thread.preview ?? "").replace(/\s+/g, " ").trim().replace(SOURCE_PREFIX, "").trim();
+  if (preview) return preview.length > TITLE_MAX ? `${preview.slice(0, TITLE_MAX)}\u2026` : preview;
+  return thread.cwd.replace(/^.*[/\\]/, "") || thread.id.slice(0, 8);
+}
+function hubStatus(status) {
+  if (status.type !== "active") return "idle";
+  return status.activeFlags.some((f) => f === "waitingOnApproval" || f === "waitingOnUserInput") ? "waiting_input" : "working";
+}
+function withSourcePrefix(content, source) {
+  return source ? `[claude-alarm \xB7 ${SOURCE_LABEL[source]}] ${content}` : `[claude-alarm] ${content}`;
+}
+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;
+}
+function cleanFolder(input) {
+  const s = input.trim();
+  return s.length >= 2 && s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1).trim() : s;
+}
+
+// src/codex/inputs.ts
+var IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function textInput(content, source) {
+  return [{ type: "text", text: withSourcePrefix(content, source) }];
+}
+async function imageInput(imagePath, mimeType, caption, source) {
+  if (!IMAGE_TYPES.has(mimeType)) throw new Error(`unsupported image type ${mimeType}`);
+  const data = await fs4.readFile(imagePath);
+  return [
+    { type: "text", text: withSourcePrefix(caption?.trim() || "(image)", source) },
+    { type: "image", url: `data:${mimeType};base64,${data.toString("base64")}` }
+  ];
+}
+
 // src/codex/rpc.ts
 import { EventEmitter } from "events";
 var RpcError = class extends Error {
@@ -358,14 +525,14 @@ var RpcClient = class extends EventEmitter {
   }
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
-  request(method, params) {
+  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 = setTimeout(() => {
+      const timer = timeoutMs === null ? void 0 : setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`${method} timed out`));
-      }, this.timeoutMs);
+      }, timeoutMs);
       this.pending.set(id, { resolve, reject, timer });
       this.ws.send(JSON.stringify(params === void 0 ? { id, method } : { id, method, params }));
     });
@@ -476,41 +643,14 @@ ${f.diff}` : f.path).join("\n\n") : "The file list is not available here. Check
   }
 }
 
-// src/codex/mapping.ts
-var TITLE_MAX = 30;
-var SOURCE_LABEL = { dashboard: "Dashboard", telegram: "Telegram", api: "API" };
-function codexSessionId(threadId) {
-  return `codex:${threadId}`;
-}
-function isTrackable(thread) {
-  return !thread.parentThreadId && !thread.ephemeral && thread.status.type !== "notLoaded";
-}
-function threadTitle(thread) {
-  const name = thread.name?.trim();
-  if (name) return name;
-  const preview = (thread.preview ?? "").replace(/\s+/g, " ").trim();
-  if (preview) return preview.length > TITLE_MAX ? `${preview.slice(0, TITLE_MAX)}\u2026` : preview;
-  return thread.cwd.replace(/^.*[/\\]/, "") || thread.id.slice(0, 8);
-}
-function hubStatus(status) {
-  if (status.type !== "active") return "idle";
-  return status.activeFlags.some((f) => f === "waitingOnApproval" || f === "waitingOnUserInput") ? "waiting_input" : "working";
-}
-function withSourcePrefix(content, source) {
-  return source ? `[claude-alarm \xB7 ${SOURCE_LABEL[source]}] ${content}` : `[claude-alarm] ${content}`;
-}
-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/adapter.ts
 var USER_REQUESTS = /* @__PURE__ */ new Set(["item/tool/requestUserInput", "item/permissions/requestApproval", "mcpServer/elicitation/request"]);
 var CodexAdapter = class {
   constructor(opts) {
     this.opts = opts;
     this.delay = opts.reconnectMinMs ?? 2e3;
+    this.hostName = opts.hostName ?? os2.hostname();
+    this.link = new CodexHubLink(opts.hub, { id: randomUUID2(), host: this.hostName }, (call) => this.onCall(call), opts.linkReconnectMs);
   }
   conn;
   rpc;
@@ -519,12 +659,20 @@ var CodexAdapter = class {
   stopped = false;
   retryTimer;
   delay;
+  notFoundNotice = "unsent";
+  firstConnectReported = false;
+  pins = /* @__PURE__ */ new Set();
+  ready = false;
+  hostName;
+  link;
   start() {
     this.stopped = false;
+    this.link.connect();
     void this.connect();
   }
   stop() {
     this.stopped = true;
+    this.link.disconnect();
     if (this.retryTimer) clearTimeout(this.retryTimer);
     this.retryTimer = void 0;
     for (const id of [...this.threads.keys()]) this.drop(id);
@@ -538,7 +686,7 @@ var CodexAdapter = class {
         conn.close();
         return;
       }
-      const live = new RpcClient(conn.ws);
+      const live = new RpcClient(conn.ws, this.opts.rpcTimeoutMs);
       rpc = live;
       live.on("notification", (method, params) => this.onNotification(method, params));
       live.on("request", (id, method, params) => this.onServerRequest(id, method, params));
@@ -552,10 +700,19 @@ var CodexAdapter = class {
       });
       live.notify("initialized");
       logger.info(`Connected to Codex daemon (${init.userAgent ?? "unknown version"})`);
+      this.reportFirstConnect({ connected: true, ...init.userAgent ? { userAgent: init.userAgent } : {} });
       await this.discover();
+      if (this.rpc === live) this.setReady(true);
       this.delay = this.opts.reconnectMinMs ?? 2e3;
     } catch (err) {
+      this.setReady(false);
       logger.warn(`Codex daemon connection failed: ${err.message}`);
+      if (err.code === "ENOENT") this.noticeNotFound();
+      this.reportFirstConnect({
+        connected: false,
+        error: err.message,
+        notFound: err.code === "ENOENT"
+      });
       if (rpc && this.rpc === rpc) {
         this.rpc = void 0;
         this.conn?.close();
@@ -566,6 +723,7 @@ var CodexAdapter = class {
     }
   }
   onDaemonLost() {
+    this.setReady(false);
     this.rpc = void 0;
     this.conn?.close();
     this.conn = void 0;
@@ -581,18 +739,86 @@ var CodexAdapter = class {
     }, this.delay);
     this.delay = Math.min(this.delay * 2, this.opts.reconnectMaxMs ?? 6e4);
   }
+  reportFirstConnect(outcome) {
+    if (this.firstConnectReported || this.stopped) return;
+    this.firstConnectReported = true;
+    try {
+      this.opts.onFirstConnect?.(outcome);
+    } catch (err) {
+      logger.debug(`First-connect observer failed: ${err.message}`);
+    }
+  }
+  noticeNotFound() {
+    if (this.notFoundNotice !== "unsent") return;
+    this.notFoundNotice = "sending";
+    const { host, port, token } = this.opts.hub;
+    fetch(`http://${host}:${port}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...token ? { Authorization: `Bearer ${token}` } : {} },
+      body: JSON.stringify({
+        title: "Codex not found",
+        message: `The Codex adapter cannot find "${this.opts.command}". Open a new terminal and restart the hub, or set "codex.command" in ~/.claude-alarm/config.json.`,
+        level: "warning"
+      }),
+      signal: AbortSignal.timeout(this.opts.noticeTimeoutMs ?? 5e3)
+    }).then((res) => {
+      this.notFoundNotice = res.ok ? "sent" : "unsent";
+      if (!res.ok) logger.debug(`Codex not-found notice was refused (${res.status})`);
+    }).catch((err) => {
+      this.notFoundNotice = err.name === "TimeoutError" ? "sent" : "unsent";
+      logger.debug(`Codex not-found notice failed: ${err.message}`);
+    });
+  }
+  setReady(ready) {
+    this.ready = ready;
+    this.link.setReady(ready);
+  }
+  requireDaemon() {
+    if (!this.ready || !this.rpc) throw new Error(`Codex is not connected on ${this.hostName}.`);
+    return this.rpc;
+  }
+  async onCall(call) {
+    if (call.kind === "folders") return { folders: await this.folders() };
+    return { sessionId: await this.create(call.cwd) };
+  }
+  async folders() {
+    const page = await this.requireDaemon().request("thread/list", { limit: 50, sortKey: "updated_at" });
+    return [...new Set(page.data.map((t) => t.cwd).filter(Boolean))].slice(0, 10);
+  }
+  async create(input) {
+    const rpc = this.requireDaemon();
+    const cwd = cleanFolder(input);
+    const isDir = path4.isAbsolute(cwd) && await fs5.promises.stat(cwd).then((s) => s.isDirectory(), () => false);
+    if (!isDir) throw new Error(`Folder not found on ${this.hostName}: ${cwd}`);
+    let thread;
+    try {
+      ({ thread } = await rpc.request("thread/start", { cwd, sandbox: "danger-full-access", approvalPolicy: "never" }, null));
+    } catch (err) {
+      throw new Error(`Codex could not start the conversation: ${err.message}`);
+    }
+    this.pins.add(thread.id);
+    this.upsert(thread);
+    const t = this.threads.get(thread.id);
+    if (!t) {
+      this.pins.delete(thread.id);
+      throw new Error("Codex started a conversation claude-alarm cannot follow.");
+    }
+    t.subscribed = true;
+    return codexSessionId(thread.id);
+  }
   async discover() {
+    const rpc = this.rpc;
+    const pinned = [...this.pins];
     const ids = [];
     let cursor;
     do {
-      const page = await this.rpc.request(
-        "thread/loaded/list",
-        cursor ? { cursor } : {}
-      );
+      const page = await rpc.request("thread/loaded/list", cursor ? { cursor } : {});
       ids.push(...page.data);
       cursor = page.nextCursor;
     } while (cursor);
     for (const id of ids) await this.refresh(id);
+    if (this.rpc !== rpc) return;
+    for (const id of pinned) if (!ids.includes(id)) this.pins.delete(id);
   }
   async refresh(threadId) {
     try {
@@ -607,18 +833,18 @@ var CodexAdapter = class {
       this.drop(thread.id);
       return;
     }
-    const existing2 = this.threads.get(thread.id);
-    if (existing2) {
-      existing2.thread = thread;
-      existing2.hub.reregister();
+    const existing = this.threads.get(thread.id);
+    if (existing) {
+      existing.thread = thread;
+      existing.hub.reregister();
     } else {
-      const { host: host2, port: port2, token: token2 } = this.opts.hub;
+      const { host, port, token } = this.opts.hub;
       const hub = new HubClient(
         codexSessionId(thread.id),
         threadTitle(thread),
-        host2,
-        port2,
-        token2,
+        host,
+        port,
+        token,
         () => void 0,
         () => this.registration(thread.id)
       );
@@ -629,6 +855,7 @@ var CodexAdapter = class {
         wantSubscribed: false,
         sync: Promise.resolve(),
         pendingTurn: false,
+        sending: Promise.resolve(),
         turns: /* @__PURE__ */ new Map(),
         unrelayed: false,
         files: /* @__PURE__ */ new Map()
@@ -642,12 +869,12 @@ var CodexAdapter = class {
     const t = this.threads.get(threadId);
     if (!t) return {};
     const title = threadTitle(t.thread);
-    return { name: title, title, cwd: t.thread.cwd, agentKind: "codex", status: hubStatus(t.thread.status) };
+    return { name: title, title, cwd: t.thread.cwd, agentKind: "codex", status: hubStatus(t.thread.status), closable: this.pins.has(threadId) };
   }
   want(threadId, subscribed) {
     const t = this.threads.get(threadId);
     if (!t) return Promise.resolve();
-    t.wantSubscribed = subscribed;
+    t.wantSubscribed = subscribed || this.pins.has(threadId);
     t.sync = t.sync.then(() => this.syncSubscription(t));
     return t.sync;
   }
@@ -665,6 +892,7 @@ var CodexAdapter = class {
       }
     } catch (err) {
       logger.debug(`subscription sync for ${threadId} deferred: ${err.message}`);
+      if (t.wantSubscribed && !t.subscribed && t.thread.status.type === "active") t.unrelayed = true;
     }
   }
   releaseLater(t) {
@@ -687,6 +915,25 @@ var CodexAdapter = class {
     t.releaseTimer = void 0;
     t.hub.disconnect();
   }
+  busy(t) {
+    return t.thread.status.type === "active" || t.pendingTurn;
+  }
+  async close(threadId) {
+    const t = this.threads.get(threadId);
+    if (!t || !this.pins.delete(threadId)) return;
+    t.hub.reregister();
+    if (this.busy(t)) return;
+    await this.want(threadId, false);
+    if (this.threads.get(threadId) !== t || this.busy(t) || t.wantSubscribed) return;
+    if (!t.subscribed) {
+      this.drop(threadId);
+      return;
+    }
+    this.pins.add(threadId);
+    t.hub.reregister();
+    void this.want(threadId, true);
+    this.notify(threadId, "Not closed", "Codex did not release the conversation. Try closing it again.", "warning");
+  }
   onNotification(method, params) {
     switch (method) {
       case "thread/started":
@@ -706,6 +953,7 @@ var CodexAdapter = class {
       case "thread/closed":
       case "thread/archived":
       case "thread/deleted":
+        this.pins.delete(params.threadId);
         this.drop(params.threadId);
         break;
       case "item/started":
@@ -730,6 +978,7 @@ var CodexAdapter = class {
       return;
     }
     if (status.type === "notLoaded") {
+      this.pins.delete(threadId);
       this.drop(threadId);
       return;
     }
@@ -763,6 +1012,7 @@ var CodexAdapter = class {
     const collected = t.turns.get(turn.id) ?? [];
     t.turns.delete(turn.id);
     t.files.clear();
+    if (!t.thread.name?.trim() && !t.thread.preview?.trim()) void this.refresh(threadId);
     if (t.thread.status.type !== "active") void this.want(threadId, false);
     if (turn.status === "failed" || turn.error) {
       this.notify(threadId, "Codex task failed", turn.error?.message ?? "The task ended with an error.", "error");
@@ -778,33 +1028,75 @@ var CodexAdapter = class {
   }
   onHubMessage(threadId, msg) {
     if (msg.type === "message_to_session") {
-      void this.sendTurn(threadId, msg.content, msg.source);
+      this.enqueue(threadId, async () => textInput(msg.content, msg.source));
     } else if (msg.type === "image_to_session") {
-      this.notify(threadId, "Not delivered", "Codex sessions do not accept images yet.", "warning");
+      this.enqueue(threadId, () => imageInput(msg.imagePath, msg.mimeType, msg.content, msg.source));
     } else if (msg.type === "permission_response") {
       this.answer(threadId, msg.requestId, msg.choiceId);
+    } else if (msg.type === "codex_close") {
+      void this.close(threadId);
     }
   }
-  async sendTurn(threadId, content, source) {
+  // One message at a time per conversation, so a message right behind another sees the turn the first one started.
+  enqueue(threadId, build) {
     const t = this.threads.get(threadId);
     if (!t) return;
-    if (t.thread.status.type !== "idle" || t.pendingTurn) {
-      this.notify(threadId, "Not delivered", "Codex is busy, so the message was not delivered. Send it again when the task finishes.", "warning");
+    t.sending = t.sending.then(() => this.deliver(t, build)).catch((err) => logger.warn(`Codex delivery for ${threadId} failed: ${err.message}`));
+  }
+  async deliver(t, build) {
+    const threadId = t.thread.id;
+    if (this.threads.get(threadId) !== t) return;
+    if (hubStatus(t.thread.status) === "waiting_input") {
+      this.notify(threadId, "Not delivered", "Codex is waiting for an approval or input. Answer it first, then send the message again.", "warning");
       return;
     }
+    let input;
+    try {
+      input = await build();
+    } catch (err) {
+      logger.debug(`Codex input for ${threadId} could not be built: ${err.message}`);
+      this.notify(threadId, "Not delivered", "The image could not be read here, so it was not delivered. Codex may be running on another PC.", "warning");
+      return;
+    }
+    if (this.threads.get(threadId) !== t) return;
     t.pendingTurn = true;
+    const wasUnrelayed = t.unrelayed;
     try {
-      if (!this.rpc) throw new Error("not connected to the Codex daemon");
+      const rpc = this.rpc;
+      if (!rpc) throw new Error("not connected to the Codex daemon");
       await this.want(threadId, true);
-      t.unrelayed = !t.subscribed;
-      await this.rpc.request("turn/start", { threadId, input: [{ type: "text", text: withSourcePrefix(content, source) }] });
+      const unsubscribed = !t.subscribed;
+      const running = await this.runningTurn(rpc, threadId);
+      if (this.threads.get(threadId) !== t) return;
+      if (unsubscribed) t.unrelayed = true;
+      if (running) {
+        await rpc.request("turn/steer", { threadId, expectedTurnId: running, input });
+        this.notify(threadId, "Queued", "Queued: Codex will read it after its current step.", "info");
+        return;
+      }
+      await rpc.request("turn/start", { threadId, input });
     } catch (err) {
       t.pendingTurn = false;
-      t.unrelayed = false;
+      t.unrelayed = wasUnrelayed;
       this.releaseLater(t);
       this.notify(threadId, "Not delivered", `Codex rejected the message: ${err.message}`, "warning");
     }
   }
+  // The list is unavailable before a new conversation's first turn; starting a turn is safe then, since turn/start steers a running turn.
+  async runningTurn(rpc, threadId) {
+    try {
+      const page = await rpc.request("thread/turns/list", {
+        threadId,
+        limit: 1,
+        sortDirection: "desc"
+      });
+      const turn = page.data?.[0];
+      return turn?.status === "inProgress" ? turn.id : void 0;
+    } catch (err) {
+      logger.debug(`thread/turns/list ${threadId} failed: ${err.message}`);
+      return void 0;
+    }
+  }
   onServerRequest(rpcId, method, params) {
     const t = params?.threadId ? this.threads.get(params.threadId) : void 0;
     let view = null;
@@ -819,7 +1111,7 @@ var CodexAdapter = class {
     }
     if (!t || !view) {
       if (t && (broken || USER_REQUESTS.has(method))) {
-        this.notify(t.thread.id, "Codex is waiting", "Codex asked for input that claude-alarm cannot relay. Handle it in Codex.", "warning");
+        this.waitingInCodex(t.thread.id);
       } else {
         logger.debug(`Ignoring Codex server request ${method}`);
       }
@@ -829,17 +1121,26 @@ var CodexAdapter = class {
       if (a.threadId === t.thread.id && a.rpcId === rpcId) return;
     }
     const requestId = randomUUID2();
-    this.approvals.set(requestId, { threadId: t.thread.id, rpcId, turnId: params.turnId, choices: view.choices, answered: false });
-    t.hub.send({
-      type: "permission_request",
-      sessionId: codexSessionId(t.thread.id),
-      requestId,
-      toolName: view.toolName,
-      description: view.description,
-      inputPreview: view.inputPreview,
-      timestamp: Date.now(),
-      choices: view.choices.map((c, i) => ({ id: String(i), label: c.label }))
-    });
+    try {
+      this.approvals.set(requestId, { threadId: t.thread.id, rpcId, turnId: params.turnId, choices: view.choices, answered: false });
+      t.hub.send({
+        type: "permission_request",
+        sessionId: codexSessionId(t.thread.id),
+        requestId,
+        toolName: view.toolName,
+        description: view.description,
+        inputPreview: view.inputPreview,
+        timestamp: Date.now(),
+        choices: view.choices.map((c, i) => ({ id: String(i), label: c.label }))
+      });
+    } catch (err) {
+      this.approvals.delete(requestId);
+      logger.warn(`Codex ${method} could not be relayed: ${err.message}`);
+      this.waitingInCodex(t.thread.id);
+    }
+  }
+  waitingInCodex(threadId) {
+    this.notify(threadId, "Codex is waiting", "Codex asked for input that claude-alarm cannot relay. Handle it in Codex.", "warning");
   }
   answer(threadId, requestId, choiceId) {
     const a = this.approvals.get(requestId);
@@ -865,49 +1166,302 @@ var CodexAdapter = class {
   }
 };
 
-// src/codex/main.ts
-function isRunning(pid) {
+// src/shared/hub-url.ts
+import net from "net";
+function hubUrlHost(host) {
+  if (host === "" || host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return net.isIPv6(host) ? `[${host}]` : host;
+}
+
+// src/codex/hub-target.ts
+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/instance-lock.ts
+import crypto from "crypto";
+import fs6 from "fs";
+import net2 from "net";
+import path5 from "path";
+var CONTROL_PROTOCOL = 1;
+var STALE_GUARD_MS = 1e4;
+var STOP_PROOF_LABEL = "claude-alarm codex stop";
+var MAX_LINE_BYTES = 4096;
+var REQUEST_IDLE_MS = 2e3;
+var MAX_SOCKET_PATH_BYTES = 103;
+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 {
-    process.kill(pid, 0);
-    return true;
+    dir = fs6.realpathSync.native(configDir);
   } catch {
-    return false;
+    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(endpoint2, request, timeoutMs) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let settled = false;
+    const socket = net2.connect(endpoint2);
+    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(endpoint2, timeoutMs = 1e3) {
+  const answer = await ask(endpoint2, { 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" };
 }
+var line = (message) => `${JSON.stringify(message)}
+`;
+function controlServer(owner) {
+  const expectedProof = Buffer.from(stopProof(owner.token));
+  return net2.createServer((socket) => {
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("error", () => {
+    });
+    const idle = setTimeout(() => socket.destroy(), REQUEST_IDLE_MS);
+    socket.on("close", () => clearTimeout(idle));
+    const onData = (chunk) => {
+      buffer += chunk;
+      const end = buffer.indexOf("\n");
+      if (end < 0) {
+        if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) socket.destroy();
+        return;
+      }
+      socket.off("data", onData);
+      clearTimeout(idle);
+      let request = null;
+      try {
+        request = JSON.parse(buffer.slice(0, end));
+      } catch {
+      }
+      if (request?.type === "status") {
+        socket.end(line({ type: "status", protocol: CONTROL_PROTOCOL, pid: owner.pid }));
+      } else if (request?.type === "stop") {
+        const proof = typeof request.proof === "string" ? Buffer.from(request.proof) : void 0;
+        if (owner.token !== "" && proof && proof.length === expectedProof.length && crypto.timingSafeEqual(proof, expectedProof)) {
+          socket.end(line({ type: "stopping", pid: owner.pid }), () => owner.onStop());
+        } else {
+          socket.end(line({ type: "error", error: "unauthorized" }));
+        }
+      } else {
+        socket.end(line({ type: "error", error: "unknown request" }));
+      }
+    };
+    socket.on("data", onData);
+  });
+}
+function listenControl(endpoint2, owner) {
+  const server = controlServer(owner);
+  return new Promise((resolve) => {
+    const onError = (err) => {
+      resolve(err.code === "EADDRINUSE" ? { kind: "busy" } : { kind: "unknown", error: err.code ?? err.message });
+    };
+    server.once("error", onError);
+    server.listen(endpoint2, () => {
+      server.off("error", onError);
+      server.on("error", () => {
+      });
+      resolve({ kind: "owner", close: () => new Promise((done) => server.close(() => done())) });
+    });
+  });
+}
+function settle(attempt, busy) {
+  return attempt.kind === "busy" ? { kind: "unknown", error: busy } : attempt;
+}
+async function acquireLock(endpoint2, owner, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const listen = deps.listen ?? listenControl;
+  const query = deps.queryOwner ?? ((e) => queryOwner(e));
+  if (platform !== "win32" && Buffer.byteLength(endpoint2) > MAX_SOCKET_PATH_BYTES) {
+    return { kind: "unknown", error: `control socket path is too long: ${endpoint2}` };
+  }
+  const first = await listen(endpoint2, owner);
+  if (first.kind !== "busy") return first;
+  const state = await query(endpoint2);
+  if (state.state === "running") return { kind: "held", pid: state.pid };
+  if (state.state === "unknown") return { kind: "unknown", error: state.error };
+  if (platform === "win32") return settle(await listen(endpoint2, owner), "the control pipe is in use but does not answer");
+  return recoverSocket(endpoint2, owner, listen, query, deps.fs ?? fs6, deps.now ?? Date.now);
+}
+async function recoverSocket(endpoint2, owner, listen, query, f, now) {
+  const guard = `${endpoint2}.lock`;
+  const blocked = takeGuard(guard, f, now);
+  if (blocked) return { kind: "unknown", error: blocked };
+  try {
+    const state = await query(endpoint2);
+    if (state.state === "running") return { kind: "held", pid: state.pid };
+    if (state.state === "unknown") return { kind: "unknown", error: state.error };
+    try {
+      f.unlinkSync(endpoint2);
+    } catch (err) {
+      if (err.code !== "ENOENT") return { kind: "unknown", error: err.message };
+    }
+    return settle(await listen(endpoint2, owner), "the control socket is in use but does not answer");
+  } finally {
+    try {
+      f.rmdirSync(guard);
+    } catch {
+    }
+  }
+}
+function takeGuard(guard, f, now) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      f.mkdirSync(guard);
+      return void 0;
+    } catch (err) {
+      if (err.code !== "EEXIST") return err.message;
+    }
+    let age;
+    try {
+      age = now() - f.statSync(guard).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (age <= STALE_GUARD_MS) return "another Codex adapter is starting";
+    try {
+      f.rmdirSync(guard);
+    } catch {
+    }
+  }
+  return "another Codex adapter is starting";
+}
+
+// src/codex/main.ts
+var WAIT_MIN_MS = 2e3;
+var WAIT_MAX_MS = 3e4;
 installCrashGuard("codex adapter");
 process.stdout.on("error", () => {
 });
 process.stderr.on("error", () => {
 });
 var config = loadConfig();
-var existing = fs4.existsSync(CODEX_PID_FILE) ? parseInt(fs4.readFileSync(CODEX_PID_FILE, "utf-8").trim(), 10) : NaN;
-if (!Number.isNaN(existing) && existing !== process.pid && isRunning(existing)) {
-  logger.info(`Codex adapter already running (PID: ${existing})`);
-  process.exit(0);
-}
-fs4.writeFileSync(CODEX_PID_FILE, String(process.pid), "utf-8");
-logStartup("Codex adapter");
-var host = process.env.CLAUDE_ALARM_HUB_HOST ?? (config.hub.host === "0.0.0.0" ? DEFAULT_HUB_HOST : config.hub.host);
-var port = process.env.CLAUDE_ALARM_HUB_PORT ? parseInt(process.env.CLAUDE_ALARM_HUB_PORT, 10) : config.hub.port;
-var token = process.env.CLAUDE_ALARM_HUB_TOKEN ?? config.hub.token;
-var adapter = new CodexAdapter({ command: config.codex?.command ?? "codex", hub: { host, port, token } });
-adapter.start();
+var supervised = process.argv.includes("--watch-stdin");
+var endpoint = controlEndpoint(CONFIG_DIR);
+var adapter;
+var release;
 var exiting = false;
 var shutdown = () => {
   if (exiting) return;
   exiting = true;
-  adapter.stop();
-  try {
-    if (fs4.readFileSync(CODEX_PID_FILE, "utf-8").trim() === String(process.pid)) fs4.unlinkSync(CODEX_PID_FILE);
-  } catch {
-  }
-  process.exit(0);
+  adapter?.stop();
+  const exit = () => process.exit(0);
+  setTimeout(exit, 3e3).unref();
+  if (release) release().then(exit, exit);
+  else exit();
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-if (process.argv.includes("--watch-stdin")) {
+if (supervised) {
   process.stdin.on("end", shutdown);
   process.stdin.on("close", shutdown);
   process.stdin.resume();
 }
+function send(message, then) {
+  if (!process.send || !process.connected) {
+    then?.();
+    return;
+  }
+  process.send(message, void 0, void 0, (err) => {
+    if (err) logger.debug(`Report to the parent not delivered: ${err.message}`);
+    then?.();
+  });
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function takeLock() {
+  let delay = WAIT_MIN_MS;
+  let waitReason;
+  for (; ; ) {
+    const lock = await acquireLock(endpoint, {
+      pid: process.pid,
+      token: config.hub.token ?? "",
+      onStop: () => {
+        if (supervised) logger.warn("Stopped by claude-alarm codex stop; the hub will not start the Codex adapter again until the hub restarts");
+        shutdown();
+      }
+    });
+    if (lock.kind === "owner") {
+      release = lock.close;
+      if (waitReason !== void 0) logger.info("Codex adapter took over: the other adapter has stopped");
+      return true;
+    }
+    if (!supervised) {
+      if (lock.kind === "held") {
+        logger.info(`Codex adapter already running (PID: ${lock.pid})`);
+        send({ type: "codex-already-running", pid: lock.pid }, () => process.exit(0));
+      } else {
+        logger.error(`Codex adapter cannot start: ${lock.error}`);
+        send({ type: "codex-lock-failed", error: lock.error }, () => process.exit(1));
+      }
+      return false;
+    }
+    const reason = lock.kind === "held" ? `held:${lock.pid}` : `unknown:${lock.error}`;
+    if (reason !== waitReason) {
+      waitReason = reason;
+      if (lock.kind === "held") logger.info(`Another Codex adapter is running (PID: ${lock.pid}); this one takes over when it stops`);
+      else logger.warn(`Codex adapter control endpoint is unavailable (${lock.error}); retrying`);
+    }
+    await sleep(delay);
+    delay = Math.min(delay * 2, WAIT_MAX_MS);
+  }
+}
+void takeLock().then((owned) => {
+  if (!owned) return;
+  logStartup("Codex adapter");
+  const { host, port, token } = resolveAdapterHub(config);
+  adapter = new CodexAdapter({
+    command: config.codex?.command ?? "codex",
+    hub: { host, port, token },
+    onFirstConnect: (outcome) => send({ type: "codex-first-connect", ...outcome })
+  });
+  adapter.start();
+});
 //# sourceMappingURL=main.js.map