@delt/claude-alarm 1.1.1 → 1.2.0

package/dist/index.d.ts

@@ -29,6 +29,7 @@ interface SessionInfo {
     peerName?: string;
     agentKind?: AgentKind;
     title?: string;
+    closable?: boolean;
 }
 /** Messages sent between channel server and hub */
 type ChannelMessage = {
@@ -71,6 +72,7 @@ type ChannelMessage = {
     mimeType: string;
     originalName?: string;
     content?: string;
+    source?: MessageSource;
 } | {
     type: 'sessions_list';
     sessions: SessionInfo[];
@@ -118,10 +120,51 @@ type ChannelMessage = {
 } | {
     type: 'permission_pending';
     requests: PendingChoiceRequest[];
+} | {
+    type: 'codex_adapters';
+    adapters: CodexAdapterInfo[];
+} | {
+    type: 'codex_close';
+    sessionId: string;
 } | {
     type: 'error';
     message: string;
 };
+interface CodexAdapterInfo {
+    id: string;
+    host: string;
+    ready: boolean;
+    isLocal: boolean;
+}
+type CodexCall = {
+    kind: 'folders';
+} | {
+    kind: 'create';
+    cwd: string;
+};
+/** Messages on the per-adapter socket between the Codex adapter and the hub */
+type CodexLinkMessage = {
+    type: 'adapter_hello';
+    adapter: {
+        id: string;
+        host: string;
+        ready: boolean;
+    };
+} | {
+    type: 'adapter_call';
+    requestId: string;
+    call: CodexCall;
+} | {
+    type: 'adapter_result';
+    requestId: string;
+    ok: true;
+    data: unknown;
+} | {
+    type: 'adapter_result';
+    requestId: string;
+    ok: false;
+    error: string;
+};
 type NotifyLevel = 'info' | 'warning' | 'error' | 'success';
 /** Webhook configuration */
 interface WebhookConfig {
@@ -184,7 +227,14 @@ declare class HubServer {
     private token?;
     private codexEnabled;
     private codexSupervisor?;
-    constructor(config?: Partial<AppConfig>);
+    private wssCodex;
+    private codexAdapters;
+    private codexAlive;
+    private codexCallTimeoutMs;
+    private codexCalls;
+    constructor(config?: Partial<AppConfig>, options?: {
+        codexCallTimeoutMs?: number;
+    });
     start(): Promise<void>;
     stop(): Promise<void>;
     private handleHttp;
@@ -194,6 +244,13 @@ declare class HubServer {
     private handleApiNotify;
     private handleChannelConnection;
     private handleChannelMessage;
+    private handleCodexConnection;
+    private callCodexAdapter;
+    private handleCodexFolders;
+    private handleCodexCreate;
+    private handleCodexClose;
+    private codexAdapterList;
+    private broadcastCodexAdapters;
     private handleDashboardConnection;
     private forwardPermissionResponse;
     private resolveChoice;
@@ -355,7 +412,8 @@ declare const CODEX_PID_FILE: string;
 declare const CODEX_LOG_FILE: string;
 declare const WS_PATH_CHANNEL = "/ws/channel";
 declare const WS_PATH_DASHBOARD = "/ws/dashboard";
+declare const WS_PATH_CODEX = "/ws/codex";
 declare const CHANNEL_SERVER_NAME = "claude-alarm";
 declare const CHANNEL_SERVER_VERSION = "0.1.0";
 
-export { type AgentKind, type AppConfig, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION, CODEX_LOG_FILE, CODEX_PID_FILE, CONFIG_DIR, CONFIG_FILE, type ChannelMessage, type CodexConfig, DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, HubClient, HubServer, type HubStatus, LOG_FILE, type MessageSource, Notifier, type NotifyLevel, PID_FILE, type PendingChoiceRequest, type PermissionChoice, type SessionInfo, SessionManager, type SessionStatus, type TelegramConfig, UPLOADS_DIR, WS_PATH_CHANNEL, WS_PATH_DASHBOARD, type WebhookConfig, loadConfig, logger, saveConfig, setupMcpConfig };
+export { type AgentKind, type AppConfig, CHANNEL_SERVER_NAME, CHANNEL_SERVER_VERSION, CODEX_LOG_FILE, CODEX_PID_FILE, CONFIG_DIR, CONFIG_FILE, type ChannelMessage, type CodexAdapterInfo, type CodexCall, type CodexConfig, type CodexLinkMessage, DEFAULT_HUB_HOST, DEFAULT_HUB_PORT, HubClient, HubServer, type HubStatus, LOG_FILE, type MessageSource, Notifier, type NotifyLevel, PID_FILE, type PendingChoiceRequest, type PermissionChoice, type SessionInfo, SessionManager, type SessionStatus, type TelegramConfig, UPLOADS_DIR, WS_PATH_CHANNEL, WS_PATH_CODEX, WS_PATH_DASHBOARD, type WebhookConfig, loadConfig, logger, saveConfig, setupMcpConfig };

package/dist/index.js

@@ -40,6 +40,7 @@ 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_DASHBOARD = "/ws/dashboard";
+var WS_PATH_CODEX = "/ws/codex";
 var CHANNEL_SERVER_NAME = "claude-alarm";
 var CHANNEL_SERVER_VERSION = "0.1.0";
 
@@ -175,6 +176,7 @@ var Notifier = class {
       execFile(
         "powershell",
         ["-Command", '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\PushNotifications" -Name ToastEnabled -ErrorAction SilentlyContinue).ToastEnabled'],
+        { windowsHide: true },
         (err, stdout) => {
           if (err) {
             resolve(true);
@@ -192,7 +194,7 @@ var Notifier = class {
     logger.warn("Windows notifications are disabled. Opening notification settings...");
     logger.warn("Please enable notifications for this app, then try again.");
     if (process.platform === "win32") {
-      execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"]);
+      execFile("powershell", ["-Command", "Start-Process ms-settings:notifications"], { windowsHide: true });
     }
     setTimeout(() => {
       this.notificationSettingsOpened = false;
@@ -944,6 +946,21 @@ function logStartup(context) {
 `);
 }
 
+// src/shared/entry.ts
+function isEntryScript(argv1, suffixes) {
+  if (!argv1) return false;
+  const normalized = argv1.replace(/\\/g, "/");
+  return suffixes.some((suffix) => normalized.endsWith(suffix));
+}
+
+// src/shared/hub-url.ts
+import net from "net";
+function hubUrlHost(host) {
+  if (host === "" || host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return net.isIPv6(host) ? `[${host}]` : host;
+}
+
 // src/hub/auth.ts
 import crypto from "crypto";
 var SESSION_COOKIE = "ca_session";
@@ -1009,6 +1026,7 @@ function validChoices(choices) {
   const valid = choices.filter((c) => typeof c?.id === "string" && typeof c?.label === "string");
   return valid.length ? valid : void 0;
 }
+var nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
 var HubServer = class {
   httpServer;
   wssChannel;
@@ -1034,7 +1052,13 @@ var HubServer = class {
   token;
   codexEnabled;
   codexSupervisor;
-  constructor(config) {
+  wssCodex;
+  codexAdapters = /* @__PURE__ */ new Map();
+  codexAlive = /* @__PURE__ */ new WeakMap();
+  codexCallTimeoutMs;
+  codexCalls = /* @__PURE__ */ new Map();
+  constructor(config, options = {}) {
+    this.codexCallTimeoutMs = options.codexCallTimeoutMs ?? 6e4;
     this.host = config?.hub?.host ?? DEFAULT_HUB_HOST;
     this.port = config?.hub?.port ?? DEFAULT_HUB_PORT;
     this.token = config?.hub?.token;
@@ -1047,7 +1071,7 @@ var HubServer = class {
     if (config?.webhooks) {
       this.notifier.configure({ webhooks: config.webhooks });
     }
-    const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+    const displayHost = hubUrlHost(this.host);
     this.notifier.configure({ dashboardUrl: `http://${displayHost}:${this.port}` });
     const fullConfig = loadConfig();
     if (fullConfig.telegram?.enabled && fullConfig.telegram.botToken && fullConfig.telegram.chatId) {
@@ -1060,6 +1084,9 @@ var HubServer = class {
     this.wssDashboard = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
     this.wssDashboard.on("connection", (ws) => this.handleDashboardConnection(ws));
     this.wssDashboard.on("error", (err) => logger.warn(`Dashboard WebSocket server error: ${err.message}`));
+    this.wssCodex = new WebSocketServer({ noServer: true, maxPayload: MAX_WS_PAYLOAD });
+    this.wssCodex.on("connection", (ws, req) => this.handleCodexConnection(ws, req));
+    this.wssCodex.on("error", (err) => logger.warn(`Codex WebSocket server error: ${err.message}`));
     this.httpServer.on("upgrade", (req, socket, head) => {
       socket.on("error", (err) => logger.debug(`Upgrade socket error: ${err.message}`));
       const url = new URL(req.url ?? "/", "http://hub");
@@ -1080,6 +1107,10 @@ var HubServer = class {
         this.wssDashboard.handleUpgrade(req, socket, head, (ws) => {
           this.wssDashboard.emit("connection", ws, req);
         });
+      } else if (pathname === WS_PATH_CODEX) {
+        this.wssCodex.handleUpgrade(req, socket, head, (ws) => {
+          this.wssCodex.emit("connection", ws, req);
+        });
       } else {
         socket.destroy();
       }
@@ -1094,7 +1125,7 @@ var HubServer = class {
       this.httpServer.listen(this.port, this.host, () => {
         this.httpServer.removeListener("error", onStartupError);
         this.httpServer.on("error", (err) => logger.error(`HTTP server error: ${err.message}`));
-        const displayHost = this.host === "0.0.0.0" ? "127.0.0.1" : this.host;
+        const displayHost = hubUrlHost(this.host);
         logger.info(`Hub server listening on http://${displayHost}:${this.port}`);
         this.startCodexAdapter();
         resolve();
@@ -1109,10 +1140,12 @@ var HubServer = class {
       if (this.telegramBot) this.telegramBot.stopPolling();
       for (const ws of this.channelSockets.values()) ws.terminate();
       for (const ws of this.dashboardSockets) ws.terminate();
+      for (const { ws } of this.codexAdapters.values()) ws.terminate();
       this.channelSockets.clear();
       this.dashboardSockets.clear();
       this.wssChannel.close();
       this.wssDashboard.close();
+      this.wssCodex.close();
       this.httpServer.close(() => {
         logger.info("Hub server stopped");
         resolve();
@@ -1177,6 +1210,12 @@ var HubServer = class {
       this.handleApiSend(req, res);
     } else if (url.pathname === "/api/notify" && req.method === "POST") {
       this.handleApiNotify(req, res);
+    } else if (url.pathname === "/api/codex/folders" && req.method === "GET") {
+      this.handleCodexFolders(url, res);
+    } else if (url.pathname === "/api/codex/threads" && req.method === "POST") {
+      this.handleCodexCreate(req, res);
+    } else if (url.pathname === "/api/codex/threads/close" && req.method === "POST") {
+      this.handleCodexClose(req, res);
     } else if (url.pathname === "/api/webhooks" && req.method === "GET") {
       const config = loadConfig();
       this.jsonResponse(res, 200, { webhooks: config.webhooks || [] });
@@ -1440,6 +1479,114 @@ var HubServer = class {
       }
     }
   }
+  handleCodexConnection(ws, req) {
+    const isLocal = this.isLocalRequest(req);
+    let adapterId;
+    ws.on("error", (err) => {
+      logger.warn(`Codex adapter WebSocket error: ${err.message}`);
+      ws.terminate();
+    });
+    ws.on("pong", () => this.codexAlive.set(ws, true));
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+        if (msg === null || typeof msg !== "object") {
+          logger.warn("Invalid message from Codex adapter");
+          return;
+        }
+      } catch {
+        logger.warn("Invalid message from Codex adapter");
+        return;
+      }
+      if (msg.type === "adapter_hello") {
+        const a = msg.adapter;
+        if (typeof a?.id !== "string" || !a.id || typeof a.host !== "string") return;
+        if (adapterId && adapterId !== a.id) return;
+        const holder = this.codexAdapters.get(a.id);
+        if (holder && holder.ws !== ws) holder.ws.terminate();
+        if (!adapterId) logger.info(`Codex adapter connected: ${a.host} (${a.id}, local: ${isLocal})`);
+        adapterId = a.id;
+        this.codexAdapters.set(a.id, { ws, info: { id: a.id, host: a.host, ready: a.ready === true, isLocal } });
+        this.broadcastCodexAdapters();
+      } else if (msg.type === "adapter_result" && adapterId) {
+        const call = this.codexCalls.get(msg.requestId);
+        if (!call || call.adapterId !== adapterId) return;
+        call.settle(msg.ok ? { status: 200, body: msg.data } : { status: 422, body: { error: String(msg.error) } });
+      }
+    });
+    ws.on("close", () => {
+      if (!adapterId || this.codexAdapters.get(adapterId)?.ws !== ws) return;
+      this.codexAdapters.delete(adapterId);
+      for (const call of [...this.codexCalls.values()]) {
+        if (call.adapterId === adapterId) call.settle({ status: 502, body: { error: "Codex adapter disconnected" } });
+      }
+      logger.info(`Codex adapter disconnected: ${adapterId}`);
+      this.broadcastCodexAdapters();
+    });
+  }
+  callCodexAdapter(adapterId, call) {
+    const adapter = this.codexAdapters.get(adapterId);
+    if (!adapter || adapter.ws.readyState !== WebSocket.OPEN) {
+      return Promise.resolve({ status: 404, body: { error: "Codex adapter is not connected" } });
+    }
+    const requestId = randomUUID3();
+    return new Promise((resolve) => {
+      const timer = setTimeout(
+        () => settle({ status: 504, body: { error: "Codex did not respond in time. The conversation may still appear." } }),
+        this.codexCallTimeoutMs
+      );
+      const settle = (outcome) => {
+        clearTimeout(timer);
+        this.codexCalls.delete(requestId);
+        resolve(outcome);
+      };
+      this.codexCalls.set(requestId, { adapterId, settle });
+      adapter.ws.send(JSON.stringify({ type: "adapter_call", requestId, call }));
+    });
+  }
+  async handleCodexFolders(url, res) {
+    const adapterId = url.searchParams.get("adapterId");
+    if (!nonEmpty(adapterId)) {
+      this.jsonResponse(res, 400, { error: "adapterId is required" });
+      return;
+    }
+    const out = await this.callCodexAdapter(adapterId, { kind: "folders" });
+    this.jsonResponse(res, out.status, out.body);
+  }
+  async handleCodexCreate(req, res) {
+    const body = await this.readBody(req);
+    const adapterId = body?.adapterId;
+    const cwd = body?.cwd;
+    if (!nonEmpty(adapterId) || !nonEmpty(cwd)) {
+      this.jsonResponse(res, 400, { error: "adapterId and cwd are required" });
+      return;
+    }
+    const out = await this.callCodexAdapter(adapterId, { kind: "create", cwd });
+    this.jsonResponse(res, out.status, out.body);
+  }
+  async handleCodexClose(req, res) {
+    const body = await this.readBody(req);
+    const sessionId = body?.sessionId;
+    if (!nonEmpty(sessionId)) {
+      this.jsonResponse(res, 400, { error: "sessionId is required" });
+      return;
+    }
+    const session = this.sessions.get(sessionId);
+    const ws = this.channelSockets.get(sessionId);
+    if (session?.agentKind !== "codex" || !session.closable || ws?.readyState !== WebSocket.OPEN) {
+      this.jsonResponse(res, 404, { error: "No closable Codex conversation" });
+      return;
+    }
+    ws.send(JSON.stringify({ type: "codex_close", sessionId }));
+    this.jsonResponse(res, 200, { ok: true });
+  }
+  codexAdapterList() {
+    return [...this.codexAdapters.values()].map((a) => a.info);
+  }
+  broadcastCodexAdapters() {
+    this.broadcastToDashboards({ type: "codex_adapters", adapters: this.codexAdapterList() });
+  }
   // --- Dashboard WebSocket ---
   handleDashboardConnection(ws) {
     this.dashboardSockets.add(ws);
@@ -1458,6 +1605,7 @@ var HubServer = class {
       requests: [...this.choiceRequests.values()].map((c) => c.request)
     };
     ws.send(JSON.stringify(pendingMsg));
+    ws.send(JSON.stringify({ type: "codex_adapters", adapters: this.codexAdapterList() }));
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
@@ -1545,7 +1693,8 @@ var HubServer = class {
       imagePath: filePath,
       mimeType,
       originalName,
-      content
+      content,
+      source: "dashboard"
     };
     channelWs.send(JSON.stringify(forwardMsg));
     logger.info(`Image saved and forwarded: ${filename} (${buffer.length} bytes)`);
@@ -1554,7 +1703,7 @@ var HubServer = class {
         fs5.unlinkSync(filePath);
       } catch {
       }
-    }, 5 * 60 * 1e3);
+    }, 5 * 60 * 1e3).unref();
   }
   async handleWebhookSave(req, res) {
     const body = await this.readBody(req);
@@ -1587,7 +1736,7 @@ var HubServer = class {
     this.telegramBot.onImageToSession = (sessionId, imagePath, mimeType, caption) => {
       const channelWs = this.channelSockets.get(sessionId);
       if (channelWs?.readyState === WebSocket.OPEN) {
-        const msg = { type: "image_to_session", sessionId, imagePath, mimeType, content: caption };
+        const msg = { type: "image_to_session", sessionId, imagePath, mimeType, content: caption, source: "telegram" };
         channelWs.send(JSON.stringify(msg));
         logger.info(`Telegram photo forwarded to session: ${sessionId}`);
       }
@@ -1730,6 +1879,14 @@ var HubServer = class {
         this.channelAlive.set(sessionId, false);
         ws.ping();
       }
+      for (const { ws } of this.codexAdapters.values()) {
+        if (this.codexAlive.get(ws) === false) {
+          ws.terminate();
+          continue;
+        }
+        this.codexAlive.set(ws, false);
+        ws.ping();
+      }
     }, 3e4);
   }
   cleanupUploads() {
@@ -1792,7 +1949,7 @@ Content-Length: 0\r
     });
   }
 };
-if (process.argv[1] && (process.argv[1].endsWith("hub/server.js") || process.argv[1].endsWith("hub/server.ts"))) {
+if (isEntryScript(process.argv[1], ["/hub/server.js", "/hub/server.ts"])) {
   installCrashGuard("hub daemon");
   logStartup("Hub daemon");
   const config = loadConfig();
@@ -1942,6 +2099,7 @@ export {
   SessionManager,
   UPLOADS_DIR,
   WS_PATH_CHANNEL,
+  WS_PATH_CODEX,
   WS_PATH_DASHBOARD,
   loadConfig,
   logger,