@delt/claude-alarm 0.9.0 → 1.0.0

package/dist/codex/main.js

@@ -0,0 +1,774 @@
+#!/usr/bin/env node
+
+// src/codex/main.ts
+import fs4 from "fs";
+
+// src/shared/config.ts
+import fs from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
+
+// src/shared/constants.ts
+import path from "path";
+import os from "os";
+var DEFAULT_HUB_HOST = "127.0.0.1";
+var DEFAULT_HUB_PORT = 7900;
+var CONFIG_DIR = path.join(os.homedir(), ".claude-alarm");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var PID_FILE = path.join(CONFIG_DIR, "hub.pid");
+var LOG_FILE = path.join(CONFIG_DIR, "hub.log");
+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 CHANNEL_SERVER_VERSION = "0.1.0";
+
+// src/shared/config.ts
+var DEFAULT_CONFIG = {
+  hub: {
+    host: DEFAULT_HUB_HOST,
+    port: DEFAULT_HUB_PORT
+  },
+  notifications: {
+    desktop: true,
+    sound: true
+  },
+  webhooks: []
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  let config2;
+  if (!fs.existsSync(CONFIG_FILE)) {
+    config2 = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+  } else {
+    try {
+      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      config2 = { ...DEFAULT_CONFIG, ...parsed, hub: { ...DEFAULT_CONFIG.hub, ...parsed.hub }, ...parsed.telegram ? { telegram: parsed.telegram } : {} };
+    } catch {
+      config2 = { ...DEFAULT_CONFIG, hub: { ...DEFAULT_CONFIG.hub } };
+    }
+  }
+  if (!config2.hub.token) {
+    config2.hub.token = randomUUID();
+    saveConfig(config2);
+  }
+  return config2;
+}
+function saveConfig(config2) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+}
+
+// src/shared/crash-guard.ts
+import fs2 from "fs";
+
+// src/shared/logger.ts
+var logger = {
+  info(msg, ...args) {
+    console.error(`[claude-alarm] ${msg}`, ...args);
+  },
+  warn(msg, ...args) {
+    console.error(`[claude-alarm WARN] ${msg}`, ...args);
+  },
+  error(msg, ...args) {
+    console.error(`[claude-alarm ERROR] ${msg}`, ...args);
+  },
+  debug(msg, ...args) {
+    if (process.env.CLAUDE_ALARM_DEBUG) {
+      console.error(`[claude-alarm DEBUG] ${msg}`, ...args);
+    }
+  }
+};
+
+// src/shared/crash-guard.ts
+var BURST_WINDOW_MS = 6e4;
+var BURST_LIMIT = 10;
+function appendToLog(text) {
+  try {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs2.appendFileSync(LOG_FILE, text, "utf-8");
+  } catch {
+  }
+}
+function describe(err) {
+  if (err instanceof Error) return err.stack ?? `${err.name}: ${err.message}`;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function installCrashGuard(context) {
+  let recent = [];
+  const handle = (kind, err) => {
+    const stack = describe(err);
+    appendToLog(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] ${kind} (${context})
+${stack}
+`);
+    logger.error(`${kind} caught by crash guard: ${stack}`);
+    const now = Date.now();
+    recent = recent.filter((t) => now - t < BURST_WINDOW_MS);
+    recent.push(now);
+    if (recent.length > BURST_LIMIT) {
+      const msg = `${recent.length} unhandled errors within ${BURST_WINDOW_MS / 1e3}s \u2014 exiting`;
+      appendToLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+      logger.error(msg);
+      process.exit(1);
+    }
+  };
+  process.on("uncaughtException", (err) => handle("uncaughtException", err));
+  process.on("unhandledRejection", (reason) => handle("unhandledRejection", reason));
+}
+function logStartup(context) {
+  appendToLog(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] ${context} started (pid ${process.pid})
+`);
+}
+
+// src/channel/hub-client.ts
+import WebSocket from "ws";
+var HubClient = class {
+  constructor(sessionId, sessionName, hubHost = DEFAULT_HUB_HOST, hubPort = DEFAULT_HUB_PORT, token2, getPeerName = () => void 0, getRegistration = () => ({})) {
+    this.sessionId = sessionId;
+    this.sessionName = sessionName;
+    this.hubHost = hubHost;
+    this.hubPort = hubPort;
+    this.token = token2;
+    this.getPeerName = getPeerName;
+    this.getRegistration = getRegistration;
+  }
+  ws = null;
+  reconnectTimer = null;
+  messageHandlers = [];
+  queue = [];
+  connected = false;
+  closed = false;
+  connect() {
+    this.closed = false;
+    const tokenQuery = this.token ? `?token=${encodeURIComponent(this.token)}` : "";
+    const url = `ws://${this.hubHost}:${this.hubPort}${WS_PATH_CHANNEL}${tokenQuery}`;
+    logger.debug(`Connecting to hub at ${url}`);
+    try {
+      const ws = new WebSocket(url);
+      this.ws = ws;
+      ws.on("open", () => {
+        if (this.ws !== ws) return;
+        logger.info("Connected to hub");
+        this.connected = true;
+        this.ws.send(JSON.stringify(this.registration()));
+        for (const msg of this.queue) {
+          this.ws.send(JSON.stringify(msg));
+        }
+        this.queue = [];
+      });
+      ws.on("message", (data) => {
+        if (this.ws !== ws) return;
+        try {
+          const msg = JSON.parse(data.toString());
+          for (const handler of this.messageHandlers) {
+            handler(msg);
+          }
+        } catch (err) {
+          logger.warn("Failed to parse hub message:", err);
+        }
+      });
+      ws.on("close", () => {
+        if (this.ws !== ws) return;
+        logger.info("Disconnected from hub");
+        this.connected = false;
+        if (!this.closed) this.scheduleReconnect();
+      });
+      ws.on("error", (err) => {
+        if (this.ws !== ws) return;
+        logger.debug(`Hub connection error: ${err.message}`);
+        this.connected = false;
+      });
+    } catch {
+      logger.debug("Failed to connect to hub, will retry");
+      this.scheduleReconnect();
+    }
+  }
+  send(msg) {
+    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    } else {
+      if (this.queue.length < 100) {
+        this.queue.push(msg);
+      }
+      logger.debug("Hub not connected, message queued");
+    }
+  }
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  disconnect() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  reregister() {
+    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(this.registration()));
+    }
+  }
+  registration() {
+    return {
+      type: "register",
+      session: {
+        id: this.sessionId,
+        name: this.sessionName,
+        status: "idle",
+        connectedAt: Date.now(),
+        lastActivity: Date.now(),
+        cwd: process.cwd(),
+        channelEnabled: true,
+        peerName: this.getPeerName(),
+        ...this.getRegistration()
+      }
+    };
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer || this.closed) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, 5e3);
+  }
+};
+
+// src/codex/transport.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import { Duplex } from "stream";
+import WebSocket2 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 dirs = (env.PATH ?? env.Path ?? "").split(path3.delimiter).filter(Boolean);
+  for (const ext of [".exe", ".cmd"]) {
+    for (const dir of dirs) {
+      const file = path3.join(dir, command + ext);
+      if (fs3.existsSync(file)) return { file, shell: ext === ".cmd" };
+    }
+  }
+  return { file: command, shell: false };
+}
+var defaultSpawn = (command, args) => {
+  const { file, shell } = resolveCommand(command);
+  if (shell) return spawn(`"${file}" ${args.join(" ")}`, { stdio: "pipe", windowsHide: true, shell: true });
+  return spawn(file, args, { stdio: "pipe", windowsHide: true });
+};
+function connectProxy(command, spawnFn = defaultSpawn) {
+  const child = spawnFn(command, ["app-server", "proxy"]);
+  child.stdin?.on("error", () => {
+  });
+  child.stderr?.on("data", (d) => logger.debug(`codex proxy: ${String(d).trim()}`));
+  const stream = new Duplex({
+    read() {
+    },
+    write(chunk, _encoding, callback) {
+      if (child.stdin?.writable) child.stdin.write(chunk, callback);
+      else callback();
+    },
+    final(callback) {
+      child.stdin?.end();
+      callback();
+    }
+  });
+  child.stdout?.on("data", (d) => stream.push(d));
+  child.stdout?.on("end", () => stream.push(null));
+  Object.assign(stream, { setNoDelay() {
+  }, setTimeout() {
+  }, setKeepAlive() {
+  }, ref() {
+  }, unref() {
+  } });
+  const ws = new WebSocket2("ws://localhost/", {
+    createConnection: (() => stream)
+  });
+  const close = () => {
+    ws.terminate();
+    child.kill();
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      close();
+      reject(err);
+    };
+    child.on("error", fail);
+    child.once("exit", (code) => fail(new Error(`codex proxy exited (code ${code})`)));
+    ws.on("error", fail);
+    ws.once("open", () => {
+      if (settled) return;
+      settled = true;
+      child.on("error", (err) => logger.warn(`codex proxy error: ${err.message}`));
+      ws.on("error", (err) => logger.warn(`codex daemon socket error: ${err.message}`));
+      resolve({ ws, close });
+    });
+  });
+}
+
+// src/codex/rpc.ts
+import { EventEmitter } from "events";
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var RpcClient = class extends EventEmitter {
+  constructor(ws, timeoutMs = 3e4) {
+    super();
+    this.ws = ws;
+    this.timeoutMs = timeoutMs;
+    ws.on("message", (data) => this.onMessage(String(data)));
+    ws.on("close", () => {
+      for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(new Error("connection closed"));
+      }
+      this.pending.clear();
+      this.emit("close");
+    });
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  request(method, params) {
+    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(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify(params === void 0 ? { id, method } : { id, method, params }));
+    });
+  }
+  notify(method, params) {
+    if (this.ws.readyState !== this.ws.OPEN) return;
+    this.ws.send(JSON.stringify(params === void 0 ? { method } : { method, params }));
+  }
+  // ws stops reading the socket for good if a 'message' listener throws.
+  guarded(method, fn) {
+    try {
+      fn();
+    } catch (err) {
+      logger.warn(`Codex ${method} handling failed: ${err.message}`);
+    }
+  }
+  onMessage(text) {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!msg || typeof msg !== "object") return;
+    if (msg.method === void 0 && msg.id !== void 0) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      clearTimeout(p.timer);
+      if (msg.error) p.reject(new RpcError(msg.error.code, msg.error.message));
+      else p.resolve(msg.result);
+    } else if (msg.method !== void 0 && msg.id !== void 0) {
+      this.guarded(msg.method, () => this.emit("request", msg.id, msg.method, msg.params));
+    } else if (msg.method !== void 0) {
+      this.guarded(msg.method, () => this.emit("notification", msg.method, msg.params));
+    }
+  }
+};
+
+// src/codex/mapping.ts
+var 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 APPROVAL_REQUESTS = /* @__PURE__ */ new Set([
+  "item/commandExecution/requestApproval",
+  "item/fileChange/requestApproval",
+  "mcpServer/elicitation/request"
+]);
+var CodexAdapter = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.delay = opts.reconnectMinMs ?? 2e3;
+  }
+  conn;
+  rpc;
+  threads = /* @__PURE__ */ new Map();
+  stopped = false;
+  retryTimer;
+  delay;
+  start() {
+    this.stopped = false;
+    void this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = void 0;
+    for (const id of [...this.threads.keys()]) this.drop(id);
+    this.conn?.close();
+  }
+  async connect() {
+    let rpc;
+    try {
+      const conn = await connectProxy(this.opts.command, this.opts.spawnFn);
+      if (this.stopped) {
+        conn.close();
+        return;
+      }
+      const live = new RpcClient(conn.ws);
+      rpc = live;
+      live.on("notification", (method, params) => this.onNotification(method, params));
+      live.on("request", (_id, method, params) => this.onServerRequest(method, params));
+      live.on("close", () => {
+        if (this.rpc === live) this.onDaemonLost();
+      });
+      this.conn = conn;
+      this.rpc = live;
+      const init = await live.request("initialize", {
+        clientInfo: { name: "claude-alarm", version: CHANNEL_SERVER_VERSION }
+      });
+      live.notify("initialized");
+      logger.info(`Connected to Codex daemon (${init.userAgent ?? "unknown version"})`);
+      await this.discover();
+      this.delay = this.opts.reconnectMinMs ?? 2e3;
+    } catch (err) {
+      logger.warn(`Codex daemon connection failed: ${err.message}`);
+      if (rpc && this.rpc === rpc) {
+        this.rpc = void 0;
+        this.conn?.close();
+        this.conn = void 0;
+      }
+      for (const id of [...this.threads.keys()]) this.drop(id);
+      this.scheduleRetry();
+    }
+  }
+  onDaemonLost() {
+    this.rpc = void 0;
+    this.conn?.close();
+    this.conn = void 0;
+    for (const id of [...this.threads.keys()]) this.drop(id);
+    if (!this.stopped) logger.warn("Codex daemon connection lost");
+    this.scheduleRetry();
+  }
+  scheduleRetry() {
+    if (this.stopped || this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      void this.connect();
+    }, this.delay);
+    this.delay = Math.min(this.delay * 2, this.opts.reconnectMaxMs ?? 6e4);
+  }
+  async discover() {
+    const ids = [];
+    let cursor;
+    do {
+      const page = await this.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);
+  }
+  async refresh(threadId) {
+    try {
+      const { thread } = await this.rpc.request("thread/read", { threadId, includeTurns: false });
+      this.upsert(thread);
+    } catch (err) {
+      logger.debug(`thread/read ${threadId} failed: ${err.message}`);
+    }
+  }
+  upsert(thread) {
+    if (!isTrackable(thread)) {
+      this.drop(thread.id);
+      return;
+    }
+    const existing2 = this.threads.get(thread.id);
+    if (existing2) {
+      existing2.thread = thread;
+      existing2.hub.reregister();
+    } else {
+      const { host: host2, port: port2, token: token2 } = this.opts.hub;
+      const hub = new HubClient(
+        codexSessionId(thread.id),
+        threadTitle(thread),
+        host2,
+        port2,
+        token2,
+        () => void 0,
+        () => this.registration(thread.id)
+      );
+      this.threads.set(thread.id, {
+        thread,
+        hub,
+        subscribed: false,
+        wantSubscribed: false,
+        sync: Promise.resolve(),
+        pendingTurn: false,
+        turns: /* @__PURE__ */ new Map(),
+        unrelayed: false
+      });
+      hub.onMessage((msg) => this.onHubMessage(thread.id, msg));
+      hub.connect();
+    }
+    void this.want(thread.id, thread.status.type === "active");
+  }
+  registration(threadId) {
+    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) };
+  }
+  want(threadId, subscribed) {
+    const t = this.threads.get(threadId);
+    if (!t) return Promise.resolve();
+    t.wantSubscribed = subscribed;
+    t.sync = t.sync.then(() => this.syncSubscription(t));
+    return t.sync;
+  }
+  async syncSubscription(t) {
+    const threadId = t.thread.id;
+    if (!this.rpc || this.threads.get(threadId) !== t || t.subscribed === t.wantSubscribed) return;
+    try {
+      if (t.wantSubscribed) {
+        await this.rpc.request("thread/resume", { threadId, excludeTurns: true });
+        t.subscribed = true;
+        t.unrelayed = false;
+      } else {
+        await this.rpc.request("thread/unsubscribe", { threadId });
+        t.subscribed = false;
+      }
+    } catch (err) {
+      logger.debug(`subscription sync for ${threadId} deferred: ${err.message}`);
+    }
+  }
+  releaseLater(t) {
+    clearTimeout(t.releaseTimer);
+    t.releaseTimer = setTimeout(() => {
+      t.releaseTimer = void 0;
+      if (this.threads.get(t.thread.id) === t && t.thread.status.type !== "active" && !t.pendingTurn) {
+        void this.want(t.thread.id, false);
+      }
+    }, this.opts.idleReleaseMs ?? 1e3);
+  }
+  drop(threadId) {
+    const t = this.threads.get(threadId);
+    if (!t) return;
+    this.threads.delete(threadId);
+    clearTimeout(t.releaseTimer);
+    t.releaseTimer = void 0;
+    t.hub.disconnect();
+  }
+  onNotification(method, params) {
+    switch (method) {
+      case "thread/started":
+        this.upsert(params.thread);
+        break;
+      case "thread/status/changed":
+        this.onStatus(params.threadId, params.status);
+        break;
+      case "thread/name/updated": {
+        const t = this.threads.get(params.threadId);
+        if (t) {
+          t.thread.name = params.threadName;
+          t.hub.reregister();
+        }
+        break;
+      }
+      case "thread/closed":
+      case "thread/archived":
+      case "thread/deleted":
+        this.drop(params.threadId);
+        break;
+      case "item/completed":
+        if (params.item?.type === "agentMessage") this.collect(params.threadId, params.turnId, params.item);
+        break;
+      case "turn/completed":
+        this.onTurnCompleted(params.threadId, params.turn);
+        break;
+    }
+  }
+  onStatus(threadId, status) {
+    const t = this.threads.get(threadId);
+    if (!t) {
+      if (status.type !== "notLoaded") void this.refresh(threadId);
+      return;
+    }
+    if (status.type === "notLoaded") {
+      this.drop(threadId);
+      return;
+    }
+    t.thread.status = status;
+    t.pendingTurn = false;
+    t.hub.send({ type: "status", sessionId: codexSessionId(threadId), status: hubStatus(status) });
+    if (status.type === "systemError") this.notify(threadId, "Codex error", "The Codex conversation hit a system error.", "error");
+    if (status.type === "active") {
+      void this.want(threadId, true);
+      return;
+    }
+    if (t.unrelayed) {
+      t.unrelayed = false;
+      this.notify(threadId, "Reply not relayed", "Codex finished, but its reply could not be relayed here. Check the Codex window.", "warning");
+    }
+    this.releaseLater(t);
+  }
+  collect(threadId, turnId, item) {
+    const t = this.threads.get(threadId);
+    if (!t) return;
+    const list = t.turns.get(turnId) ?? [];
+    list.push({ text: item.text, phase: item.phase });
+    t.turns.set(turnId, list);
+  }
+  onTurnCompleted(threadId, turn) {
+    const t = this.threads.get(threadId);
+    if (!t) return;
+    const collected = t.turns.get(turn.id) ?? [];
+    t.turns.delete(turn.id);
+    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");
+      return;
+    }
+    if (turn.status === "interrupted") {
+      this.notify(threadId, "Codex task stopped", "The task was interrupted.", "info");
+      return;
+    }
+    const fromTurn = (turn.items ?? []).filter((i) => i.type === "agentMessage");
+    const text = finalAnswer(collected.length ? collected : fromTurn);
+    if (text) t.hub.send({ type: "reply", sessionId: codexSessionId(threadId), content: text });
+  }
+  onHubMessage(threadId, msg) {
+    if (msg.type === "message_to_session") {
+      void this.sendTurn(threadId, msg.content, msg.source);
+    } else if (msg.type === "image_to_session") {
+      this.notify(threadId, "Not delivered", "Codex sessions do not accept images yet.", "warning");
+    }
+  }
+  async sendTurn(threadId, content, source) {
+    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");
+      return;
+    }
+    t.pendingTurn = true;
+    try {
+      if (!this.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) }] });
+    } catch (err) {
+      t.pendingTurn = false;
+      t.unrelayed = false;
+      this.releaseLater(t);
+      this.notify(threadId, "Not delivered", `Codex rejected the message: ${err.message}`, "warning");
+    }
+  }
+  onServerRequest(method, params) {
+    if (!APPROVAL_REQUESTS.has(method) || !params?.threadId) {
+      logger.debug(`Ignoring Codex server request ${method}`);
+      return;
+    }
+    const detail = params.commandActions?.[0]?.command ?? params.command ?? params.reason ?? params.message ?? method;
+    this.notify(params.threadId, "Codex approval needed", `Approve or decline in Codex: ${String(detail).slice(0, 300)}`, "warning");
+  }
+  notify(threadId, title, message, level) {
+    this.threads.get(threadId)?.hub.send({ type: "notify", sessionId: codexSessionId(threadId), title, message, level });
+  }
+};
+
+// src/codex/main.ts
+function isRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 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);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+if (process.argv.includes("--watch-stdin")) {
+  process.stdin.on("end", shutdown);
+  process.stdin.on("close", shutdown);
+  process.stdin.resume();
+}
+//# sourceMappingURL=main.js.map