@delt/claude-alarm 1.0.1 → 1.1.1

package/dist/index.d.ts

@@ -2,6 +2,19 @@
 type SessionStatus = 'idle' | 'working' | 'waiting_input';
 type AgentKind = 'claude' | 'codex';
 type MessageSource = 'dashboard' | 'telegram' | 'api';
+interface PermissionChoice {
+    id: string;
+    label: string;
+}
+interface PendingChoiceRequest {
+    sessionId: string;
+    requestId: string;
+    toolName: string;
+    description: string;
+    inputPreview: string;
+    timestamp: number;
+    choices: PermissionChoice[];
+}
 /** Session info tracked by the hub */
 interface SessionInfo {
     id: string;
@@ -90,11 +103,21 @@ type ChannelMessage = {
     description: string;
     inputPreview: string;
     timestamp: number;
+    choices?: PermissionChoice[];
 } | {
     type: 'permission_response';
     sessionId: string;
     requestId: string;
-    behavior: 'allow' | 'deny';
+    behavior?: 'allow' | 'deny';
+    choiceId?: string;
+} | {
+    type: 'permission_resolved';
+    sessionId: string;
+    requestId: string;
+    state: 'resolved' | 'expired';
+} | {
+    type: 'permission_pending';
+    requests: PendingChoiceRequest[];
 } | {
     type: 'error';
     message: string;
@@ -155,6 +178,7 @@ declare class HubServer {
     private heartbeatInterval?;
     private channelAlive;
     private socketOwners;
+    private choiceRequests;
     private host;
     private port;
     private token?;
@@ -171,6 +195,9 @@ declare class HubServer {
     private handleChannelConnection;
     private handleChannelMessage;
     private handleDashboardConnection;
+    private forwardPermissionResponse;
+    private resolveChoice;
+    private expireChoices;
     private broadcastToDashboards;
     private handleImageUpload;
     private handleWebhookSave;
@@ -235,6 +262,9 @@ declare class TelegramBot {
     onMessageToSession?: (sessionId: string, content: string) => void;
     onImageToSession?: (sessionId: string, imagePath: string, mimeType: string, caption?: string) => void;
     onPermissionVerdict?: (sessionId: string, requestId: string, behavior: 'allow' | 'deny') => void;
+    onChoiceVerdict?: (sessionId: string, requestId: string, choiceId: string) => void;
+    private choiceTokens;
+    private choiceMessages;
     getSessions?: () => SessionInfo[];
     private pendingMessages;
     constructor(config: TelegramConfig);
@@ -257,6 +287,11 @@ declare class TelegramBot {
     private getLabel;
     /** Send a permission request with inline buttons */
     sendPermissionRequest(sessionId: string, sessionLabel: string, requestId: string, toolName: string, description: string, inputPreview: string): Promise<void>;
+    sendChoiceRequest(sessionId: string, sessionLabel: string, requestId: string, toolName: string, description: string, inputPreview: string, choices: PermissionChoice[]): Promise<void>;
+    resolveChoiceRequest(sessionId: string, requestId: string, state: 'resolved' | 'expired'): Promise<void>;
+    private handleChoiceCallback;
+    private dropChoiceTokens;
+    private trimChoiceMessages;
     private handleCallbackQuery;
     private handleSessionSelectCallback;
     private answerCallbackQuery;
@@ -323,4 +358,4 @@ declare const WS_PATH_DASHBOARD = "/ws/dashboard";
 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 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 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 };

package/dist/index.js

@@ -234,8 +234,15 @@ function sessionLabel(session) {
   return session.agentKind === "codex" ? `Codex \xB7 ${base}` : base;
 }
 
+// src/shared/permission-key.ts
+function permissionKey(sessionId, requestId) {
+  return `${sessionId}
+${requestId}`;
+}
+
 // src/hub/telegram.ts
 var TELEGRAM_API = "https://api.telegram.org/bot";
+var MAX_CHOICE_MESSAGES = 200;
 var TelegramBot = class _TelegramBot {
   config;
   offset = 0;
@@ -249,6 +256,11 @@ var TelegramBot = class _TelegramBot {
   onImageToSession;
   // Callback: when a permission verdict arrives from Telegram
   onPermissionVerdict;
+  // Callback: when a Codex approval choice arrives from Telegram
+  onChoiceVerdict;
+  // Telegram caps callback_data at 64 bytes, so buttons carry a short token instead of the ids.
+  choiceTokens = /* @__PURE__ */ new Map();
+  choiceMessages = /* @__PURE__ */ new Map();
   // Callback: get current sessions list
   getSessions;
   // Pending messages for session selection
@@ -537,6 +549,71 @@ ${previewHtml}${truncNote}`;
     };
     await this.sendMessage(text, void 0, replyMarkup);
   }
+  async sendChoiceRequest(sessionId, sessionLabel2, requestId, toolName, description, inputPreview, choices) {
+    let preview = inputPreview;
+    try {
+      const p = JSON.parse(inputPreview);
+      if (typeof p.command === "string") preview = `$ ${p.command}`;
+      else if (typeof p.content === "string") preview = p.content;
+    } catch {
+    }
+    const slice = preview.slice(0, 3e3);
+    const html = `\u26A0\uFE0F <b>Permission Request</b> \u2014 ${this.escHtml(sessionLabel2)}
+
+\u{1F527} <b>${this.escHtml(toolName)}</b>` + (description ? `
+${this.escHtml(description)}` : "") + (slice ? `
+<pre>${this.escHtml(slice)}</pre>` : "") + (preview.length > slice.length ? "\n<i>...truncated</i>" : "");
+    const entry = { html };
+    this.choiceMessages.set(permissionKey(sessionId, requestId), entry);
+    const rows = choices.map((c) => {
+      const token = randomUUID().replace(/-/g, "").slice(0, 16);
+      this.choiceTokens.set(token, { sessionId, requestId, choiceId: c.id, label: c.label });
+      return [{ text: c.label, callback_data: `pc:${token}` }];
+    });
+    this.trimChoiceMessages();
+    const sent = await this.sendMessage(html, void 0, { inline_keyboard: rows });
+    if (!sent) return;
+    entry.messageId = sent.message_id;
+    if (entry.outcome) await this.editMessageText(this.config.chatId, sent.message_id, html + entry.outcome);
+  }
+  async resolveChoiceRequest(sessionId, requestId, state) {
+    this.dropChoiceTokens(sessionId, requestId);
+    const key = permissionKey(sessionId, requestId);
+    const entry = this.choiceMessages.get(key);
+    if (!entry) return;
+    this.choiceMessages.delete(key);
+    entry.outcome = state === "resolved" ? "\n\n\u2705 <b>Resolved</b>" : "\n\n\u231B <b>Expired</b>";
+    if (entry.messageId !== void 0) await this.editMessageText(this.config.chatId, entry.messageId, entry.html + entry.outcome);
+  }
+  async handleChoiceCallback(query) {
+    const choice = this.choiceTokens.get(query.data.slice("pc:".length));
+    if (!choice) {
+      await this.answerCallbackQuery(query.id, "Expired");
+      return;
+    }
+    this.dropChoiceTokens(choice.sessionId, choice.requestId);
+    this.onChoiceVerdict?.(choice.sessionId, choice.requestId, choice.choiceId);
+    await this.answerCallbackQuery(query.id, `Sent: ${choice.label}`);
+    const entry = this.choiceMessages.get(permissionKey(choice.sessionId, choice.requestId));
+    if (entry?.messageId !== void 0 && !entry.outcome) {
+      await this.editMessageText(this.config.chatId, entry.messageId, `${entry.html}
+
+\u23F3 <b>Sent: ${this.escHtml(choice.label)}</b>`);
+    }
+  }
+  dropChoiceTokens(sessionId, requestId) {
+    for (const [token, c] of this.choiceTokens) {
+      if (c.sessionId === sessionId && c.requestId === requestId) this.choiceTokens.delete(token);
+    }
+  }
+  trimChoiceMessages() {
+    while (this.choiceMessages.size > MAX_CHOICE_MESSAGES) {
+      const oldest = this.choiceMessages.keys().next().value;
+      this.choiceMessages.delete(oldest);
+      const [sessionId, requestId] = oldest.split("\n");
+      this.dropChoiceTokens(sessionId, requestId);
+    }
+  }
   async handleCallbackQuery(query) {
     if (!query.data) return;
     if (String(query.message?.chat.id) !== String(this.config.chatId)) return;
@@ -544,6 +621,10 @@ ${previewHtml}${truncNote}`;
       await this.handleSessionSelectCallback(query);
       return;
     }
+    if (query.data.startsWith("pc:")) {
+      await this.handleChoiceCallback(query);
+      return;
+    }
     if (!query.data.startsWith("perm:")) return;
     const parts = query.data.split(":");
     if (parts.length < 4) return;
@@ -923,6 +1004,11 @@ function isSecureRequest(req) {
 // src/hub/server.ts
 var __dirname = path5.dirname(fileURLToPath(import.meta.url));
 var MAX_WS_PAYLOAD = 16 * 1024 * 1024;
+function validChoices(choices) {
+  if (!Array.isArray(choices)) return void 0;
+  const valid = choices.filter((c) => typeof c?.id === "string" && typeof c?.label === "string");
+  return valid.length ? valid : void 0;
+}
 var HubServer = class {
   httpServer;
   wssChannel;
@@ -941,6 +1027,8 @@ var HubServer = class {
   channelAlive = /* @__PURE__ */ new Map();
   // sessionId -> alive flag
   socketOwners = /* @__PURE__ */ new WeakMap();
+  // Codex approvals carry their own choices; a response is forwarded only in the mode of the request it answers.
+  choiceRequests = /* @__PURE__ */ new Map();
   host;
   port;
   token;
@@ -1078,6 +1166,7 @@ var HubServer = class {
       this.channelSockets.delete(sessionId);
       this.localChannels.delete(sessionId);
       this.channelAlive.delete(sessionId);
+      this.expireChoices(sessionId);
       if (session) {
         this.broadcastToDashboards({ type: "session_disconnected", sessionId });
         this.jsonResponse(res, 200, { ok: true });
@@ -1221,6 +1310,7 @@ var HubServer = class {
           this.channelSockets.delete(sessionId);
           this.localChannels.delete(sessionId);
           this.channelAlive.delete(sessionId);
+          this.expireChoices(sessionId);
           logger.info(`Channel disconnected: ${sessionId}`);
           this.broadcastToDashboards({
             type: "session_disconnected",
@@ -1308,7 +1398,22 @@ var HubServer = class {
       }
       case "permission_request": {
         this.sessions.updateActivity(msg.sessionId);
+        const choices = validChoices(msg.choices);
         logger.info(`Permission request [${msg.requestId}] from ${msg.sessionId}: ${msg.toolName}`);
+        if (choices) {
+          this.choiceRequests.set(permissionKey(msg.sessionId, msg.requestId), {
+            request: {
+              sessionId: msg.sessionId,
+              requestId: msg.requestId,
+              toolName: msg.toolName,
+              description: msg.description,
+              inputPreview: msg.inputPreview,
+              timestamp: msg.timestamp,
+              choices
+            },
+            choiceIds: new Set(choices.map((c) => c.id))
+          });
+        }
         this.broadcastToDashboards({
           type: "permission_request",
           sessionId: msg.sessionId,
@@ -1316,15 +1421,23 @@ var HubServer = class {
           toolName: msg.toolName,
           description: msg.description,
           inputPreview: msg.inputPreview,
-          timestamp: msg.timestamp
+          timestamp: msg.timestamp,
+          ...choices ? { choices } : {}
         });
         if (this.telegramBot) {
-          const session = this.sessions.get(msg.sessionId);
-          const label = this.getSessionLabel(session);
-          this.telegramBot.sendPermissionRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview);
+          const label = this.getSessionLabel(this.sessions.get(msg.sessionId));
+          if (choices) {
+            void this.telegramBot.sendChoiceRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview, choices);
+          } else {
+            this.telegramBot.sendPermissionRequest(msg.sessionId, label, msg.requestId, msg.toolName, msg.description, msg.inputPreview);
+          }
         }
         break;
       }
+      case "permission_resolved": {
+        this.resolveChoice(msg.sessionId, msg.requestId, msg.state === "expired" ? "expired" : "resolved");
+        break;
+      }
     }
   }
   // --- Dashboard WebSocket ---
@@ -1340,6 +1453,11 @@ var HubServer = class {
       sessions: this.sessions.getAll()
     };
     ws.send(JSON.stringify(sessionsMsg));
+    const pendingMsg = {
+      type: "permission_pending",
+      requests: [...this.choiceRequests.values()].map((c) => c.request)
+    };
+    ws.send(JSON.stringify(pendingMsg));
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
@@ -1351,10 +1469,9 @@ var HubServer = class {
         } else if (msg.type === "image_upload") {
           this.handleImageUpload(msg);
         } else if (msg.type === "permission_response") {
-          const channelWs = this.channelSockets.get(msg.sessionId);
-          if (channelWs?.readyState === WebSocket.OPEN) {
-            channelWs.send(JSON.stringify(msg));
-            logger.info(`Permission verdict [${msg.requestId}]: ${msg.behavior} -> session ${msg.sessionId}`);
+          if (this.forwardPermissionResponse(msg)) {
+            const verdict = msg.choiceId !== void 0 ? `choice ${msg.choiceId}` : msg.behavior;
+            logger.info(`Permission verdict [${msg.requestId}]: ${verdict} -> session ${msg.sessionId}`);
           }
         }
       } catch {
@@ -1367,6 +1484,32 @@ var HubServer = class {
     });
   }
   // --- Helpers ---
+  forwardPermissionResponse(msg) {
+    const pending = this.choiceRequests.get(permissionKey(msg.sessionId, msg.requestId));
+    let out;
+    if (pending) {
+      if (typeof msg.choiceId !== "string" || !pending.choiceIds.has(msg.choiceId)) return false;
+      out = { type: "permission_response", sessionId: msg.sessionId, requestId: msg.requestId, choiceId: msg.choiceId };
+    } else {
+      if (msg.behavior !== "allow" && msg.behavior !== "deny" || msg.choiceId !== void 0) return false;
+      if (this.sessions.get(msg.sessionId)?.agentKind === "codex") return false;
+      out = { type: "permission_response", sessionId: msg.sessionId, requestId: msg.requestId, behavior: msg.behavior };
+    }
+    const channelWs = this.channelSockets.get(msg.sessionId);
+    if (channelWs?.readyState !== WebSocket.OPEN) return false;
+    channelWs.send(JSON.stringify(out));
+    return true;
+  }
+  resolveChoice(sessionId, requestId, state) {
+    if (!this.choiceRequests.delete(permissionKey(sessionId, requestId))) return;
+    this.broadcastToDashboards({ type: "permission_resolved", sessionId, requestId, state });
+    void this.telegramBot?.resolveChoiceRequest(sessionId, requestId, state);
+  }
+  expireChoices(sessionId) {
+    for (const pending of [...this.choiceRequests.values()]) {
+      if (pending.request.sessionId === sessionId) this.resolveChoice(sessionId, pending.request.requestId, "expired");
+    }
+  }
   broadcastToDashboards(msg) {
     const payload = JSON.stringify(msg);
     for (const ws of this.dashboardSockets) {
@@ -1450,14 +1593,16 @@ var HubServer = class {
       }
     };
     this.telegramBot.onPermissionVerdict = (sessionId, requestId, behavior) => {
-      const channelWs = this.channelSockets.get(sessionId);
-      if (channelWs?.readyState === WebSocket.OPEN) {
-        const msg = { type: "permission_response", sessionId, requestId, behavior };
-        channelWs.send(JSON.stringify(msg));
+      if (this.forwardPermissionResponse({ sessionId, requestId, behavior })) {
         logger.info(`Telegram permission verdict [${requestId}]: ${behavior} -> session ${sessionId}`);
       }
       this.broadcastToDashboards({ type: "permission_response", sessionId, requestId, behavior });
     };
+    this.telegramBot.onChoiceVerdict = (sessionId, requestId, choiceId) => {
+      if (this.forwardPermissionResponse({ sessionId, requestId, choiceId })) {
+        logger.info(`Telegram choice [${requestId}]: ${choiceId} -> session ${sessionId}`);
+      }
+    };
     this.notifier.configure({ telegramBot: this.telegramBot });
     this.telegramBot.startPolling();
     logger.info("Telegram bot initialized");