bkinnightskytw
/
mcp-discord
mirror of https://github.com/existedinnettw/mcp-discord.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: implement multi-transport support and optimize Discord MCP server

This commit is contained in:
Barry Yip 2025-05-09 00:38:03 +08:00
parent 21c910a15d
commit 7baf5a03e6
7 changed files with 960 additions and 552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
README.md
View File

@ -77,56 +77,119 @@ npm run build
## Configuration
A Discord bot token is required for proper operation. You can provide it in two ways:
A Discord bot token is required for proper operation. The server supports two transport methods: stdio and streamable HTTP.
### Transport Methods
1. **stdio** (Default)
- Traditional stdio transport for basic usage
- Suitable for simple integrations
2. **streamable HTTP**
- HTTP-based transport for more advanced scenarios
- Supports stateless operation
- Configurable port number
- Powered by Smithery SDK for improved reliability and performance
### Configuration Options
You can provide configuration in two ways:
1. Environment variables:
```
```bash
DISCORD_TOKEN=your_discord_bot_token
```
2. Using the `--config` parameter when launching:
```
node path/to/mcp-discord/build/index.js --config "{\"DISCORD_TOKEN\":\"your_discord_bot_token\"}"
2. Using command line arguments:
```bash
# For stdio transport (default)
node build/index.js --config "your_discord_bot_token"
# For streamable HTTP transport
node build/index.js --transport http --port 3000 --config "your_discord_bot_token"
```
## Usage with Claude/Cursor
- Claude
```json
{
"mcpServers": {
"discord": {
"command": "node",
"args": [
"path/to/mcp-discord/build/index.js"
],
"env": {
"DISCORD_TOKEN": "your_discord_bot_token"
}
}
### Claude
1. Using stdio transport:
```json
{
"mcpServers": {
"discord": {
"command": "node",
"args": [
"path/to/mcp-discord/build/index.js",
"--config",
"your_discord_bot_token"
]
}
}
```
}
```
- Cursor
```json
{
"mcpServers": {
"discord": {
"command": "cmd",
"args": [
"/c",
"node",
"path/to/mcp-discord/build/index.js"
],
"env": {
"DISCORD_TOKEN": "your_discord_bot_token"
}
}
}
2. Using streamable HTTP transport:
```json
{
"mcpServers": {
"discord": {
"command": "node",
"args": [
"path/to/mcp-discord/build/index.js",
"--transport",
"http",
"--port",
"3000",
"--config",
"your_discord_bot_token"
]
}
}
```
}
```
### Cursor
1. Using stdio transport:
```json
{
"mcpServers": {
"discord": {
"command": "cmd",
"args": [
"/c",
"node",
"path/to/mcp-discord/build/index.js",
"--config",
"your_discord_bot_token"
]
}
}
}
```
2. Using streamable HTTP transport:
```json
{
"mcpServers": {
"discord": {
"command": "cmd",
"args": [
"/c",
"node",
"path/to/mcp-discord/build/index.js",
"--transport",
"http",
"--port",
"3000",
"--config",
"your_discord_bot_token"
]
}
}
}
```
## Tools Documentation

490
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

13
package.json
View File

@ -1,6 +1,6 @@
{
"name": "mcp-discord",
"version": "1.1.0",
"version": "1.2.0",
"main": "build/index.js",
"bin": {
"mcp-discord": "build/index.js"
@ -10,20 +10,23 @@
"test": "echo \"Error: no test specified\" && exit 1",
"build": "tsc",
"start": "node build/index.js",
"dev": "node --loader ts-node/esm src/index.ts"
"dev": "node --loader ts-node/esm src/index.ts",
"test-api": "node test-api.js"
},
"author": "",
"license": "MIT",
"description": "",
"devDependencies": {
"@modelcontextprotocol/sdk": "^1.8.0",
"@modelcontextprotocol/sdk": "^1.11.0",
"@types/express": "^5.0.1",
"@types/node": "^20.17.26",
"ts-node": "^10.9.2",
"typescript": "^5.8.2"
"typescript": "^5.8.3"
},
"dependencies": {
"discord.js": "^14.18.0",
"dotenv": "^16.4.7",
"dotenv": "^16.5.0",
"express": "^5.1.0",
"zod": "^3.24.2"
}
}

36
smithery.yaml
View File

@ -1,9 +1,9 @@
# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml
startCommand:
type: stdio
version: 1
start:
type: http
configSchema:
# JSON Schema defining the configuration options for the MCP.
type: object
required:
- discordToken
@ -11,13 +11,27 @@ startCommand:
discordToken:
type: string
description: Discord bot token. Obtain this from the Discord Developer Portal.
commandFunction:
# A JS function that produces the CLI command based on the given config to start the MCP on stdio.
|-
(config) => ({
command: 'node',
args: ['build/index.js'],
env: { DISCORD_TOKEN: config.discordToken }
})
port:
type: number
description: Port number for the HTTP server
default: 3000
command:
function: |
(config) => ({
command: 'node',
args: [
'build/index.js',
'--transport',
'http',
'--port',
config.port || 3000,
'--config',
config.discordToken
],
env: {
NODE_ENV: 'production'
}
})
exampleConfig:
discordToken: YOUR_DISCORD_BOT_TOKEN
port: 3000

275
src/index.ts
View File

@ -1,73 +1,60 @@
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { Client, GatewayIntentBits } from "discord.js";
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { toolList } from './toolList.js';
import {
createToolContext,
loginHandler,
sendMessageHandler,
getForumChannelsHandler,
createForumPostHandler,
getForumPostHandler,
replyToForumHandler,
deleteForumPostHandler,
createTextChannelHandler,
deleteChannelHandler,
readMessagesHandler,
getServerInfoHandler,
addReactionHandler,
addMultipleReactionsHandler,
removeReactionHandler,
deleteMessageHandler,
createWebhookHandler,
sendWebhookMessageHandler,
editWebhookHandler,
deleteWebhookHandler
} from './tools/tools.js';
import { config as dotenvConfig } from 'dotenv';
import { DiscordMCPServer } from './server.js';
import { StdioTransport, StreamableHttpTransport } from './transport.js';
// Configuration parsing
let config: any = {};
// Load environment variables from .env file if exists
dotenvConfig();
// Read configuration from environment variables
if (process.env.DISCORD_TOKEN) {
config.DISCORD_TOKEN = process.env.DISCORD_TOKEN;
console.log("Config loaded from environment variables. Discord token available:", !!config.DISCORD_TOKEN);
if (config.DISCORD_TOKEN) {
console.log("Token length:", config.DISCORD_TOKEN.length);
}
} else {
// Try to parse configuration from command line arguments (for backward compatibility)
const configArgIndex = process.argv.indexOf('--config');
if (configArgIndex !== -1 && configArgIndex < process.argv.length - 1) {
// Configuration with priority for command line arguments
const config = {
DISCORD_TOKEN: (() => {
try {
let configStr = process.argv[configArgIndex + 1];
// Print raw configuration string for debugging
console.log("Raw config string:", configStr);
// Try to parse JSON
config = JSON.parse(configStr);
console.log("Config parsed successfully. Discord token available:", !!config.DISCORD_TOKEN);
if (config.DISCORD_TOKEN) {
console.log("Token length:", config.DISCORD_TOKEN.length);
// First try to get from command line arguments
const configIndex = process.argv.indexOf('--config');
if (configIndex !== -1 && configIndex + 1 < process.argv.length) {
const configArg = process.argv[configIndex + 1];
// Handle both string and object formats
if (typeof configArg === 'string') {
try {
const parsedConfig = JSON.parse(configArg);
return parsedConfig.DISCORD_TOKEN;
} catch (e) {
// If not valid JSON, try using the string directly
return configArg;
}
}
}
// Then try environment variable
return process.env.DISCORD_TOKEN;
} catch (error) {
console.error("Failed to parse config argument:", error);
console.error("Raw config argument:", process.argv[configArgIndex + 1]);
// Try to read arguments directly (for debugging)
console.log("All arguments:", process.argv);
console.error('Error parsing config:', error);
return null;
}
} else {
console.warn("No config found in environment variables or command line arguments");
console.log("All arguments:", process.argv);
}
})(),
TRANSPORT: (() => {
// Check for transport type argument
const transportIndex = process.argv.indexOf('--transport');
if (transportIndex !== -1 && transportIndex + 1 < process.argv.length) {
return process.argv[transportIndex + 1];
}
// Default to stdio
return 'stdio';
})(),
HTTP_PORT: (() => {
// Check for port argument
const portIndex = process.argv.indexOf('--port');
if (portIndex !== -1 && portIndex + 1 < process.argv.length) {
return parseInt(process.argv[portIndex + 1]);
}
// Default port
return 3000;
})()
};
if (!config.DISCORD_TOKEN) {
console.error('Discord token not found. Please provide it via --config argument or environment variable.');
process.exit(1);
}
// Create Discord client
@ -84,141 +71,13 @@ if (config.DISCORD_TOKEN) {
client.token = config.DISCORD_TOKEN;
}
// Create an MCP server
const server = new Server(
{
name: "MCP-Discord",
version: "1.0.0"
},
{
capabilities: {
tools: {}
}
}
);
// Set up the tool list
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: toolList
};
});
// Create tool context
const toolContext = createToolContext(client);
// Handle tool execution requests
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
let toolResponse;
switch (name) {
case "discord_login":
toolResponse = await loginHandler(args, toolContext);
return toolResponse;
case "discord_send":
toolResponse = await sendMessageHandler(args, toolContext);
return toolResponse;
case "discord_get_forum_channels":
toolResponse = await getForumChannelsHandler(args, toolContext);
return toolResponse;
case "discord_create_forum_post":
toolResponse = await createForumPostHandler(args, toolContext);
return toolResponse;
case "discord_get_forum_post":
toolResponse = await getForumPostHandler(args, toolContext);
return toolResponse;
case "discord_reply_to_forum":
toolResponse = await replyToForumHandler(args, toolContext);
return toolResponse;
case "discord_delete_forum_post":
toolResponse = await deleteForumPostHandler(args, toolContext);
return toolResponse;
case "discord_create_text_channel":
toolResponse = await createTextChannelHandler(args, toolContext);
return toolResponse;
case "discord_delete_channel":
toolResponse = await deleteChannelHandler(args, toolContext);
return toolResponse;
case "discord_read_messages":
toolResponse = await readMessagesHandler(args, toolContext);
return toolResponse;
case "discord_get_server_info":
toolResponse = await getServerInfoHandler(args, toolContext);
return toolResponse;
case "discord_add_reaction":
toolResponse = await addReactionHandler(args, toolContext);
return toolResponse;
case "discord_add_multiple_reactions":
toolResponse = await addMultipleReactionsHandler(args, toolContext);
return toolResponse;
case "discord_remove_reaction":
toolResponse = await removeReactionHandler(args, toolContext);
return toolResponse;
case "discord_delete_message":
toolResponse = await deleteMessageHandler(args, toolContext);
return toolResponse;
case "discord_create_webhook":
toolResponse = await createWebhookHandler(args, toolContext);
return toolResponse;
case "discord_send_webhook_message":
toolResponse = await sendWebhookMessageHandler(args, toolContext);
return toolResponse;
case "discord_edit_webhook":
toolResponse = await editWebhookHandler(args, toolContext);
return toolResponse;
case "discord_delete_webhook":
toolResponse = await deleteWebhookHandler(args, toolContext);
return toolResponse;
default:
throw new Error(`Unknown tool: ${name}`);
}
} catch (error) {
if (error instanceof z.ZodError) {
return {
content: [{
type: "text",
text: `Invalid arguments: ${error.errors
.map((e) => `${e.path.join(".")}: ${e.message}`)
.join(", ")}`
}],
isError: true
};
}
return {
content: [{ type: "text", text: `Error executing tool: ${error}` }],
isError: true
};
}
});
// Auto-login on startup if token is available
const autoLogin = async () => {
const token = config.DISCORD_TOKEN;
if (token) {
try {
await client.login(token);
console.log('Successfully logged in to Discord');
} catch (error) {
console.error("Auto-login failed:", error);
}
@ -227,8 +86,32 @@ const autoLogin = async () => {
}
};
// Start auto-login process
autoLogin();
// Initialize transport based on configuration
const initializeTransport = () => {
switch (config.TRANSPORT.toLowerCase()) {
case 'http':
console.log(`Initializing HTTP transport on port ${config.HTTP_PORT}`);
return new StreamableHttpTransport(config.HTTP_PORT);
case 'stdio':
console.log('Initializing stdio transport');
return new StdioTransport();
default:
console.error(`Unknown transport type: ${config.TRANSPORT}. Falling back to stdio.`);
return new StdioTransport();
}
};
const transport = new StdioServerTransport();
await server.connect(transport);
// Start auto-login process
await autoLogin();
// Create and start MCP server with selected transport
const transport = initializeTransport();
const mcpServer = new DiscordMCPServer(client, transport);
try {
await mcpServer.start();
console.log('MCP server started successfully');
} catch (error) {
console.error('Failed to start MCP server:', error);
process.exit(1);
}

184
src/server.ts Normal file
View File

@ -0,0 +1,184 @@
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { Client } from "discord.js";
import { z } from "zod";
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { toolList } from './toolList.js';
import {
createToolContext,
loginHandler,
sendMessageHandler,
getForumChannelsHandler,
createForumPostHandler,
getForumPostHandler,
replyToForumHandler,
deleteForumPostHandler,
createTextChannelHandler,
deleteChannelHandler,
readMessagesHandler,
getServerInfoHandler,
addReactionHandler,
addMultipleReactionsHandler,
removeReactionHandler,
deleteMessageHandler,
createWebhookHandler,
sendWebhookMessageHandler,
editWebhookHandler,
deleteWebhookHandler
} from './tools/tools.js';
import { MCPTransport } from './transport.js';
export class DiscordMCPServer {
private server: Server;
private toolContext: ReturnType<typeof createToolContext>;
constructor(
private client: Client,
private transport: MCPTransport
) {
this.server = new Server(
{
name: "MCP-Discord",
version: "1.0.0"
},
{
capabilities: {
tools: {}
}
}
);
this.toolContext = createToolContext(client);
this.setupHandlers();
}
private setupHandlers() {
// Set up the tool list
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: toolList
};
});
// Handle tool execution requests
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
let toolResponse;
switch (name) {
case "discord_login":
toolResponse = await loginHandler(args, this.toolContext);
return toolResponse;
case "discord_send":
toolResponse = await sendMessageHandler(args, this.toolContext);
return toolResponse;
case "discord_get_forum_channels":
toolResponse = await getForumChannelsHandler(args, this.toolContext);
return toolResponse;
case "discord_create_forum_post":
toolResponse = await createForumPostHandler(args, this.toolContext);
return toolResponse;
case "discord_get_forum_post":
toolResponse = await getForumPostHandler(args, this.toolContext);
return toolResponse;
case "discord_reply_to_forum":
toolResponse = await replyToForumHandler(args, this.toolContext);
return toolResponse;
case "discord_delete_forum_post":
toolResponse = await deleteForumPostHandler(args, this.toolContext);
return toolResponse;
case "discord_create_text_channel":
toolResponse = await createTextChannelHandler(args, this.toolContext);
return toolResponse;
case "discord_delete_channel":
toolResponse = await deleteChannelHandler(args, this.toolContext);
return toolResponse;
case "discord_read_messages":
toolResponse = await readMessagesHandler(args, this.toolContext);
return toolResponse;
case "discord_get_server_info":
toolResponse = await getServerInfoHandler(args, this.toolContext);
return toolResponse;
case "discord_add_reaction":
toolResponse = await addReactionHandler(args, this.toolContext);
return toolResponse;
case "discord_add_multiple_reactions":
toolResponse = await addMultipleReactionsHandler(args, this.toolContext);
return toolResponse;
case "discord_remove_reaction":
toolResponse = await removeReactionHandler(args, this.toolContext);
return toolResponse;
case "discord_delete_message":
toolResponse = await deleteMessageHandler(args, this.toolContext);
return toolResponse;
case "discord_create_webhook":
toolResponse = await createWebhookHandler(args, this.toolContext);
return toolResponse;
case "discord_send_webhook_message":
toolResponse = await sendWebhookMessageHandler(args, this.toolContext);
return toolResponse;
case "discord_edit_webhook":
toolResponse = await editWebhookHandler(args, this.toolContext);
return toolResponse;
case "discord_delete_webhook":
toolResponse = await deleteWebhookHandler(args, this.toolContext);
return toolResponse;
default:
throw new Error(`Unknown tool: ${name}`);
}
} catch (error) {
if (error instanceof z.ZodError) {
return {
content: [{
type: "text",
text: `Invalid arguments: ${error.errors
.map((e: z.ZodIssue) => `${e.path.join(".")}: ${e.message}`)
.join(", ")}`
}],
isError: true
};
}
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
return {
content: [{ type: "text", text: `Error executing tool: ${errorMessage}` }],
isError: true
};
}
});
}
async start() {
// Add client to server context so transport can access it
(this.server as any)._context = { client: this.client };
(this.server as any).client = this.client;
await this.transport.start(this.server);
}
async stop() {
await this.transport.stop();
}
}

375
src/transport.ts Normal file
View File

@ -0,0 +1,375 @@
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import express, { Request, Response } from "express";
import { toolList } from './toolList.js';
import {
createToolContext,
loginHandler,
sendMessageHandler,
getForumChannelsHandler,
createForumPostHandler,
getForumPostHandler,
replyToForumHandler,
deleteForumPostHandler,
createTextChannelHandler,
deleteChannelHandler,
readMessagesHandler,
getServerInfoHandler,
addReactionHandler,
addMultipleReactionsHandler,
removeReactionHandler,
deleteMessageHandler,
createWebhookHandler,
sendWebhookMessageHandler,
editWebhookHandler,
deleteWebhookHandler
} from './tools/tools.js';
import { Client } from "discord.js";
export interface MCPTransport {
start(server: Server): Promise<void>;
stop(): Promise<void>;
}
export class StdioTransport implements MCPTransport {
private transport: StdioServerTransport | null = null;
async start(server: Server): Promise<void> {
this.transport = new StdioServerTransport();
await server.connect(this.transport);
}
async stop(): Promise<void> {
if (this.transport) {
await this.transport.close();
this.transport = null;
}
}
}
export class StreamableHttpTransport implements MCPTransport {
private app: express.Application;
private server: Server | null = null;
private httpServer: any = null;
private transport: StreamableHTTPServerTransport | null = null;
private toolContext: ReturnType<typeof createToolContext> | null = null;
constructor(private port: number = 3000) {
this.app = express();
this.app.use(express.json());
this.setupEndpoints();
}
private setupEndpoints() {
// Handler for POST requests
this.app.post('/mcp', (req: Request, res: Response) => {
console.log('Received MCP request:', req.body);
this.handleMcpRequest(req, res).catch(error => {
console.error('Unhandled error in MCP request:', error);
});
});
// Handler for non-POST methods
this.app.all('/mcp', (req: Request, res: Response) => {
if (req.method !== 'POST') {
res.status(405).json({
jsonrpc: '2.0',
error: {
code: -32000,
message: 'Method not allowed. Use POST.',
},
id: null,
});
}
});
}
private async handleMcpRequest(req: Request, res: Response) {
try {
if (!this.server) {
return res.status(500).json({
jsonrpc: '2.0',
error: {
code: -32603,
message: 'Server not initialized',
},
id: req.body?.id || null,
});
}
console.log('Request body:', JSON.stringify(req.body));
// Handle all tool requests in a generic way
if (!req.body.method) {
return res.status(400).json({
jsonrpc: '2.0',
error: {
code: -32600,
message: 'Invalid Request: No method specified',
},
id: req.body?.id || null,
});
}
// Handle all tools directly with proper error handling
try {
const method = req.body.method;
const params = req.body.params || {};
// Make sure toolContext is available
if (!this.toolContext && method !== 'list_tools') {
return res.status(500).json({
jsonrpc: '2.0',
error: {
code: -32603,
message: 'Tool context not initialized. Service may need to be restarted.',
},
id: req.body?.id || null,
});
}
let result;
// Handle each tool method directly
switch (method) {
case 'list_tools':
result = { tools: toolList };
break;
case 'discord_login':
result = await loginHandler(params, this.toolContext!);
break;
case 'discord_send':
result = await sendMessageHandler(params, this.toolContext!);
break;
case 'discord_get_forum_channels':
result = await getForumChannelsHandler(params, this.toolContext!);
break;
case 'discord_create_forum_post':
result = await createForumPostHandler(params, this.toolContext!);
break;
case 'discord_get_forum_post':
result = await getForumPostHandler(params, this.toolContext!);
break;
case 'discord_reply_to_forum':
result = await replyToForumHandler(params, this.toolContext!);
break;
case 'discord_delete_forum_post':
result = await deleteForumPostHandler(params, this.toolContext!);
break;
case 'discord_create_text_channel':
result = await createTextChannelHandler(params, this.toolContext!);
break;
case 'discord_delete_channel':
result = await deleteChannelHandler(params, this.toolContext!);
break;
case 'discord_read_messages':
result = await readMessagesHandler(params, this.toolContext!);
break;
case 'discord_get_server_info':
result = await getServerInfoHandler(params, this.toolContext!);
break;
case 'discord_add_reaction':
result = await addReactionHandler(params, this.toolContext!);
break;
case 'discord_add_multiple_reactions':
result = await addMultipleReactionsHandler(params, this.toolContext!);
break;
case 'discord_remove_reaction':
result = await removeReactionHandler(params, this.toolContext!);
break;
case 'discord_delete_message':
result = await deleteMessageHandler(params, this.toolContext!);
break;
case 'discord_create_webhook':
result = await createWebhookHandler(params, this.toolContext!);
break;
case 'discord_send_webhook_message':
result = await sendWebhookMessageHandler(params, this.toolContext!);
break;
case 'discord_edit_webhook':
result = await editWebhookHandler(params, this.toolContext!);
break;
case 'discord_delete_webhook':
result = await deleteWebhookHandler(params, this.toolContext!);
break;
default:
return res.status(400).json({
jsonrpc: '2.0',
error: {
code: -32601,
message: `Method not found: ${method}`,
},
id: req.body?.id || null,
});
}
console.log(`Request for ${method} handled successfully`);
// Handle the case where tool handlers return { content, isError }
if (result && typeof result === 'object' && 'content' in result) {
// If it's an error from the tool handler
if ('isError' in result && result.isError) {
return res.status(400).json({
jsonrpc: '2.0',
id: req.body.id,
error: {
code: -32603,
message: Array.isArray(result.content)
? result.content.map((item: any) => item.text).join(' ')
: 'Tool execution error'
}
});
}
// Return success result but maintain same format as other RPC methods
return res.json({
jsonrpc: '2.0',
id: req.body.id,
result: result
});
}
// Standard result format
return res.json({
jsonrpc: '2.0',
id: req.body.id,
result: result
});
} catch (error) {
console.error('Error processing tool request:', error);
// Handle validation errors
if (error && typeof error === 'object' && 'name' in error && error.name === 'ZodError') {
return res.status(400).json({
jsonrpc: '2.0',
error: {
code: -32602,
message: `Invalid parameters: ${error && typeof error === 'object' && 'message' in error ? String(error.message) : 'Unknown validation error'}`,
},
id: req.body?.id || null,
});
}
// Handle all other errors
return res.status(500).json({
jsonrpc: '2.0',
error: {
code: -32603,
message: error instanceof Error ? error.message : 'Unknown error',
},
id: req.body?.id || null,
});
}
} catch (error) {
console.error('Error handling MCP request:', error);
if (!res.headersSent) {
res.status(500).json({
jsonrpc: '2.0',
error: {
code: -32603,
message: 'Internal server error',
},
id: req.body?.id || null,
});
}
}
}
async start(server: Server): Promise<void> {
this.server = server;
console.log('Starting HTTP transport with server:', !!this.server);
// Try to get client from the DiscordMCPServer instance
// First, check if the server is passed from DiscordMCPServer
if (server) {
// Try to access client directly from server._context
const anyServer = server as any;
let client: Client | undefined;
if (anyServer._context?.client) {
client = anyServer._context.client;
console.log('Found client in server._context');
}
// Also check if the server object has client directly
else if (anyServer.client instanceof Client) {
client = anyServer.client;
console.log('Found client directly on server object');
}
// Look in parent object if available
else if (anyServer._parent?.client instanceof Client) {
client = anyServer._parent.client;
console.log('Found client in server._parent');
}
if (client) {
this.toolContext = createToolContext(client);
console.log('Tool context initialized with Discord client');
} else {
// Create a dummy client for testing - allows list_tools to work
console.log('Unable to get Discord client. Creating tool context without client.');
this.toolContext = createToolContext({} as Client);
}
}
// Create a stateless transport
this.transport = new StreamableHTTPServerTransport({
sessionIdGenerator: undefined // set to undefined for stateless servers
});
// Connect the transport
await this.server.connect(this.transport);
console.log('Transport connected');
return new Promise((resolve) => {
this.httpServer = this.app.listen(this.port, () => {
console.log(`MCP Server listening on port ${this.port}`);
resolve();
});
});
}
async stop(): Promise<void> {
if (this.transport) {
await this.transport.close();
this.transport = null;
}
if (this.server) {
await this.server.close();
this.server = null;
}
if (this.httpServer) {
return new Promise((resolve) => {
this.httpServer.close(() => {
console.log('HTTP server closed');
this.httpServer = null;
resolve();
});
});
}
}
}