@seliseblocks/mcp-server/dist/index.js

A Model Context Protocol (MCP) server for managing schemas in SELISE Blocks platform, built with TypeScript.

#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
import { createSchema, updateSchema, generateReactModule } from './services/index.js';
import { create_schema_tool, update_schema_tool, generate_react_module } from './tools/index.js';
class SchemaManagementServer {
    constructor() {
        this.server = new Server({
            name: 'schema-management-server',
            version: '0.1.0',
        }, {
            capabilities: {
                tools: {},
            },
        });
        this.blocksKey = process.env.BLOCKS_KEY;
        this.username = process.env.USERNAME;
        this.passkey = process.env.PASSKEY;
        this.apiBaseUrl = process.env.API_BASE_URL;
        this.setupToolHandlers();
    }
    setupToolHandlers() {
        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
            const tools = [
                create_schema_tool,
                update_schema_tool,
                generate_react_module
            ];
            return { tools };
        });
        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
            const { name, arguments: args } = request.params;
            try {
                const promptArgs = args ?? {};
                if (name === 'create_schema') {
                    const result = await createSchema(promptArgs);
                    return result;
                }
                else if (name === 'update_schema') {
                    const result = await updateSchema(promptArgs);
                    return result;
                }
                else if (name === 'generate_react_module') {
                    const result = await generateReactModule(promptArgs);
                    return result;
                }
                else {
                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
                }
            }
            catch (error) {
                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
                const errorStack = error instanceof Error ? error.stack : undefined;
                if (error instanceof McpError) {
                    throw error;
                }
                throw new McpError(ErrorCode.InternalError, `Error executing ${name}: ${errorMessage}`);
            }
        });
    }
    async run() {
        const transport = new StdioServerTransport();
        await this.server.connect(transport);
    }
    async close() {
        await this.server.close();
    }
}
const server = new SchemaManagementServer();
process.on('SIGINT', async () => {
    await server.close();
    process.exit(0);
});
process.on('uncaughtException', (error) => {
    process.exit(1);
});
process.on('unhandledRejection', (reason, promise) => {
    process.exit(1);
});
server.run().catch((error) => {
    process.exit(1);
});
//# sourceMappingURL=index.js.map