Claude Code と Discord 連携はどのように動作しているのか？

{
  "dmPolicy": "pairing",
  "allowFrom": ["<senderId>", ...],
  "groups": {
    "<channelId>": { "requireMention": true, "allowFrom": [] }
  },
  "pending": {
    "<6-char-code>": {
      "senderId": "...", "chatId": "...",
      "createdAt": <ms>, "expiresAt": <ms>
    }
  },
  "mentionPatterns": ["@mybot"]
}

async function gate(msg: Message): Promise<GateResult> {
  // access.json の内容を取得
  const access = loadAccess()
  // メッセージが DM かどうか
  const isDM = msg.channel.type === ChannelType.DM
 
  if (isDM) {
    // 許可リストに含まれるユーザーならメッセージを配信し、dmPolicy が allowlist なら許可リスト外のユーザーを拒否する
    if (access.allowFrom.includes(senderId)) return { action: 'deliver', access }
    if (access.dmPolicy === 'allowlist') return { action: 'drop' }
    // ...
  }
}

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 
const mcp = new Server(
  { name: 'discord', version: '0.0.1' },
  {
    capabilities: { experimental: { 'claude/channel': {} } },
    instructions: [
      'The sender reads Discord, not this session. Anything you want them to see must go through the reply tool — your transcript output never reaches their chat.',
      // 省略
    ].join('\n'),
  },
)

import { Client, GatewayIntentBits, Partials } from 'discord.js'
 
const TOKEN = process.env.DISCORD_BOT_TOKEN
 
const client = new Client({
  intents: [
    GatewayIntentBits.DirectMessages,
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
  partials: [Partials.Channel],
})
 
await client.login(TOKEN)

client.on('messageCreate', msg => {
  if (msg.author.bot) return
  handleInbound(msg).catch(e => process.stderr.write(`discord: handleInbound failed: ${e}\n`))
})
 
async function handleInbound(msg: Message): Promise<void> {
  //...
}

async function handleInbound(msg: Message): Promise<void> {
  // gate は許可リストに基づいてアクセス制御を行う関数
  const result = await gate(msg)
 
  if (result.action === 'drop') return
  // ...
  const content = msg.content || (atts.length > 0 ? '(attachment)' : '')
 
  // MCP サーバーの notification メソッドを呼び出して、Claude Code に通知を送る
  void mcp.notification({
    method: 'notifications/claude/channel',
    params: {
      content,
      meta: {
        chat_id,
        message_id: msg.id,
        user: msg.author.username,
        user_id: msg.author.id,
        ts: msg.createdAt.toISOString(),
        ...(atts.length > 0 ? { attachment_count: String(atts.length), attachments: atts.join('; ') } : {}),
      },
    },
  })
}

mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'reply',
      description:
        'Reply on Discord. Pass chat_id from the inbound message. Optionally pass reply_to (message_id) for threading, and files (absolute paths) to attach images or other files.',
      inputSchema: {
        type: 'object',
        properties: {
          chat_id: { type: 'string' },
          text: { type: 'string' },
          reply_to: {
            type: 'string',
            description: 'Message ID to thread under. Use message_id from the inbound <channel> block, or an id from fetch_messages.',
          },
          files: {
            type: 'array',
            items: { type: 'string' },
            description: 'Absolute file paths to attach (images, logs, etc). Max 10 files, 25MB each.',
          },
        },
        required: ['chat_id', 'text'],
      },
    },
    /// ...
  ],
}))

mcp.setRequestHandler(CallToolRequestSchema, async req => {
  const args = (req.params.arguments ?? {}) as Record<string, unknown>
  try {
    switch (req.params.name) {
      // reply ツールが呼び出された場合の処理
      case 'reply': {
        const chat_id = args.chat_id as string
        const text = args.text as string
        const reply_to = args.reply_to as string | undefined
        const files = (args.files as string[] | undefined) ?? []
 
        // 投稿先のチャンネルが送信可能かどうか確認する
        const ch = await fetchAllowedChannel(chat_id)
        if (!('send' in ch)) throw new Error('channel is not sendable')
 
        // 添付ファイルのサイズと数を確認する
        for (const f of files) {
          assertSendable(f)
          const st = statSync(f)
          if (st.size > MAX_ATTACHMENT_BYTES) {
            throw new Error(`file too large: ${f} (${(st.size / 1024 / 1024).toFixed(1)}MB, max 25MB)`)
          }
        }
        if (files.length > 10) throw new Error('Discord allows max 10 attachments per message')
 
        const access = loadAccess()
        const limit = Math.max(1, Math.min(access.textChunkLimit ?? MAX_CHUNK_LIMIT, MAX_CHUNK_LIMIT))
        const mode = access.chunkMode ?? 'length'
        const replyMode = access.replyToMode ?? 'first'
        const chunks = chunk(text, limit, mode)
        const sentIds: string[] = []
 
        try {
          // メッセージをチャンクに分割して送信する
          for (let i = 0; i < chunks.length; i++) {
            const shouldReplyTo =
              reply_to != null &&
              replyMode !== 'off' &&
              (replyMode === 'all' || i === 0)
            const sent = await ch.send({
              content: chunks[i],
              ...(i === 0 && files.length > 0 ? { files } : {}),
              ...(shouldReplyTo
                ? { reply: { messageReference: reply_to, failIfNotExists: false } }
                : {}),
            })
            noteSent(sent.id)
            sentIds.push(sent.id)
          }
        } catch (err) {
          const msg = err instanceof Error ? err.message : String(err)
          throw new Error(`reply failed after ${sentIds.length} of ${chunks.length} chunk(s) sent: ${msg}`)
        }
 
        const result =
          sentIds.length === 1
            ? `sent (id: ${sentIds[0]})`
            : `sent ${sentIds.length} parts (ids: ${sentIds.join(', ')})`
        return { content: [{ type: 'text', text: result }] }
      }
      // その他のツールの処理は省略
    }
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err)
    return {
      content: [{ type: 'text', text: `${req.params.name} failed: ${msg}` }],
      isError: true,
    }
  }
})

{
  "mcpServers": {
    "discord": {
      "command": "bun",
      "args": [
        "run",
        "--cwd",
        "${CLAUDE_PLUGIN_ROOT}",
        "--shell=bun",
        "--silent",
        "start"
      ]
    }
  }
}

import { Hono } from "hono";
 
interface Message {
  id: number;
  name: string;
  message: string;
  timestamp: string;
}
 
const app = new Hono();
const messages: Message[] = [];
let lastRetrievedIndex = 0;
 
app.post("/send", async (c) => {
  const body = await c.req.json<{ name?: string; message?: string }>();
  const { name, message } = body;
 
  if (!name || !message || name.trim() === "" || message.trim() === "") {
    return c.json({ error: "name and message are required" }, 400);
  }
 
  const newMessage: Message = {
    id: messages.length + 1,
    name: name.trim(),
    message: message.trim(),
    timestamp: new Date().toISOString(),
  };
 
  console.log(`Received message: ${newMessage.name}: ${newMessage.message}`);
 
  messages.push(newMessage);
  return c.json(newMessage, 201);
});
 
app.get("/messages", (c) => {
  const requesterName = c.req.query("name");
  const newMessages = messages.slice(lastRetrievedIndex);
  lastRetrievedIndex = messages.length;
 
  const result = requesterName
    ? newMessages.filter((m) => m.name !== requesterName)
    : newMessages;
 
  return c.json({ messages: result });
});
 
export default {
  port: 3000,
  fetch: app.fetch,
};

mkdir my-channel
cd my-channel
bun add @modelcontextprotocol/sdk

#!/usr/bin/env bun
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  ListToolsRequestSchema,
  CallToolRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
 
const mcp = new Server(
  { name: "my-channel", version: "0.0.1" },
  {
    capabilities: { experimental: { "claude/channel": {} }, tools: {} },
    instructions:
     "This is a channel for receiving messages from the chat service and replying to them using tools. The client can call the 'reply' tool to send a message back to the chat service.",
  },
);
 
await mcp.connect(new StdioServerTransport());

async function pollMessages() {
  while (true) {
    try {
      const res = await fetch("http://localhost:3000/messages?name=Claude");
      const { messages } = await res.json();
      for (const msg of messages) {
        await mcp.notification({
          method: "notifications/claude/channel",
          params: {
            content: msg.message,
            meta: {
              message_id: String(msg.id),
              user: msg.name,
              ts: msg.timestamp,
            },
          },
        });
      }
    } catch (err) {
      console.error("Failed to poll messages:", err);
    }
    await new Promise((resolve) => setTimeout(resolve, 5000)); // 5秒ごとにポーリング
  }
}
 
pollMessages();

mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "reply",
      description: "Reply to a message in the chat service.",
      inputSchema: {
        type: "object",
        properties: {
          text: { type: "string" },
        },
        required: ["text"],
      },
    },
  ],
}));

mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
  const args = req.params.arguments as Record<string, unknown>;
  if (req.params.name === "reply") {
    const text = args.text as string;
    try {
      const res = await fetch("http://localhost:3000/send", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ name: "Claude", message: text }),
      });
      if (!res.ok) {
        const errorText = await res.text();
        throw new Error(`Failed to send message: ${errorText}`);
      }
      return { content: [{ type: "text", text: "Message sent successfully" }] };
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : String(err);
      return {
        content: [
          { type: "text", text: `Failed to send message: ${errorMessage}` },
        ],
        isError: true,
      };
    }
  } else {
    throw new Error(`Unknown tool: ${req.params.name}`);
  }
});

{
  "mcpServers": {
    "my-channel": {
      "command": "bun",
      "args": ["./server.ts"]
    }
  }
}

bun run dev

claude --dangerously-load-development-channels server:my-channel

curl -X POST http://localhost:3000/send -H "Content-Type: application/json" -d '{"name": "azuki", "message": "こんにちは〜"}'