@delt/claude-alarm 1.1.1 → 1.2.0

package/dist/codex/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/codex/main.ts
-import fs4 from "fs";
+import fs6 from "fs";
 
 // src/shared/config.ts
 import fs from "fs";
@@ -21,6 +21,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,11 +134,115 @@ 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 = () => ({})) {
     this.sessionId = sessionId;
@@ -160,7 +265,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 +305,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 +330,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 +364,10 @@ 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);
+  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,6 +380,15 @@ 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 });
@@ -305,7 +419,7 @@ function connectProxy(command, spawnFn = defaultSpawn) {
   }, ref() {
   }, unref() {
   } });
-  const ws = new WebSocket2("ws://localhost/", {
+  const ws = new WebSocket3("ws://localhost/", {
     createConnection: (() => stream)
   });
   const close = () => {
@@ -333,6 +447,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 +523,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 +641,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 +657,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 +684,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 +698,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 +721,7 @@ var CodexAdapter = class {
     }
   }
   onDaemonLost() {
+    this.setReady(false);
     this.rpc = void 0;
     this.conn?.close();
     this.conn = void 0;
@@ -581,18 +737,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: host2, port: port2, token: token2 } = this.opts.hub;
+    fetch(`http://${host2}:${port2}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...token2 ? { Authorization: `Bearer ${token2}` } : {} },
+      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 {
@@ -629,6 +853,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 +867,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;
   }
@@ -687,6 +912,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 +950,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 +975,7 @@ var CodexAdapter = class {
       return;
     }
     if (status.type === "notLoaded") {
+      this.pins.delete(threadId);
       this.drop(threadId);
       return;
     }
@@ -763,6 +1009,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 +1025,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;
@@ -865,6 +1154,27 @@ 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;
+}
+
+// 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/main.ts
 function isRunning(pid) {
   try {
@@ -880,17 +1190,24 @@ 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;
+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);
 }
-fs4.writeFileSync(CODEX_PID_FILE, String(process.pid), "utf-8");
+fs6.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 } });
+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 exiting = false;
 var shutdown = () => {
@@ -898,7 +1215,7 @@ var shutdown = () => {
   exiting = true;
   adapter.stop();
   try {
-    if (fs4.readFileSync(CODEX_PID_FILE, "utf-8").trim() === String(process.pid)) fs4.unlinkSync(CODEX_PID_FILE);
+    if (fs6.readFileSync(CODEX_PID_FILE, "utf-8").trim() === String(process.pid)) fs6.unlinkSync(CODEX_PID_FILE);
   } catch {
   }
   process.exit(0);