@0xmaxma/claude-gateway 1.4.8 → 1.5.0

package/mcp/tools/discord/module.ts

@@ -33,6 +33,18 @@ import type { DiscordMessageContext } from './types';
 
 const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024;
 
+/** AgentRunner callback base (origin of CLAUDE_CHANNEL_CALLBACK, "" when unset).
+ *  Used to mint/approve `/cli` pairings via the runner, the same bridge the
+ *  Telegram receiver uses for /models. */
+function cliCallbackBase(): string {
+  try {
+    const u = new URL(process.env.CLAUDE_CHANNEL_CALLBACK ?? '');
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return '';
+  }
+}
+
 export class DiscordModule implements ChannelModule {
   id = 'discord' as ChannelId;
   toolVisibility: ToolVisibility = 'current-channel';
@@ -281,6 +293,45 @@ export class DiscordModule implements ChannelModule {
       }
 
       // action === 'deliver'
+      // `/cli` opens the live terminal viewer: mint a pairing (link + Approve
+      // button) instead of forwarding the text to the agent. Only reached after
+      // gate() authorized this user, so it inherits the channel's access control.
+      const cliText = (msg.content ?? '').replace(/<@!?\d+>/g, '').trim().toLowerCase();
+      if (cliText === '/cli') {
+        const base = cliCallbackBase();
+        try {
+          const res = await fetch(base + '/command', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ command: 'cli_pair', payload: { channel: 'discord', user_id: context.userId } }),
+          });
+          const data = (await res.json()) as { success?: boolean; url?: string; code?: string; pairingId?: string; error?: string };
+          if (!data.success || !data.url || !data.pairingId) {
+            await msg.channel.send(
+              data.error === 'not_configured'
+                ? 'Terminal viewer is not configured. Set gateway.publicUrl in config.json first.'
+                : 'Could not open the terminal viewer right now.',
+            ).catch(() => {});
+            return;
+          }
+          const components = [{
+            type: 1,
+            components: [
+              { type: 2, style: 5, label: '\u{1F5A5} Open terminal', url: data.url },
+              { type: 2, style: 2, label: `Approve ${data.code}`, custom_id: `cli:approve:${data.pairingId}` },
+              { type: 2, style: 4, label: 'Deny', custom_id: `cli:deny:${data.pairingId}` },
+            ],
+          }];
+          await msg.channel.send({
+            content: 'Live terminal viewer — open the link, confirm the code matches, then tap **Approve** to unlock (read-only by default).',
+            components,
+          }).catch(() => {});
+        } catch {
+          await msg.channel.send('Could not open the terminal viewer right now.').catch(() => {});
+        }
+        return;
+      }
+
       // Start typing indicator before handing off to runner
       const channelId = context.channelId;
       const typingFileDir = path.join(this.stateDir, 'typing');
@@ -347,12 +398,59 @@ export class DiscordModule implements ChannelModule {
       message?: { id: string };
       client: { user?: { id: string } };
       reply(opts: { content: string; ephemeral: boolean }): Promise<unknown>;
-      update(opts: { components: unknown[] }): Promise<unknown>;
+      update(opts: { components: unknown[]; content?: string }): Promise<unknown>;
     }
     this.client.on('interactionCreate', async (interaction: ButtonInteraction) => {
       try {
         if (!interaction.isButton?.()) return;
 
+        // `/cli` approve/deny — unlock (or reject) a pending terminal-viewer
+        // pairing. Re-runs the access gate on the tapping user, then relays the
+        // decision to the runner. The pairing itself checks the user id matches.
+        const cliM = /^cli:(approve|deny):([0-9a-f]{36})$/.exec(interaction.customId ?? '');
+        if (cliM) {
+          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,
+            mentionsBot: true,
+          };
+          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;
+          }
+          const deny = cliM[1] === 'deny';
+          const base = cliCallbackBase();
+          let ok = false;
+          try {
+            const res = await fetch(base + '/command', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                command: 'cli_approve',
+                payload: { channel: 'discord', pairing_id: cliM[2], user_id: interaction.user.id, deny },
+              }),
+            });
+            ok = !!((await res.json()) as { success?: boolean }).success;
+          } catch {}
+          const content = deny
+            ? '\u{1F6AB} Denied.'
+            : ok
+              ? '✅ Approved — return to the browser.'
+              : '⚠️ Could not approve (the link may have expired). Send /cli again.';
+          await interaction.update({ components: [], content }).catch(() => {});
+          return;
+        }
+
         // Cancel button: send ESC sentinel to dismiss the pending menu cleanly.
         if ((interaction.customId ?? '') === 'menu:cancel') {
           const isDM = !interaction.guildId;

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

@@ -881,6 +881,7 @@ const BOT_COMMANDS = [
   { command: 'restart', description: 'Graceful restart session' },
   { command: 'model', description: 'Show current AI model' },
   { command: 'models', description: 'Switch AI model' },
+  { command: 'cli', description: 'Open the live terminal viewer' },
   { command: 'start', description: 'Welcome and setup guide' },
   { command: 'status', description: 'Check your pairing status' },
   { command: 'help', description: 'What this bot can do' },
@@ -1146,7 +1147,8 @@ bot.command('help', async ctx => {
     `/restart — graceful restart session\n\n` +
     `*Agent*\n` +
     `/model — show current AI model\n` +
-    `/models — switch AI model\n\n` +
+    `/models — switch AI model\n` +
+    `/cli — open the live terminal viewer\n\n` +
     `*Account*\n` +
     `/start — pairing instructions\n` +
     `/status — check your pairing state`,
@@ -1238,6 +1240,44 @@ bot.command('models', async ctx => {
   }
 })
 
+// /cli — open the live terminal viewer as a Telegram Mini App. The Mini App
+// page reads Telegram's signed initData and the gateway verifies it (HMAC with
+// this bot's token), so nothing secret rides in the URL. Private chat + allowlist
+// only, matching every other command.
+bot.command('cli', async ctx => {
+  if (ctx.chat?.type !== 'private') return
+  const access = loadAccess()
+  if (!access.allowFrom.includes(String(ctx.from!.id))) return
+  if (!CALLBACK_URL_BASE) return
+
+  try {
+    const res = await fetch(CALLBACK_URL_BASE + '/command', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        command: 'cli_pair',
+        payload: { channel: 'telegram', user_id: String(ctx.from!.id) },
+      }),
+    })
+    const data = (await res.json()) as { success?: boolean; url?: string; error?: string }
+    if (!data.success || !data.url) {
+      if (data.error === 'not_configured') {
+        await ctx.reply('Terminal viewer is not configured. Set gateway.publicUrl in config.json first.')
+      } else {
+        await ctx.reply('Could not open the terminal viewer right now.')
+      }
+      return
+    }
+    // web_app button launches the Mini App; Telegram requires an HTTPS URL.
+    const keyboard = new InlineKeyboard().webApp('\u{1F5A5} Open terminal', data.url)
+    await ctx.reply('Live terminal viewer (read-only by default — toggle input inside):', {
+      reply_markup: keyboard,
+    })
+  } catch {
+    await ctx.reply('Could not open the terminal viewer right now.')
+  }
+})
+
 // /compact — show compact confirmation keyboard (receiver mode only)
 bot.command('compact', async ctx => {
   if (ctx.chat?.type !== 'private') return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "1.4.8",
+  "version": "1.5.0",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",