@takashito/linode-mcp-server/dist/server.js

MCP server for Linode API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.VERSION = void 0;
exports.startServer = startServer;
const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
const mcp_proxy_1 = require("mcp-proxy");
const client_1 = require("./client");
const tools_1 = require("./tools");
const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
exports.VERSION = '0.2.1';
/**
 * Creates and starts a Linode MCP Server
 * @param options Server configuration options
 * @returns Configured and running MCP server instance
 */
async function startServer(options) {
    console.error('Starting Linode MCP server...');
    // Initialize the server
    try {
        const server = new mcp_js_1.McpServer({
            name: 'linode-mcp-server',
            version: exports.VERSION,
            description: 'MCP server for Linode API integration'
        });
        server.server.registerCapabilities({
            resources: {},
            prompts: {}
        });
        console.error('MCP Server initialized successfully');
        // Create Linode client with the provided token
        const client = (0, client_1.createClient)(options.token);
        // Register tools with direct client access (only enabled categories)
        try {
            console.error(`Registering tool categories: ${options.enabledCategories?.join(', ') || 'all'}`);
            (0, tools_1.registerAllTools)(server, client, options.enabledCategories);
            // Show debugging info
            console.error(`Successfully registered tools`);
        }
        catch (error) {
            console.error(`Failed to register tools: ${error instanceof Error ? error.message : String(error)}`);
            throw error;
        }
        server.server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => { return { resources: [] }; });
        server.server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => { return { prompts: [] }; });
        // Start HTTP server if enabled
        if (options.transport === 'http' && options.httpOptions) {
            try {
                const { port, endpoint } = options.httpOptions;
                console.error(`Starting StreamableHTTP server on port ${port}, endpoint ${endpoint}`);
                const { close } = await (0, mcp_proxy_1.startHTTPStreamServer)({
                    port,
                    endpoint,
                    createServer: async () => {
                        // Return the already configured server
                        return server;
                    },
                    eventStore: new mcp_proxy_1.InMemoryEventStore(),
                });
                console.error(`HTTP StreamableHTTP server started successfully`);
            }
            catch (error) {
                console.error(`Failed to start StreamableHTTP server: ${error instanceof Error ? error.message : String(error)}`);
                // Continue with stdio even if HTTP server fails
            }
        }
        // Start SSE server if enabled
        if (options.transport === 'sse' && options.sseOptions) {
            try {
                const { port, endpoint, host } = options.sseOptions;
                console.error(`Starting SSE server on ${host}:${port}, endpoint ${endpoint}`);
                // Remove host parameter as it's not supported by startSSEServer
                const { close } = await (0, mcp_proxy_1.startSSEServer)({
                    port,
                    endpoint,
                    createServer: async () => {
                        // Return the already configured server
                        return server;
                    },
                });
                console.error(`SSE server started successfully`);
            }
            catch (error) {
                console.error(`Failed to start SSE server: ${error instanceof Error ? error.message : String(error)}`);
                // Continue with stdio even if SSE server fails
            }
        }
        // Start the server with stdio transport
        if (options.transport === 'stdio' || !options.transport) {
            try {
                const transport = new stdio_js_1.StdioServerTransport();
                server.connect(transport);
                console.error('Stdio MCP server transport connected');
            }
            catch (error) {
                console.error(`Failed to start stdio server: ${error instanceof Error ? error.message : String(error)}`);
                throw error;
            }
        }
        return server;
    }
    catch (error) {
        console.error(`Failed to initialize MCP server: ${error instanceof Error ? error.message : String(error)}`);
        throw error;
    }
}
//# sourceMappingURL=server.js.map