mcp-quickbase/dist/mcp/server.js

Work with Quickbase via Model Context Protocol

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createMcpServer = createMcpServer;
exports.registerMcpTools = registerMcpTools;
exports.createHttpTransport = createHttpTransport;
exports.handleMcpRequest = handleMcpRequest;
/**
 * MCP Server implementation using the official Model Context Protocol SDK
 */
const crypto_1 = require("crypto");
const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
const logger_1 = require("../utils/logger");
const tools_1 = require("../tools");
const validation_1 = require("../utils/validation");
const logger = (0, logger_1.createLogger)("mcp-server");
/**
 * Create and configure an MCP server instance
 */
function createMcpServer() {
    // Initialize the MCP server with our app info
    const server = new mcp_js_1.McpServer({
        name: "Quickbase MCP Server",
        version: "2.0.0",
    });
    logger.info("MCP Server created");
    return server;
}
/**
 * Register tools with an existing MCP server
 */
function registerMcpTools(server) {
    registerTools(server);
}
/**
 * Register all tools with the MCP server
 */
function registerTools(server) {
    const tools = tools_1.toolRegistry.getAllTools();
    tools.forEach((tool) => {
        // Create a Zod schema from our tool's parameter schema
        const schema = (0, validation_1.createMcpZodSchema)(tool.paramSchema);
        // Register the tool with the MCP server
        server.tool(tool.name, tool.description, schema, async (params) => {
            try {
                logger.info(`Executing MCP tool: ${tool.name}`);
                const apiResponse = await tool.execute(params);
                // Handle API response - only return the data if successful
                if (!apiResponse.success || apiResponse.error) {
                    const errorMessage = apiResponse.error?.message || "Tool execution failed";
                    logger.error(`Tool ${tool.name} failed`, {
                        error: apiResponse.error,
                    });
                    throw new Error(errorMessage);
                }
                // Ensure proper JSON formatting by using a standardized response structure
                return {
                    content: [
                        {
                            type: "text",
                            text: JSON.stringify(apiResponse.data, null, 2),
                        },
                    ],
                };
            }
            catch (error) {
                logger.error(`Error executing MCP tool ${tool.name}`, { error });
                throw error;
            }
        });
        logger.info(`Registered MCP tool: ${tool.name}`);
    });
    logger.info(`Registered ${tools.length} tools with MCP Server`);
}
/**
 * Create an HTTP transport for the MCP server
 */
function createHttpTransport() {
    // Create a new transport with proper session management
    // Following the TypeScript SDK examples for HTTP transport
    return new streamableHttp_js_1.StreamableHTTPServerTransport({
        sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
        enableJsonResponse: true,
    });
}
/**
 * Handle an MCP request via HTTP
 */
async function handleMcpRequest(server, transport, req, res) {
    try {
        logger.info("Handling MCP request");
        await transport.handleRequest(req, res, req.body);
    }
    catch (error) {
        logger.error("Error handling MCP request", { error });
        res.status(500).json({
            jsonrpc: "2.0",
            error: {
                code: -32000,
                message: error instanceof Error ? error.message : "Unknown error",
            },
            id: req.body?.id || null,
        });
    }
}
//# sourceMappingURL=server.js.map