@0xmaxma/claude-gateway 1.0.0

package/mcp/tools/discord/module.ts

@@ -0,0 +1,442 @@
+/**
+ * Discord channel module — implements ChannelModule interface.
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as https from 'https';
+import * as http from 'http';
+import { randomBytes } from 'crypto';
+import type {
+  ChannelModule,
+  ChannelCapabilities,
+  ChannelAccountSnapshot,
+  McpToolDefinition,
+  McpToolResult,
+  ToolVisibility,
+  InboundMessageHandler,
+  ChannelId,
+} from '../../types';
+import { sendMessage } from './outbound';
+import { loadAccess, saveAccess, gate } from './access';
+import { maybeCreateThread } from './threading';
+import { createMessageHandler } from './inbound';
+import type { DiscordMessageContext } from './types';
+
+const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024;
+
+export class DiscordModule implements ChannelModule {
+  id = 'discord' as ChannelId;
+  toolVisibility: ToolVisibility = 'current-channel';
+  skillsDir = path.join(__dirname, 'skills');
+
+  capabilities: ChannelCapabilities = {
+    typingIndicator: false,
+    reactions: true,
+    editMessage: true,
+    fileAttachment: true,
+    threadReply: true,
+    maxMessageLength: 2000,
+    markupFormat: 'markdown',
+  };
+
+  private client: any = null;
+  private stateDir: string;
+  private inboxDir: string;
+  private running = false;
+  private lastMessageAt?: number;
+  private lastError?: string;
+
+  constructor() {
+    this.stateDir = process.env.DISCORD_STATE_DIR
+      ?? path.join(os.homedir(), '.claude', 'channels', 'discord');
+    this.inboxDir = path.join(this.stateDir, 'inbox');
+  }
+
+  isEnabled(): boolean {
+    return Boolean(this.getToken());
+  }
+
+  private getToken(): string | undefined {
+    if (process.env.DISCORD_BOT_TOKEN) return process.env.DISCORD_BOT_TOKEN;
+    const envFile = path.join(this.stateDir, '.env');
+    try {
+      for (const line of fs.readFileSync(envFile, 'utf8').split('\n')) {
+        const m = line.match(/^DISCORD_BOT_TOKEN=(.*)$/);
+        if (m) return m[1];
+      }
+    } catch {}
+    return undefined;
+  }
+
+  getTools(): McpToolDefinition[] {
+    return [
+      {
+        name: 'discord_reply',
+        description:
+          'Send a message to a Discord channel, thread, or DM. Pass channel_id from the inbound message. Optionally pass reply_to (message_id) and files (absolute paths).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string' },
+            text: { type: 'string' },
+            reply_to: { type: 'string', description: 'Message ID to reply to.' },
+            files: { type: 'array', items: { type: 'string' }, description: 'Absolute file paths to attach.' },
+            embed: { type: 'boolean', description: 'Use embed for long responses.' },
+          },
+          required: ['channel_id', 'text'],
+        },
+      },
+      {
+        name: 'discord_react',
+        description: 'Add an emoji reaction to a Discord message.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string' },
+            message_id: { type: 'string' },
+            emoji: { type: 'string' },
+          },
+          required: ['channel_id', 'message_id', 'emoji'],
+        },
+      },
+      {
+        name: 'discord_edit_message',
+        description: "Edit a message the bot previously sent.",
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string' },
+            message_id: { type: 'string' },
+            text: { type: 'string' },
+          },
+          required: ['channel_id', 'message_id', 'text'],
+        },
+      },
+      {
+        name: 'discord_download_attachment',
+        description: 'Download a file from a Discord CDN URL to the local inbox.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'CDN URL from attachmentFileId.' },
+            filename: { type: 'string', description: 'Optional filename override.' },
+          },
+          required: ['url'],
+        },
+      },
+      {
+        name: 'discord_create_thread',
+        description: 'Create a public thread in a Discord channel.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            channel_id: { type: 'string' },
+            name: { type: 'string', description: 'Thread name (max 100 chars).' },
+            message_id: { type: 'string', description: 'Source message to start the thread from.' },
+          },
+          required: ['channel_id', 'name'],
+        },
+      },
+    ];
+  }
+
+  async handleTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
+    if (!this.client) {
+      return { content: [{ type: 'text', text: 'Discord client not initialized' }], isError: true };
+    }
+    try {
+      switch (name) {
+        case 'discord_reply':    return await this.handleReply(args);
+        case 'discord_react':    return await this.handleReact(args);
+        case 'discord_edit_message': return await this.handleEditMessage(args);
+        case 'discord_download_attachment': return await this.handleDownloadAttachment(args);
+        case 'discord_create_thread': return await this.handleCreateThread(args);
+        default:
+          return { content: [{ type: 'text', text: `unknown tool: ${name}` }], isError: true };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: 'text', text: `${name} failed: ${msg}` }], isError: true };
+    }
+  }
+
+  async initBot(): Promise<void> {
+    const token = this.getToken();
+    if (!token) throw new Error('DISCORD_BOT_TOKEN not configured');
+    const { createDiscordClient } = await import('./client');
+    this.client = await createDiscordClient(token);
+    this.running = true;
+  }
+
+  async start(handler: InboundMessageHandler, signal: AbortSignal): Promise<void> {
+    if (!this.client) {
+      await this.initBot();
+    }
+
+    const autoThread = process.env.DISCORD_AUTO_THREAD === 'true';
+    const autoArchive = parseInt(process.env.DISCORD_AUTO_THREAD_ARCHIVE ?? '60', 10);
+    const useEmbeds = process.env.DISCORD_USE_EMBEDS === 'true';
+    const agentId = process.env.GATEWAY_AGENT_ID ?? 'discord';
+
+    const stateDir = this.stateDir;
+    const loadAccessFn = () => loadAccess(stateDir);
+    const saveAccessFn = (a: ReturnType<typeof loadAccess>) => saveAccess(stateDir, a);
+
+    // Permissive config — gate() already handled access, inbound.ts skips re-check
+    const permissiveConfig = {
+      botToken: this.getToken()!,
+      dmPolicy: 'open' as const,
+      dmAllowlist: [] as string[],
+      guildAllowlist: [] as string[],
+      channelAllowlist: [] as string[],
+      autoThread,
+      autoThreadArchiveMinutes: autoArchive as 60 | 1440 | 4320 | 10080,
+      maxMessageLength: 2000,
+      useEmbeds,
+    };
+
+    const permissiveAccessConfig = {
+      dmPolicy: 'open' as const,
+      dmAllowlist: [] as string[],
+      guildAllowlist: [] as string[],
+      channelAllowlist: [] as string[],
+      roleAllowlist: [] as string[],
+    };
+
+    const msgHandler = createMessageHandler(agentId, handler, permissiveConfig, permissiveAccessConfig);
+
+    this.client.on('messageCreate', async (msg: any) => {
+      if (msg.author?.bot) return;
+      if (msg.system) return;
+
+      this.lastMessageAt = Date.now();
+
+      const isDM = !msg.guild;
+      const isThread = msg.channel?.isThread?.() ?? false;
+
+      const context: DiscordMessageContext = {
+        guildId: msg.guildId ?? null,
+        channelId: msg.channelId,
+        threadId: isThread ? msg.channelId : null,
+        userId: msg.author.id,
+        username: msg.author.username,
+        messageId: msg.id,
+        isDM,
+        isThread,
+      };
+
+      const access = loadAccessFn();
+      const result = gate(access, context, saveAccessFn, () => randomBytes(3).toString('hex'));
+
+      if (result.action === 'drop') return;
+
+      if (result.action === 'pair') {
+        try {
+          await msg.channel.send(
+            `Pairing required — run in Claude Code:\n\n/discord:access pair ${result.code}`,
+          );
+        } catch {}
+        return;
+      }
+
+      // action === 'deliver'
+      // Start typing indicator before handing off to runner
+      const channelId = context.channelId;
+      const typingFileDir = path.join(this.stateDir, 'typing');
+      try {
+        fs.mkdirSync(typingFileDir, { recursive: true });
+        fs.writeFileSync(path.join(typingFileDir, channelId), '');
+        await fetch(`https://discord.com/api/v10/channels/${channelId}/typing`, {
+          method: 'POST',
+          headers: { Authorization: `Bot ${this.getToken()!}`, 'Content-Length': '0' },
+        });
+      } catch {}
+
+      await msgHandler(msg);
+      if (autoThread) {
+        await maybeCreateThread(msg, autoThread, autoArchive).catch(() => {});
+      }
+    });
+
+    const approvedDir = path.join(this.stateDir, 'approved');
+    const approvedInterval = setInterval(() => { void this.checkApprovals(approvedDir); }, 5000);
+    approvedInterval.unref();
+
+    const typingDir = path.join(this.stateDir, 'typing');
+    const forwardInterval = setInterval(() => { void this.processForwardFiles(typingDir); }, 1000);
+    forwardInterval.unref();
+
+    // Send typing indicator every 8s for all active channels (Discord typing lasts ~10s)
+    const typingInterval = setInterval(() => { void this.processTypingSignals(typingDir, this.getToken()!); }, 8000);
+    typingInterval.unref();
+
+    signal.addEventListener('abort', () => {
+      this.running = false;
+      clearInterval(approvedInterval);
+      clearInterval(forwardInterval);
+      clearInterval(typingInterval);
+      this.client?.destroy?.();
+    });
+
+    await new Promise<void>(resolve => signal.addEventListener('abort', () => resolve()));
+  }
+
+  private async processForwardFiles(typingDir: string): Promise<void> {
+    let files: string[];
+    try { files = fs.readdirSync(typingDir); } catch { return; }
+
+    for (const file of files) {
+      if (!file.endsWith('.forward')) continue;
+      const filePath = path.join(typingDir, file);
+      const channelId = file.slice(0, -'.forward'.length);
+      let text: string;
+      let parseMode: undefined | 'html';
+      try {
+        const raw = fs.readFileSync(filePath, 'utf8').trim();
+        try {
+          const parsed = JSON.parse(raw) as { text: string; format: string };
+          text = parsed.text;
+          parseMode = parsed.format === 'html' ? 'html' : undefined;
+        } catch {
+          text = raw;
+        }
+        fs.rmSync(filePath, { force: true });
+      } catch { continue; }
+
+      if (!text) continue;
+      try {
+        const channel = await this.client.channels.fetch(channelId);
+        if (parseMode === 'html') {
+          // Discord doesn't support HTML — strip tags and send plain text
+          text = text.replace(/<[^>]*>/g, '');
+        }
+        await sendMessage(channel, text, {});
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  private async processTypingSignals(typingDir: string, token: string): Promise<void> {
+    let files: string[];
+    try { files = fs.readdirSync(typingDir); } catch { return; }
+
+    for (const file of files) {
+      // Only act on plain files (no extension) — these are active typing channels
+      if (file.includes('.')) continue;
+      const channelId = file;
+      const errorFile = path.join(typingDir, `${channelId}.error`);
+      if (fs.existsSync(errorFile)) {
+        // Error signalled by runner — clean up both files and stop typing
+        try { fs.rmSync(path.join(typingDir, channelId), { force: true }); } catch {}
+        try { fs.rmSync(errorFile, { force: true }); } catch {}
+        continue;
+      }
+      try {
+        await fetch(`https://discord.com/api/v10/channels/${channelId}/typing`, {
+          method: 'POST',
+          headers: { Authorization: `Bot ${this.getToken()!}`, 'Content-Length': '0' },
+        });
+      } catch {}
+    }
+  }
+
+  private async checkApprovals(approvedDir: string): Promise<void> {
+    let files: string[];
+    try { files = fs.readdirSync(approvedDir); } catch { return; }
+
+    for (const userId of files) {
+      const file = path.join(approvedDir, userId);
+      let channelId: string;
+      try { channelId = fs.readFileSync(file, 'utf8').trim(); } catch { continue; }
+
+      try {
+        const channel = await this.client.channels.fetch(channelId);
+        await channel.send("You're connected! Send me a message to get started.");
+      } catch {}
+
+      try { fs.unlinkSync(file); } catch {}
+    }
+  }
+
+  getSnapshot(): ChannelAccountSnapshot {
+    return {
+      accountId: this.id,
+      running: this.running,
+      configured: this.isEnabled(),
+      lastMessageAt: this.lastMessageAt,
+      lastError: this.lastError,
+    };
+  }
+
+  private async handleReply(args: Record<string, unknown>): Promise<McpToolResult> {
+    const channel = await this.client.channels.fetch(args.channel_id as string);
+    const text = args.text as string;
+    const replyTo = args.reply_to as string | undefined;
+    const files = (args.files as string[] | undefined) ?? [];
+    const useEmbed = Boolean(args.embed);
+
+    for (const f of files) {
+      const st = fs.statSync(f);
+      if (st.size > MAX_ATTACHMENT_BYTES) {
+        throw new Error(`file too large: ${f} (${(st.size / 1024 / 1024).toFixed(1)}MB, max 50MB)`);
+      }
+    }
+
+    const sent = await sendMessage(channel, text, { replyTo, files, useEmbed });
+    const ids = sent.map(m => m.id).join(', ');
+    return { content: [{ type: 'text', text: `sent (${sent.length === 1 ? `id: ${ids}` : `ids: ${ids}`})` }] };
+  }
+
+  private async handleReact(args: Record<string, unknown>): Promise<McpToolResult> {
+    const channel = await this.client.channels.fetch(args.channel_id as string);
+    const message = await channel.messages.fetch(args.message_id as string);
+    await message.react(args.emoji as string);
+    return { content: [{ type: 'text', text: 'reacted' }] };
+  }
+
+  private async handleEditMessage(args: Record<string, unknown>): Promise<McpToolResult> {
+    const channel = await this.client.channels.fetch(args.channel_id as string);
+    const message = await channel.messages.fetch(args.message_id as string);
+    const edited = await message.edit(args.text as string);
+    return { content: [{ type: 'text', text: `edited (id: ${edited.id})` }] };
+  }
+
+  private async handleDownloadAttachment(args: Record<string, unknown>): Promise<McpToolResult> {
+    const url = args.url as string;
+    const filename = (args.filename as string | undefined) ?? path.basename(url.split('?')[0]);
+    const ext = path.extname(filename).replace(/[^a-zA-Z0-9.]/g, '') || '.bin';
+    const dlPath = path.join(this.inboxDir, `${Date.now()}-${filename.replace(/[^a-zA-Z0-9._-]/g, '_')}`);
+
+    fs.mkdirSync(this.inboxDir, { recursive: true });
+
+    await new Promise<void>((resolve, reject) => {
+      const proto = url.startsWith('https') ? https : http;
+      const file = fs.createWriteStream(dlPath);
+      proto.get(url, res => {
+        if (res.statusCode && res.statusCode >= 400) {
+          file.close();
+          reject(new Error(`download failed: HTTP ${res.statusCode}`));
+          return;
+        }
+        res.pipe(file);
+        file.on('finish', () => { file.close(); resolve(); });
+      }).on('error', err => { file.close(); reject(err); });
+    });
+
+    return { content: [{ type: 'text', text: dlPath }] };
+  }
+
+  private async handleCreateThread(args: Record<string, unknown>): Promise<McpToolResult> {
+    const channel = await this.client.channels.fetch(args.channel_id as string);
+    const name = (args.name as string).slice(0, 100);
+    let thread: any;
+    if (args.message_id) {
+      const message = await channel.messages.fetch(args.message_id as string);
+      thread = await message.startThread({ name, autoArchiveDuration: 60 });
+    } else {
+      thread = await channel.threads.create({ name, autoArchiveDuration: 60 });
+    }
+    return { content: [{ type: 'text', text: `thread created (id: ${thread.id})` }] };
+  }
+}

package/mcp/tools/discord/outbound.ts

@@ -0,0 +1,90 @@
+/**
+ * Discord outbound adapter — openclaw pattern from send.outbound.ts.
+ * Uses local SendableChannel interface; no top-level discord.js import.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { SendableChannel, SentMessage, EmbedData, FileAttachment } from './types';
+
+const MAX_MESSAGE_LENGTH = 2000;
+const MAX_EMBED_DESCRIPTION = 4096;
+
+export async function sendMessage(
+  channel: SendableChannel,
+  text: string,
+  options: {
+    replyTo?: string;
+    files?: string[];
+    useEmbed?: boolean;
+  } = {},
+): Promise<SentMessage[]> {
+  const sent: SentMessage[] = [];
+
+  if (text.length > MAX_MESSAGE_LENGTH && options.useEmbed) {
+    const embedText = text.slice(0, MAX_EMBED_DESCRIPTION);
+    const embed: EmbedData = { description: embedText };
+    const msg = await channel.send({ embeds: [embed] });
+    sent.push(msg);
+
+    const remaining = text.slice(MAX_EMBED_DESCRIPTION);
+    if (remaining) {
+      const chunks = chunkText(remaining, MAX_MESSAGE_LENGTH);
+      for (const chunk of chunks) {
+        sent.push(await channel.send({ content: chunk }));
+      }
+    }
+  } else {
+    const chunks = chunkText(text, MAX_MESSAGE_LENGTH);
+    const replyRef = options.replyTo;
+    for (let i = 0; i < chunks.length; i++) {
+      const sendOpts: Parameters<SendableChannel['send']>[0] = { content: chunks[i] };
+      if (replyRef && i === 0) sendOpts.reply = { messageReference: replyRef };
+      sent.push(await channel.send(sendOpts));
+    }
+  }
+
+  for (const filePath of options.files ?? []) {
+    const attachment: FileAttachment = {
+      attachment: filePath,
+      name: path.basename(filePath),
+    };
+    sent.push(await channel.send({ files: [attachment] }));
+  }
+
+  return sent;
+}
+
+export function chunkText(text: string, limit: number): string[] {
+  if (text.length <= limit) return [text];
+  const chunks: string[] = [];
+  let rest = text;
+  while (rest.length > limit) {
+    const para = rest.lastIndexOf('\n\n', limit);
+    const nl = rest.lastIndexOf('\n', limit);
+    const sp = rest.lastIndexOf(' ', limit);
+    const cut = para > limit / 2 ? para : nl > limit / 2 ? nl : sp > 0 ? sp : limit;
+    chunks.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\n+/, '');
+  }
+  if (rest) chunks.push(rest);
+  return chunks;
+}
+
+export function validateFilePath(filePath: string, inboxDir: string): void {
+  let real: string;
+  try {
+    real = fs.realpathSync(filePath);
+  } catch {
+    return;
+  }
+  let inboxReal: string;
+  try {
+    inboxReal = fs.realpathSync(inboxDir);
+  } catch {
+    return;
+  }
+  if (real.startsWith(path.dirname(inboxReal) + path.sep) && !real.startsWith(inboxReal + path.sep)) {
+    throw new Error(`refusing to send state directory file: ${filePath}`);
+  }
+}

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

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+/**
+ * Standalone Discord receiver — spawned by DiscordReceiver in src/discord/receiver.ts.
+ * Connects to Discord, runs the access gate, and POSTs inbound messages to
+ * CLAUDE_CHANNEL_CALLBACK so the AgentRunner can route them to a session.
+ */
+
+import { DiscordModule } from './module';
+import type { InboundMessage } from '../../types';
+
+const CALLBACK_URL = process.env.CLAUDE_CHANNEL_CALLBACK;
+if (!CALLBACK_URL) {
+  process.stderr.write('discord receiver: CLAUDE_CHANNEL_CALLBACK required\n');
+  process.exit(1);
+}
+
+async function postCallback(inbound: InboundMessage): Promise<void> {
+  const meta: Record<string, string> = {
+    source: 'discord',
+    chat_id: inbound.chatId,
+    user: inbound.senderId,
+    message_id: inbound.messageId ?? '',
+    ts: new Date(inbound.ts).toISOString(),
+  };
+
+  if (inbound.attachmentFileId) {
+    meta['attachment_file_id'] = inbound.attachmentFileId;
+  }
+
+  try {
+    await fetch(CALLBACK_URL!, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ content: inbound.text ?? '', meta }),
+    });
+  } catch (err) {
+    process.stderr.write(`discord receiver: callback POST failed: ${err}\n`);
+  }
+}
+
+const mod = new DiscordModule();
+const controller = new AbortController();
+
+function shutdown(): void {
+  process.stderr.write('discord receiver: shutting down\n');
+  controller.abort();
+  setTimeout(() => process.exit(0), 2000);
+}
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+process.stderr.write('discord receiver: starting\n');
+try {
+  await mod.start(postCallback, controller.signal);
+} catch (err) {
+  process.stderr.write(`discord receiver: fatal error: ${err}\n`);
+  process.exit(1);
+}

package/mcp/tools/discord/skills/access/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: discord-access
+description: Manage Discord channel access — guild/channel allowlists, DM policy, user/role allowlists.
+user-invocable: true
+---
+
+# /gateway:discord-access — Manage Discord access
+
+Use this skill to view or update Discord access settings stored at `$DISCORD_STATE_DIR/access.json`.
+
+## Commands
+
+### Show current access config
+```
+/gateway:discord-access show
+```
+
+### Set DM policy
+```
+/gateway:discord-access dm-policy <pairing|allowlist|disabled>
+```
+
+### Add/remove user from DM allowlist
+```
+/gateway:discord-access dm-allow <user_id>
+/gateway:discord-access dm-deny <user_id>
+```
+
+### Approve a pending pairing code
+```
+/gateway:discord-access pair <code>
+```
+
+### Deny/remove a pending pairing code
+```
+/gateway:discord-access deny <code>
+```
+
+### Add/remove guild from allowlist
+```
+/gateway:discord-access guild-allow <guild_id>
+/gateway:discord-access guild-deny <guild_id>
+```
+
+### Add/remove channel from allowlist
+```
+/gateway:discord-access channel-allow <channel_id>
+/gateway:discord-access channel-deny <channel_id>
+```
+
+## Access file format (`access.json`)
+
+```json
+{
+  "dmPolicy": "pairing",
+  "allowFrom": [],
+  "guildAllowlist": [],
+  "channelAllowlist": [],
+  "roleAllowlist": [],
+  "pending": {}
+}
+```
+
+## Implementation
+
+Read `$DISCORD_STATE_DIR/access.json`, apply the requested change, write it back.
+If the file does not exist, create it with defaults (dmPolicy: pairing, empty lists, empty pending).
+
+### `pair <code>` implementation
+1. Load `$DISCORD_STATE_DIR/access.json`
+2. Look up `pending[code]` — error if not found
+3. Check `pending[code].expiresAt > Date.now()` — error if expired
+4. Add `pending[code].senderId` to `allowFrom` (deduped)
+5. Delete `pending[code]`
+6. Write `$DISCORD_STATE_DIR/approved/<senderId>` with the `channelId` as file contents
+7. Save `access.json`
+8. Report: "Paired! User `<senderId>` added to allowFrom. Bot will send confirmation within 5s."
+
+### `deny <code>` implementation
+1. Load `$DISCORD_STATE_DIR/access.json`
+2. Look up `pending[code]` — error if not found
+3. Delete `pending[code]`
+4. Save `access.json`
+5. Report: "Code `<code>` rejected and removed."
+
+Always confirm the change made and show the new config.