@delt/claude-alarm 1.2.0 → 1.4.0

package/dist/codex/main.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 
-// src/codex/main.ts
-import fs6 from "fs";
-
 // src/shared/config.ts
 import fs from "fs";
 import path2 from "path";
@@ -244,12 +241,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 // src/channel/hub-client.ts
 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;
   }
@@ -360,13 +357,14 @@ var HubClient = class {
 };
 
 // src/codex/transport.ts
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import fs3 from "fs";
 import path3 from "path";
 import { Duplex } from "stream";
 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 };
+  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 };
 }
@@ -389,13 +387,116 @@ function findCodex(command, platform = process.platform, env = process.env) {
   ];
   return candidates.find((file) => !!file && fs3.existsSync(file));
 }
+var shellSpawns = /* @__PURE__ */ new WeakSet();
+var spawnedThroughShell = (child) => shellSpawns.has(child);
 var defaultSpawn = (command, args) => {
   const { file, shell } = resolveCommand(command);
-  if (shell) return spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
-  return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  if (!shell) return spawn(file, args, { stdio: "pipe", windowsHide: true });
+  const child = spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
+  shellSpawns.add(child);
+  return child;
+};
+var queryProcesses = () => new Promise((resolve, reject) => {
+  const script = "@(Get-CimInstance Win32_Process | ForEach-Object { [pscustomobject]@{ pid = [int]$_.ProcessId; parentPid = [int]$_.ParentProcessId; creationTime = $_.CreationDate.ToUniversalTime().ToString('o') } }) | ConvertTo-Json -Compress";
+  execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { windowsHide: true, timeout: 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    try {
+      const rows = JSON.parse(stdout);
+      if (!Array.isArray(rows) || rows.some((row) => !Number.isInteger(row.pid) || !Number.isInteger(row.parentPid) || typeof row.creationTime !== "string")) {
+        throw new Error("invalid process snapshot");
+      }
+      resolve(rows);
+    } catch (error) {
+      reject(error);
+    }
+  });
+});
+var runFile = (file, args, options, callback) => {
+  execFile(file, args, options, (err) => callback(err));
 };
-function connectProxy(command, spawnFn = defaultSpawn) {
+function descendantsOf(rootPid, rows) {
+  const root = rows.find((row) => row.pid === rootPid);
+  if (!root) return void 0;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set([root.pid]);
+  let level = [root];
+  for (let depth = 1; level.length; depth++) {
+    const next = [];
+    for (const parent of level) {
+      for (const row of rows) {
+        if (row.parentPid !== parent.pid || seen.has(row.pid) || row.creationTime < parent.creationTime) continue;
+        seen.add(row.pid);
+        next.push(row);
+        found.push({ ...row, depth });
+      }
+    }
+    level = next;
+  }
+  return found;
+}
+var exited = (child) => child.exitCode !== null || child.signalCode !== null;
+function treeKiller(platform = process.platform, run = runFile, query = queryProcesses, throughShell = spawnedThroughShell) {
+  const recorded = /* @__PURE__ */ new WeakMap();
+  const stop = (pid) => new Promise((resolve) => {
+    run("taskkill", ["/PID", String(pid), "/F"], { windowsHide: true }, (err) => {
+      if (err) logger.debug(`taskkill ${pid} failed: ${err.message}`);
+      resolve();
+    });
+  });
+  const stopDeepestFirst = async (descendants) => {
+    for (const descendant of [...descendants].sort((a, b) => b.depth - a.depth)) await stop(descendant.pid);
+  };
+  const snapshot = async () => {
+    try {
+      return await query();
+    } catch (err) {
+      logger.debug(`codex process query failed: ${String(err)}`);
+      return void 0;
+    }
+  };
+  const isShellTree = (child) => platform === "win32" && child.pid !== void 0 && throughShell(child);
+  const killer = async (child) => {
+    if (!isShellTree(child)) {
+      if (!exited(child)) child.kill();
+      return;
+    }
+    if (!exited(child)) {
+      const rows = await snapshot();
+      if (!exited(child)) {
+        const descendants2 = rows && descendantsOf(child.pid, rows);
+        if (descendants2) await stopDeepestFirst(descendants2);
+        child.kill();
+        return;
+      }
+    }
+    const descendants = await recorded.get(child) ?? [];
+    if (!descendants.length) return;
+    const current = await snapshot();
+    if (!current) return;
+    await stopDeepestFirst(descendants.filter((d) => current.some((row) => row.pid === d.pid && row.creationTime === d.creationTime)));
+  };
+  killer.track = async (child) => {
+    if (!isShellTree(child) || exited(child)) return;
+    const earlier = recorded.get(child);
+    const latest = (async () => {
+      const rows = await snapshot();
+      const found = rows && !exited(child) ? descendantsOf(child.pid, rows) ?? [] : [];
+      const before = await earlier ?? [];
+      return [...before, ...found.filter((d) => !before.some((b) => b.pid === d.pid && b.creationTime === d.creationTime))];
+    })();
+    recorded.set(child, latest);
+    await latest;
+  };
+  return killer;
+}
+var killTree = treeKiller();
+var HANDSHAKE_TIMEOUT_MS = 1e4;
+function connectProxy(command, spawnFn = defaultSpawn, timeoutMs = HANDSHAKE_TIMEOUT_MS, killTreeFn = killTree) {
   const child = spawnFn(command, ["app-server", "proxy"]);
+  void killTreeFn.track?.(child);
   child.stdin?.on("error", () => {
   });
   child.stderr?.on("data", (d) => logger.debug(`codex proxy: ${String(d).trim()}`));
@@ -422,17 +523,20 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   const ws = new WebSocket3("ws://localhost/", {
     createConnection: (() => stream)
   });
-  const close = () => {
+  let closing;
+  const close = () => closing ??= (async () => {
     ws.terminate();
-    child.kill();
-  };
+    child.stdin?.end();
+    await killTreeFn(child);
+  })();
   return new Promise((resolve, reject) => {
     let settled = false;
+    const timer = setTimeout(() => fail(new Error(`codex daemon did not answer within ${timeoutMs / 1e3}s`)), timeoutMs);
     const fail = (err) => {
       if (settled) return;
       settled = true;
-      close();
-      reject(err);
+      clearTimeout(timer);
+      void close().then(() => reject(err), () => reject(err));
     };
     child.on("error", fail);
     child.once("exit", (code) => fail(new Error(`codex proxy exited (code ${code})`)));
@@ -440,8 +544,10 @@ function connectProxy(command, spawnFn = defaultSpawn) {
     ws.once("open", () => {
       if (settled) return;
       settled = true;
+      clearTimeout(timer);
       child.on("error", (err) => logger.warn(`codex proxy error: ${err.message}`));
       ws.on("error", (err) => logger.warn(`codex daemon socket error: ${err.message}`));
+      void killTreeFn.track?.(child);
       resolve({ ws, close });
     });
   });
@@ -651,6 +757,8 @@ var CodexAdapter = class {
     this.link = new CodexHubLink(opts.hub, { id: randomUUID2(), host: this.hostName }, (call) => this.onCall(call), opts.linkReconnectMs);
   }
   conn;
+  connecting;
+  closing = /* @__PURE__ */ new Set();
   rpc;
   threads = /* @__PURE__ */ new Map();
   approvals = /* @__PURE__ */ new Map();
@@ -666,22 +774,29 @@ var CodexAdapter = class {
   start() {
     this.stopped = false;
     this.link.connect();
-    void this.connect();
+    this.connecting = this.connect();
   }
-  stop() {
+  async 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);
-    this.conn?.close();
+    this.closeConn(this.conn);
+    await this.connecting;
+    await Promise.all(this.closing);
+  }
+  closeConn(conn) {
+    if (!conn) return;
+    const closing = conn.close().finally(() => this.closing.delete(closing));
+    this.closing.add(closing);
   }
   async connect() {
     let rpc;
     try {
       const conn = await connectProxy(this.opts.command, this.opts.spawnFn);
       if (this.stopped) {
-        conn.close();
+        this.closeConn(conn);
         return;
       }
       const live = new RpcClient(conn.ws, this.opts.rpcTimeoutMs);
@@ -713,7 +828,7 @@ var CodexAdapter = class {
       });
       if (rpc && this.rpc === rpc) {
         this.rpc = void 0;
-        this.conn?.close();
+        this.closeConn(this.conn);
         this.conn = void 0;
       }
       for (const id of [...this.threads.keys()]) this.drop(id);
@@ -723,7 +838,7 @@ var CodexAdapter = class {
   onDaemonLost() {
     this.setReady(false);
     this.rpc = void 0;
-    this.conn?.close();
+    this.closeConn(this.conn);
     this.conn = void 0;
     for (const id of [...this.threads.keys()]) this.drop(id);
     if (!this.stopped) logger.warn("Codex daemon connection lost");
@@ -733,7 +848,7 @@ var CodexAdapter = class {
     if (this.stopped || this.retryTimer) return;
     this.retryTimer = setTimeout(() => {
       this.retryTimer = void 0;
-      void this.connect();
+      this.connecting = this.connect();
     }, this.delay);
     this.delay = Math.min(this.delay * 2, this.opts.reconnectMaxMs ?? 6e4);
   }
@@ -749,10 +864,10 @@ var CodexAdapter = class {
   noticeNotFound() {
     if (this.notFoundNotice !== "unsent") return;
     this.notFoundNotice = "sending";
-    const { host: host2, port: port2, token: token2 } = this.opts.hub;
-    fetch(`http://${host2}:${port2}/api/notify`, {
+    const { host, port, token } = this.opts.hub;
+    fetch(`http://${host}:${port}/api/notify`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...token2 ? { Authorization: `Bearer ${token2}` } : {} },
+      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.`,
@@ -831,18 +946,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)
       );
@@ -890,6 +1005,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) {
@@ -1025,9 +1141,9 @@ var CodexAdapter = class {
   }
   onHubMessage(threadId, msg) {
     if (msg.type === "message_to_session") {
-      this.enqueue(threadId, async () => textInput(msg.content, msg.source));
+      this.enqueue(threadId, async () => textInput(msg.content, msg.source), msg.source);
     } else if (msg.type === "image_to_session") {
-      this.enqueue(threadId, () => imageInput(msg.imagePath, msg.mimeType, msg.content, msg.source));
+      this.enqueue(threadId, () => imageInput(msg.imagePath, msg.mimeType, msg.content, msg.source), msg.source);
     } else if (msg.type === "permission_response") {
       this.answer(threadId, msg.requestId, msg.choiceId);
     } else if (msg.type === "codex_close") {
@@ -1035,16 +1151,16 @@ var CodexAdapter = class {
     }
   }
   // One message at a time per conversation, so a message right behind another sees the turn the first one started.
-  enqueue(threadId, build) {
+  enqueue(threadId, build, source) {
     const t = this.threads.get(threadId);
     if (!t) return;
-    t.sending = t.sending.then(() => this.deliver(t, build)).catch((err) => logger.warn(`Codex delivery for ${threadId} failed: ${err.message}`));
+    t.sending = t.sending.then(() => this.deliver(t, build, source)).catch((err) => logger.warn(`Codex delivery for ${threadId} failed: ${err.message}`));
   }
-  async deliver(t, build) {
+  async deliver(t, build, source) {
     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");
+    if (this.waitingForAnswer(t)) {
+      this.refuseWhileWaiting(threadId);
       return;
     }
     let input;
@@ -1065,20 +1181,37 @@ var CodexAdapter = class {
       const unsubscribed = !t.subscribed;
       const running = await this.runningTurn(rpc, threadId);
       if (this.threads.get(threadId) !== t) return;
+      if (this.waitingForAnswer(t)) {
+        this.abandonDelivery(t, wasUnrelayed);
+        this.refuseWhileWaiting(threadId);
+        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");
+        this.notify(threadId, "Queued", "Queued: Codex will read it after its current step.", "info", source);
         return;
       }
       await rpc.request("turn/start", { threadId, input });
     } catch (err) {
-      t.pendingTurn = false;
-      t.unrelayed = wasUnrelayed;
-      this.releaseLater(t);
+      this.abandonDelivery(t, wasUnrelayed);
       this.notify(threadId, "Not delivered", `Codex rejected the message: ${err.message}`, "warning");
     }
   }
+  abandonDelivery(t, wasUnrelayed) {
+    t.pendingTurn = false;
+    t.unrelayed = wasUnrelayed;
+    this.releaseLater(t);
+  }
+  // The approval request itself can arrive before the status broadcast that marks the thread as waiting.
+  waitingForAnswer(t) {
+    if (hubStatus(t.thread.status) === "waiting_input") return true;
+    for (const a of this.approvals.values()) if (a.threadId === t.thread.id && !a.answered) return true;
+    return false;
+  }
+  refuseWhileWaiting(threadId) {
+    this.notify(threadId, "Not delivered", "Codex is waiting for an approval or input. Answer it first, then send the message again.", "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 {
@@ -1108,7 +1241,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}`);
       }
@@ -1118,17 +1251,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);
@@ -1149,17 +1291,17 @@ var CodexAdapter = class {
     this.approvals.delete(requestId);
     this.threads.get(a.threadId)?.hub.send({ type: "permission_resolved", sessionId: codexSessionId(a.threadId), requestId, state });
   }
-  notify(threadId, title, message, level) {
-    this.threads.get(threadId)?.hub.send({ type: "notify", sessionId: codexSessionId(threadId), title, message, level });
+  notify(threadId, title, message, level, to) {
+    this.threads.get(threadId)?.hub.send({ type: "notify", sessionId: codexSessionId(threadId), title, message, level, ...to ? { to } : {} });
   }
 };
 
 // src/shared/hub-url.ts
 import net from "net";
-function hubUrlHost(host2) {
-  if (host2 === "" || host2 === "0.0.0.0") return "127.0.0.1";
-  if (host2 === "::") return "[::1]";
-  return net.isIPv6(host2) ? `[${host2}]` : host2;
+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
@@ -1175,56 +1317,280 @@ function resolveAdapterHub(config2, env = process.env) {
   };
 }
 
-// src/codex/main.ts
-function isRunning(pid) {
+// 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 = fs6.existsSync(CODEX_PID_FILE) ? parseInt(fs6.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);
-}
-fs6.writeFileSync(CODEX_PID_FILE, String(process.pid), "utf-8");
-logStartup("Codex adapter");
-var { host, port, token } = resolveAdapterHub(config);
-var adapter = new CodexAdapter({
-  command: config.codex?.command ?? "codex",
-  hub: { host, port, token },
-  onFirstConnect: (outcome) => {
-    if (!process.send || !process.connected) return;
-    process.send({ type: "codex-first-connect", ...outcome }, void 0, void 0, (err) => {
-      if (err) logger.debug(`First-connect report not delivered: ${err.message}`);
-    });
-  }
-});
-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 (fs6.readFileSync(CODEX_PID_FILE, "utf-8").trim() === String(process.pid)) fs6.unlinkSync(CODEX_PID_FILE);
-  } catch {
-  }
-  process.exit(0);
+  const stopped = adapter?.stop();
+  const exit = () => process.exit(0);
+  setTimeout(exit, 3e3).unref();
+  Promise.all([stopped, release?.()]).then(exit, 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