discord-mcp/dist/index-official.js

Discord integration for Model Context Protocol

#!/usr/bin/env node
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
const logger_js_1 = require("./utils/logger.js");
const index_js_2 = require("./tools/index.js");
const index_js_3 = require("./resources/index.js");
const config_js_1 = require("./config.js");
const service_js_1 = require("./discord/service.js");
const session_js_1 = require("./session.js");
const sessionManager = new session_js_1.SessionManager();
const discordService = new service_js_1.DiscordService(config_js_1.config.discord.token);
const server = new index_js_1.Server({
    name: 'Discord MCP Server',
    version: '2.0.1',
}, {
    capabilities: {
        tools: {},
        resources: {},
    },
});
const tools = (0, index_js_2.registerTools)(discordService, sessionManager);
server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
    return {
        tools: tools.map(tool => ({
            name: tool.name,
            description: tool.description,
            inputSchema: tool.parameters,
        })),
    };
});
server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
    const tool = tools.find(t => t.name === request.params.name);
    if (!tool) {
        throw new Error(`Unknown tool: ${request.params.name}`);
    }
    try {
        const result = await tool.execute(request.params.arguments || {}, {
            sessionManager,
            discordService,
        });
        return {
            content: [
                {
                    type: 'text',
                    text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
                },
            ],
        };
    }
    catch (error) {
        logger_js_1.logger.error({ msg: 'Tool execution error', tool: request.params.name, error });
        return {
            content: [
                {
                    type: 'text',
                    text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
                },
            ],
            isError: true,
        };
    }
});
const resources = (0, index_js_3.registerResources)(discordService, sessionManager);
server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
    return {
        resources: resources.map(resource => ({
            uri: resource.uri,
            name: resource.name,
            description: resource.description,
            mimeType: resource.mimeType,
        })),
    };
});
server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
    const resource = resources.find(r => r.uri === request.params.uri);
    if (!resource) {
        throw new Error(`Unknown resource: ${request.params.uri}`);
    }
    try {
        const contents = await resource.contents();
        return {
            contents: [
                {
                    uri: request.params.uri,
                    mimeType: resource.mimeType || 'text/plain',
                    text: typeof contents === 'string' ? contents : JSON.stringify(contents, null, 2),
                },
            ],
        };
    }
    catch (error) {
        logger_js_1.logger.error({ msg: 'Resource read error', resource: request.params.uri, error });
        throw error;
    }
});
async function main() {
    try {
        const transport = new stdio_js_1.StdioServerTransport();
        await server.connect(transport);
        logger_js_1.logger.info({ msg: 'Discord MCP Server started' });
    }
    catch (error) {
        logger_js_1.logger.error({ msg: 'Failed to start server', error });
        process.exit(1);
    }
}
main();
//# sourceMappingURL=index-official.js.map