@delt/claude-alarm 1.0.1 → 1.1.1

package/README.md

@@ -185,11 +185,13 @@ claude-alarm hub start
 
 - Requires the Codex CLI with its app-server daemon (`codex app-server daemon version` shows `running`). Set `"codex": { "command": "C:/path/to/codex.exe" }` in `~/.claude-alarm/config.json` if `codex` is not on `PATH`.
 - If the hub console keeps printing `Codex daemon connection failed: spawn codex ENOENT`, the hub's terminal cannot find `codex`. A terminal opened before Codex was installed still has the old `PATH`, so open a new terminal or set `codex.command`.
-- Every loaded Codex conversation appears as a session with a **Codex** badge. Replies, failures and approval waits are relayed to the dashboard and Telegram.
+- Every loaded Codex conversation appears as a session with a **Codex** badge. Replies, failures and approval requests are relayed to the dashboard and Telegram.
 - Messages you send reach the conversation only while Codex is idle, and show up in Codex prefixed with `[claude-alarm · Dashboard]` or `[claude-alarm · Telegram]`.
-- Approvals still have to be answered in Codex; claude-alarm only tells you one is waiting.
+- Approvals for commands, file changes and MCP tools can be answered from the dashboard or Telegram with the choices Codex offers (for example **Allow once**, **Always allow this command**, **Cancel task**). Whoever answers first wins, in Codex or here; the other buttons close as **Resolved**, which does not say what was chosen. Buttons from before a hub or adapter restart show **Expired**; if Codex is still waiting, a new request appears.
+- After updating claude-alarm, reload open dashboard tabs so they pick up the new approval buttons.
+- Questions Codex asks you (not approvals) still have to be answered in Codex; claude-alarm tells you one is waiting.
 - A conversation is followed only while Codex is working on it, so a closed Codex window drops off the dashboard about a minute later. If a reply could not be picked up, you get a **Reply not relayed** warning; read it in the Codex window.
-- If Codex runs on another PC, run `claude-alarm codex start` there with that PC's config pointing at your hub.
+- If Codex runs on another PC, run `claude-alarm codex start` there with that PC's config pointing at your hub. Keep claude-alarm at the same version on both PCs; an older hub cannot show Codex's choices.
 
 ## Permission Relay
 
@@ -293,7 +295,7 @@ In the dashboard input, type `@<session name>` to have the selected session send
 
 - Node.js >= 18
 - Claude Code with MCP Channels support
-- Optional, for Codex sessions: OpenAI Codex CLI with the app-server daemon (tested with 0.159.3)
+- Optional, for Codex sessions: OpenAI Codex CLI with the app-server daemon (tested with 0.159.3; approvals also with app-server 0.160.0)
 
 ## License
 

package/dist/cli.js

@@ -412,18 +412,31 @@ var init_session_label = __esm({
   }
 });
 
+// src/shared/permission-key.ts
+function permissionKey(sessionId2, requestId) {
+  return `${sessionId2}
+${requestId}`;
+}
+var init_permission_key = __esm({
+  "src/shared/permission-key.ts"() {
+    "use strict";
+  }
+});
+
 // src/hub/telegram.ts
 import fs4 from "fs";
 import path4 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-var TELEGRAM_API, TelegramBot;
+var TELEGRAM_API, MAX_CHOICE_MESSAGES, TelegramBot;
 var init_telegram = __esm({
   "src/hub/telegram.ts"() {
     "use strict";
     init_logger();
     init_constants();
     init_session_label();
+    init_permission_key();
     TELEGRAM_API = "https://api.telegram.org/bot";
+    MAX_CHOICE_MESSAGES = 200;
     TelegramBot = class _TelegramBot {
       config;
       offset = 0;
@@ -437,6 +450,11 @@ var init_telegram = __esm({
       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
@@ -725,6 +743,71 @@ ${previewHtml}${truncNote}`;
         };
         await this.sendMessage(text, void 0, replyMarkup);
       }
+      async sendChoiceRequest(sessionId2, 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(sessionId2, requestId), entry);
+        const rows = choices.map((c) => {
+          const token = randomUUID2().replace(/-/g, "").slice(0, 16);
+          this.choiceTokens.set(token, { sessionId: sessionId2, 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(sessionId2, requestId, state) {
+        this.dropChoiceTokens(sessionId2, requestId);
+        const key = permissionKey(sessionId2, 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(sessionId2, requestId) {
+        for (const [token, c] of this.choiceTokens) {
+          if (c.sessionId === sessionId2 && 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 [sessionId2, requestId] = oldest.split("\n");
+          this.dropChoiceTokens(sessionId2, requestId);
+        }
+      }
       async handleCallbackQuery(query) {
         if (!query.data) return;
         if (String(query.message?.chat.id) !== String(this.config.chatId)) return;
@@ -732,6 +815,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;
@@ -1017,6 +1104,11 @@ import path6 from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 import { randomUUID as randomUUID3 } from "crypto";
+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 __dirname, MAX_WS_PAYLOAD, HubServer;
 var init_server = __esm({
   "src/hub/server.ts"() {
@@ -1030,6 +1122,7 @@ var init_server = __esm({
     init_config();
     init_session_label();
     init_crash_guard();
+    init_permission_key();
     init_auth();
     __dirname = path6.dirname(fileURLToPath(import.meta.url));
     MAX_WS_PAYLOAD = 16 * 1024 * 1024;
@@ -1051,6 +1144,8 @@ var init_server = __esm({
       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;
@@ -1188,6 +1283,7 @@ var init_server = __esm({
           this.channelSockets.delete(sessionId2);
           this.localChannels.delete(sessionId2);
           this.channelAlive.delete(sessionId2);
+          this.expireChoices(sessionId2);
           if (session) {
             this.broadcastToDashboards({ type: "session_disconnected", sessionId: sessionId2 });
             this.jsonResponse(res, 200, { ok: true });
@@ -1331,6 +1427,7 @@ var init_server = __esm({
               this.channelSockets.delete(sessionId2);
               this.localChannels.delete(sessionId2);
               this.channelAlive.delete(sessionId2);
+              this.expireChoices(sessionId2);
               logger.info(`Channel disconnected: ${sessionId2}`);
               this.broadcastToDashboards({
                 type: "session_disconnected",
@@ -1418,7 +1515,22 @@ var init_server = __esm({
           }
           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,
@@ -1426,15 +1538,23 @@ var init_server = __esm({
               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 ---
@@ -1450,6 +1570,11 @@ var init_server = __esm({
           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());
@@ -1461,10 +1586,9 @@ var init_server = __esm({
             } 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 === WebSocket2.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 {
@@ -1477,6 +1601,32 @@ var init_server = __esm({
         });
       }
       // --- 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 !== WebSocket2.OPEN) return false;
+        channelWs.send(JSON.stringify(out));
+        return true;
+      }
+      resolveChoice(sessionId2, requestId, state) {
+        if (!this.choiceRequests.delete(permissionKey(sessionId2, requestId))) return;
+        this.broadcastToDashboards({ type: "permission_resolved", sessionId: sessionId2, requestId, state });
+        void this.telegramBot?.resolveChoiceRequest(sessionId2, requestId, state);
+      }
+      expireChoices(sessionId2) {
+        for (const pending of [...this.choiceRequests.values()]) {
+          if (pending.request.sessionId === sessionId2) this.resolveChoice(sessionId2, pending.request.requestId, "expired");
+        }
+      }
       broadcastToDashboards(msg) {
         const payload = JSON.stringify(msg);
         for (const ws of this.dashboardSockets) {
@@ -1560,14 +1710,16 @@ var init_server = __esm({
           }
         };
         this.telegramBot.onPermissionVerdict = (sessionId2, requestId, behavior) => {
-          const channelWs = this.channelSockets.get(sessionId2);
-          if (channelWs?.readyState === WebSocket2.OPEN) {
-            const msg = { type: "permission_response", sessionId: sessionId2, requestId, behavior };
-            channelWs.send(JSON.stringify(msg));
+          if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, behavior })) {
             logger.info(`Telegram permission verdict [${requestId}]: ${behavior} -> session ${sessionId2}`);
           }
           this.broadcastToDashboards({ type: "permission_response", sessionId: sessionId2, requestId, behavior });
         };
+        this.telegramBot.onChoiceVerdict = (sessionId2, requestId, choiceId) => {
+          if (this.forwardPermissionResponse({ sessionId: sessionId2, requestId, choiceId })) {
+            logger.info(`Telegram choice [${requestId}]: ${choiceId} -> session ${sessionId2}`);
+          }
+        };
         this.notifier.configure({ telegramBot: this.telegramBot });
         this.telegramBot.startPolling();
         logger.info("Telegram bot initialized");