@delt/claude-alarm 1.2.0 → 1.3.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;
   }
@@ -366,7 +363,8 @@ 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 };
 }
@@ -394,7 +392,8 @@ var defaultSpawn = (command, args) => {
   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", () => {
   });
@@ -428,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);
     };
@@ -440,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 });
@@ -749,10 +751,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 +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)
       );
@@ -890,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) {
@@ -1108,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}`);
       }
@@ -1118,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);
@@ -1156,10 +1168,10 @@ var CodexAdapter = class {
 
 // 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 +1187,281 @@ 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);
+  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