@0xmaxma/claude-gateway 1.3.4 → 1.3.6

package/dist/ui/web-ui.js.map

@@ -1 +1 @@
-{"version":3,"file":"web-ui.js","sourceRoot":"","sources":["../../src/ui/web-ui.ts"],"names":[],"mappings":";;AAIA,sDA0NC;AA9ND;;;GAGG;AACH,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwND,CAAC;AACT,CAAC"}
+{"version":3,"file":"web-ui.js","sourceRoot":"","sources":["../../src/ui/web-ui.ts"],"names":[],"mappings":";;AAIA,sDAkxBC;AAtxBD;;;GAGG;AACH,SAAgB,qBAAqB,CAAC,SAAS,GAAG,EAAE;IAClD,MAAM,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC3E,OAAO;;;;;qCAK4B,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0wBtC,CAAC;AACT,CAAC"}

package/mcp/tools/discord/module.ts

@@ -16,9 +16,10 @@ import type {
   McpToolResult,
   ToolVisibility,
   InboundMessageHandler,
+  InboundMessage,
   ChannelId,
 } from '../../types';
-import { sendMessage } from './outbound';
+import { sendMessage, buildChoiceComponents } from './outbound';
 import { loadAccess, saveAccess, gate } from './access';
 import { maybeCreateThread } from './threading';
 import { createMessageHandler } from './inbound';
@@ -260,6 +261,74 @@ export class DiscordModule implements ChannelModule {
       }
     });
 
+    // Interactive-menu button clicks: custom_id `choice:N`. A click is routed
+    // exactly like the user typing "N" (same InboundMessage → handler), so the
+    // session's pending-menu handler injects the selection into the PTY.
+    // Security mirrors the message path: the access gate must return 'deliver'.
+    // discord.js client is typed as `any` (dynamic import) so we narrow locally.
+    interface ButtonInteraction {
+      isButton?: () => boolean;
+      customId?: string;
+      guildId?: string | null;
+      channelId: string;
+      channel?: { isThread?: () => boolean };
+      user: { id: string; username: string };
+      message?: { id: string };
+      client: { user?: { id: string } };
+      reply(opts: { content: string; ephemeral: boolean }): Promise<unknown>;
+      update(opts: { components: unknown[] }): Promise<unknown>;
+    }
+    this.client.on('interactionCreate', async (interaction: ButtonInteraction) => {
+      try {
+        if (!interaction.isButton?.()) return;
+        const m = /^choice:(\d+)$/.exec(interaction.customId ?? '');
+        if (!m) return;
+
+        const isDM = !interaction.guildId;
+        const isThread = interaction.channel?.isThread?.() ?? false;
+        const context: DiscordMessageContext = {
+          guildId: interaction.guildId ?? null,
+          channelId: interaction.channelId,
+          threadId: isThread ? interaction.channelId : null,
+          userId: interaction.user.id,
+          username: interaction.user.username,
+          messageId: interaction.message?.id ?? '',
+          isDM,
+          isThread,
+        };
+        const access = loadAccessFn();
+        const result = gate(access, context, saveAccessFn, () => randomBytes(3).toString('hex'));
+        if (result.action !== 'deliver') {
+          await interaction.reply({ content: 'Not authorized.', ephemeral: true }).catch(() => {});
+          return;
+        }
+
+        // Disable the buttons (acknowledges the click + prevents double-selection).
+        await interaction.update({ components: [] }).catch(() => {});
+
+        const channelId = interaction.channelId;
+        const typingFileDir = path.join(this.stateDir, 'typing');
+        try {
+          fs.mkdirSync(typingFileDir, { recursive: true });
+          fs.writeFileSync(path.join(typingFileDir, channelId), '');
+        } catch {}
+
+        const inbound: InboundMessage = {
+          channel: 'discord',
+          accountId: interaction.client.user?.id ?? 'discord',
+          senderId: interaction.user.id,
+          chatId: channelId,
+          chatType: isDM ? 'direct' : 'group',
+          text: m[1],
+          messageId: interaction.message?.id ?? '',
+          ts: Date.now(),
+        };
+        await handler(inbound);
+      } catch (err) {
+        process.stderr.write(`discord: interaction handler error: ${err}\n`);
+      }
+    });
+
     const approvedDir = path.join(this.stateDir, 'approved');
     const approvedInterval = setInterval(() => { void this.checkApprovals(approvedDir); }, 5000);
     approvedInterval.unref();
@@ -288,6 +357,24 @@ export class DiscordModule implements ChannelModule {
     try { files = fs.readdirSync(typingDir); } catch { return; }
 
     for (const file of files) {
+      // Interactive menu: render the question with Secondary buttons. Each click
+      // routes back as a normal "N" message (see the interactionCreate handler).
+      if (file.endsWith('.menu')) {
+        const filePath = path.join(typingDir, file);
+        const channelId = file.slice(0, -'.menu'.length);
+        try {
+          const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8').trim()) as {
+            text: string;
+            options: Array<{ label: string }>;
+          };
+          fs.rmSync(filePath, { force: true });
+          if (parsed.text && Array.isArray(parsed.options) && parsed.options.length) {
+            const channel = await this.client.channels.fetch(channelId);
+            await sendMessage(channel, parsed.text, { components: buildChoiceComponents(parsed.options) });
+          }
+        } catch { /* non-fatal — result text carries the numbered list as fallback */ }
+        continue;
+      }
       if (!file.endsWith('.forward')) continue;
       const filePath = path.join(typingDir, file);
       const channelId = file.slice(0, -'.forward'.length);

package/mcp/tools/discord/outbound.ts

@@ -17,10 +17,23 @@ export async function sendMessage(
     replyTo?: string;
     files?: string[];
     useEmbed?: boolean;
+    components?: unknown[];
   } = {},
 ): Promise<SentMessage[]> {
   const sent: SentMessage[] = [];
 
+  // Interactive menu: send the text with button rows attached to the first message.
+  if (options.components && options.components.length) {
+    const chunks = chunkText(text, MAX_MESSAGE_LENGTH);
+    for (let i = 0; i < chunks.length; i++) {
+      const last = i === chunks.length - 1;
+      const sendOpts: Parameters<SendableChannel['send']>[0] = { content: chunks[i] };
+      if (last) sendOpts.components = options.components;
+      sent.push(await channel.send(sendOpts));
+    }
+    return sent;
+  }
+
   if (text.length > MAX_MESSAGE_LENGTH && options.useEmbed) {
     const embedText = text.slice(0, MAX_EMBED_DESCRIPTION);
     const embed: EmbedData = { description: embedText };
@@ -55,6 +68,29 @@ export async function sendMessage(
   return sent;
 }
 
+/**
+ * Build Discord action-row components for an interactive menu. Each option
+ * becomes a Secondary button labelled "N. label" whose custom_id is `choice:N`
+ * (≤5 buttons per row, ≤5 rows). Uses raw component JSON to keep this module
+ * free of a discord.js import (matching the rest of the file).
+ */
+export function buildChoiceComponents(options: Array<{ label: string }>): unknown[] {
+  const rows: unknown[] = [];
+  for (let i = 0; i < options.length && rows.length < 5; i += 5) {
+    const buttons = options.slice(i, i + 5).map((o, j) => {
+      const n = i + j + 1;
+      return {
+        type: 2, // Button
+        style: 2, // Secondary
+        label: `${n}. ${o.label}`.slice(0, 80),
+        custom_id: `choice:${n}`,
+      };
+    });
+    rows.push({ type: 1, components: buttons }); // ActionRow
+  }
+  return rows;
+}
+
 export function chunkText(text: string, limit: number): string[] {
   if (text.length <= limit) return [text];
   const chunks: string[] = [];

package/mcp/tools/discord/types.ts

@@ -65,6 +65,8 @@ export type SendOptions = {
   embeds?: EmbedData[];
   files?: FileAttachment[];
   reply?: { messageReference: string };
+  /** Raw Discord message components (action rows of buttons), passed through to channel.send. */
+  components?: unknown[];
 };
 
 export type SentMessage = { id: string };

package/mcp/tools/telegram/menu-parser.ts

@@ -0,0 +1,37 @@
+/**
+ * Pure parsing logic for .menu files written by AgentRunner.writeMenuForward.
+ * Kept in a separate module so tests can import it without pulling in the full
+ * bot runtime (receiver-server.ts imports grammy + all its dependencies).
+ */
+
+export type InlineKeyboardButton = { text: string; callback_data: string };
+
+export type MenuMessage = {
+  text: string;
+  inline_keyboard: Array<Array<InlineKeyboardButton>>;
+};
+
+/**
+ * Parse raw .menu file content into a Telegram sendMessage payload.
+ * Returns null if the content is malformed or missing required fields.
+ */
+export function parseMenuFileContent(raw: string): MenuMessage | null {
+  let parsed: { text?: unknown; options?: unknown };
+  try {
+    parsed = JSON.parse(raw) as { text?: unknown; options?: unknown };
+  } catch {
+    return null;
+  }
+  const text = typeof parsed.text === 'string' ? parsed.text : '';
+  const options = Array.isArray(parsed.options)
+    ? (parsed.options as Array<{ label?: unknown }>)
+        .map(o => (typeof o?.label === 'string' ? o.label : ''))
+        .filter((l): l is string => l.length > 0)
+    : [];
+  if (!text || options.length === 0) return null;
+  const inline_keyboard = options.map((label, i) => [{
+    text: `${i + 1}. ${label}`.slice(0, 60),
+    callback_data: `choice:${i + 1}`,
+  }]);
+  return { text, inline_keyboard };
+}

package/mcp/tools/telegram/receiver-server.ts

@@ -690,6 +690,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async req => {
 const SEND_ONLY = process.env.TELEGRAM_SEND_ONLY === 'true'
 const RECEIVER_MODE = process.env.TELEGRAM_RECEIVER_MODE === 'true'
 
+import { parseMenuFileContent } from './menu-parser'
+
 const BOT_COMMANDS = [
   { command: 'session', description: 'Show current session info' },
   { command: 'sessions', description: 'Manage conversation sessions' },
@@ -1157,6 +1159,45 @@ bot.command('clear', async ctx => {
 bot.on('callback_query:data', async ctx => {
   const data = ctx.callbackQuery.data
 
+  // Handle interactive-menu choice: choice:<N>. A tap is routed back exactly like
+  // the user typing "N" — same content + meta as the text path — so the session's
+  // pending-menu handler injects the selection into the PTY. Security mirrors the
+  // text path: the tapper must be in allowFrom.
+  const choiceMatch = /^choice:(\d+)$/.exec(data)
+  if (choiceMatch) {
+    const access = loadAccess()
+    if (!access.allowFrom.includes(String(ctx.from.id))) {
+      await ctx.answerCallbackQuery({ text: 'Not authorized.' }).catch(() => {})
+      return
+    }
+    const chat_id = String(ctx.callbackQuery.message?.chat.id ?? ctx.from.id)
+    const choice = choiceMatch[1]
+    // Remove the keyboard immediately to prevent double-selection.
+    await ctx.editMessageReplyMarkup({ reply_markup: undefined }).catch(() => {})
+    await ctx.answerCallbackQuery({ text: `✓ ${choice}` }).catch(() => {})
+    const callbackUrl = process.env.CLAUDE_CHANNEL_CALLBACK
+    if (callbackUrl) {
+      const channelParams = {
+        content: choice,
+        meta: {
+          chat_id,
+          user: ctx.from.username ?? String(ctx.from.id),
+          user_id: String(ctx.from.id),
+          ts: new Date().toISOString(),
+        },
+      }
+      fetch(callbackUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(channelParams),
+      }).catch(err => {
+        process.stderr.write(`telegram channel: choice callback POST failed: ${err}\n`)
+      })
+      if (RECEIVER_MODE) typingManager.start(chat_id)
+    }
+    return
+  }
+
   // Handle model selection callback: model:<model_id>
   const modelMatch = /^model:(.+)$/.exec(data)
   if (modelMatch) {
@@ -1633,6 +1674,48 @@ if (RECEIVER_MODE) {
   process.on('SIGTERM', shutdown)
   process.on('SIGINT', shutdown)
 
+  // Interactive-menu delivery. The AgentRunner drops a `<chatId>.menu` file in
+  // TYPING_DIR whenever the PTY session blocks on an interactive select menu
+  // (AskUserQuestion / plan approval). We render it as inline buttons here.
+  //
+  // This MUST be independent of the typing-indicator lifecycle: a menu can be
+  // emitted after typing has already been torn down (e.g. the agent called the
+  // reply tool earlier in the same turn, or the turn ended), and the old
+  // stop()-coupled drain would early-return on a missing typing state, leaving
+  // the .menu file orphaned and the user staring at a silent chat. A standalone
+  // poller — mirroring the Discord side — guarantees every menu reaches the chat.
+  function drainMenuFiles(): void {
+    let files: string[]
+    try {
+      files = readdirSync(TYPING_DIR)
+    } catch {
+      return
+    }
+    for (const name of files) {
+      if (!name.endsWith('.menu')) continue
+      const chatId = name.slice(0, -'.menu'.length)
+      const menuPath = join(TYPING_DIR, name)
+      let raw: string
+      try {
+        raw = readFileSync(menuPath, 'utf8').trim()
+      } catch {
+        // Malformed or mid-write (the runner writes atomically, so this is rare) —
+        // drop it so the poller doesn't spin on the same bad file forever.
+        rmSync(menuPath, { force: true })
+        continue
+      }
+      // Remove BEFORE sending: a slow or failing send must not let the next tick
+      // re-deliver the same menu (which would stack duplicate button messages).
+      rmSync(menuPath, { force: true })
+      const msg = parseMenuFileContent(raw)
+      if (!msg) continue
+      void bot.api.sendMessage(chatId, msg.text, { reply_markup: { inline_keyboard: msg.inline_keyboard } }).catch(err => {
+        process.stderr.write(`telegram channel (receiver): failed to send menu to ${chatId}: ${err}\n`)
+      })
+    }
+  }
+  setInterval(drainMenuFiles, 1000).unref()
+
   void (async () => {
     for (let attempt = 1; ; attempt++) {
       try {

package/mcp/tools/telegram/typing.ts

@@ -96,7 +96,7 @@ export interface WorkingState {
 
 export interface BotApi {
   sendChatAction(chatId: string, action: 'typing'): Promise<unknown>
-  sendMessage(chatId: string, text: string, opts?: { parse_mode?: 'MarkdownV2' | 'HTML' | 'Markdown' }): Promise<{ message_id: number }>
+  sendMessage(chatId: string, text: string, opts?: { parse_mode?: 'MarkdownV2' | 'HTML' | 'Markdown'; reply_markup?: unknown }): Promise<{ message_id: number }>
   editMessageText(chatId: string, msgId: number, text: string): Promise<unknown>
   deleteMessage(chatId: string, msgId: number): Promise<unknown>
   setMessageReaction(chatId: string, msgId: number, emoji: string): Promise<unknown>
@@ -212,6 +212,12 @@ export function createWorkingStateManager(
       } catch {}
       fsApi.rmSync(forwardPath, { force: true })
     }
+    // NOTE: interactive-menu (.menu) delivery is handled by an independent poller
+    // in receiver-server.ts (drainMenuFiles), NOT here. A menu can be emitted
+    // after the typing state has already been torn down (reply tool called earlier
+    // in the turn, or the turn ended), in which case this stop() never runs for it
+    // and the .menu file would be orphaned. The standalone poller has no such
+    // coupling, so it reliably delivers every menu. Do not re-add a drain here.
     fsApi.rmSync(repliedPath, { force: true })
     // Read signal file timestamp before deleting — process.ts overwrites it with a newer
     // timestamp when a queued turn is injected; if newer than this turn's startedAt it means

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -47,10 +47,12 @@
     "lru-cache": "^10.0.0",
     "node-cron": "^3.0.0",
     "node-pty": "^1.1.0",
-    "p-queue": "^6.6.2"
+    "p-queue": "^6.6.2",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.0",
+    "@types/ws": "^8.18.1",
     "@types/jest": "^29.0.0",
     "@types/js-yaml": "^4.0.0",
     "@types/node": "^22.19.18",