# Load plugin-type channels
codebuddy --channels plugin:fakechat@claude-plugins-official

# Load the channel server configured in .mcp.json
codebuddy --channels server:webhook

# Load multiple channels (comma-separated)
codebuddy --channels plugin:telegram@claude-plugins-official,plugin:discord@claude-plugins-official

codebuddy --dangerously-load-development-channels server:my-webhook

<channel source="fakechat" sender="web" chat_id="1">Hello, please help me look into this issue.</channel>

#fakechat · web: Hello, please help me look into this issue.

{
  "channelsEnabled": true
}

#!/usr/bin/env bun
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const mcp = new Server(
  { name: 'webhook', version: '0.0.1' },
  {
    capabilities: { experimental: { 'claude/channel': {} } },
    instructions: 'Events from webhooks arrive with the <channel source="webhook" ...> tag. This is a one-way channel, so you only need to read and process them.',
  },
)

await mcp.connect(new StdioServerTransport())

Bun.serve({
  port: 8788,
  hostname: '127.0.0.1',
  async fetch(req) {
    const body = await req.text()
    await mcp.notification({
      method: 'notifications/claude/channel',
      params: {
        content: body,
        meta: { path: new URL(req.url).pathname, method: req.method },
      },
    })
    return new Response('ok')
  },
})

{
  "mcpServers": {
    "webhook": { "command": "bun", "args": ["./webhook.ts"] }
  }
}

await mcp.notification({
  method: 'notifications/claude/channel',
  params: {
    content: 'build failed on main',
    meta: { severity: 'high', run_id: '1234' },
  },
})

<channel source="webhook" severity="high" run_id="1234">
build failed on main
</channel>

import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'

mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: 'reply',
    description: 'Send a reply message through this channel',
    inputSchema: {
      type: 'object',
      properties: {
        chat_id: { type: 'string', description: 'The conversation ID to reply to' },
        text: { type: 'string', description: 'The message to send' },
      },
      required: ['chat_id', 'text'],
    },
  }],
}))

mcp.setRequestHandler(CallToolRequestSchema, async req => {
  if (req.params.name === 'reply') {
    const { chat_id, text } = req.params.arguments as { chat_id: string; text: string }
    // Call your chat platform API to send a message.
    await sendToPlatform(chat_id, text)
    return { content: [{ type: 'text', text: 'sent' }] }
  }
  throw new Error(`unknown tool: ${req.params.name}`)
})

const allowed = new Set(loadAllowlist())

// In the message handler, before sending a notification:
if (!allowed.has(message.from.id)) {  // Check the sender ID, not the group ID.
  return  // Silently discard.
}
await mcp.notification({ ... })

capabilities: {
  experimental: {
    'claude/channel': {},
    'claude/channel/permission': {},  // Enable permission relay.
  },
  tools: {},
},

await mcp.notification({
  method: 'notifications/claude/channel/permission',
  params: {
    request_id: '<received request_id>',
    behavior: 'allow',  // or 'deny'
  },
})

// Matches "y abcde", "yes abcde", "n abcde", "no abcde"
// [a-km-z] is the ID alphabet used by CodeBuddy Code (lowercase, skipping 'l').
const PERMISSION_REPLY_RE = /^\\s*(y|yes|n|no)\\s+([a-km-z]{5})\\s*$/i

const m = PERMISSION_REPLY_RE.exec(message.text)
if (m) {
  await mcp.notification({
    method: 'notifications/claude/channel/permission',
    params: {
      request_id: m[2].toLowerCase(),
      behavior: m[1].toLowerCase().startsWith('y') ? 'allow' : 'deny',
    },
  })
  return  // Handle as a decision without forwarding to chat.
}