agent-files-watcher/dist/server.js

A comprehensive CLI tool and MCP server for synchronizing AI agent documentation using a partials-to-templates architecture

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.startServer = startServer;
const express_1 = __importDefault(require("express"));
const json_rpc_2_0_1 = require("json-rpc-2.0");
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 tools_1 = require("./core/tools");
// --- HTTP Server Implementation ---
function startHttpServer() {
    const app = (0, express_1.default)();
    app.use(express_1.default.json());
    const PORT = process.env.PORT || 3000;
    const rpcServer = new json_rpc_2_0_1.JSONRPCServer();
    for (const schema of tools_1.toolSchemas) {
        const toolName = schema.name;
        if (tools_1.toolImplementations[toolName]) {
            rpcServer.addMethod(toolName, tools_1.toolImplementations[toolName]);
        }
    }
    rpcServer.addMethod('mcp.discover', () => tools_1.toolSchemas);
    app.post('/mcp', (req, res) => {
        const jsonRPCRequest = req.body;
        rpcServer.receive(jsonRPCRequest).then((jsonRPCResponse) => {
            if (jsonRPCResponse) {
                res.json(jsonRPCResponse);
            }
            else {
                res.sendStatus(204);
            }
        });
    });
    app.listen(PORT, () => {
        console.error(`MCP HTTP Server listening on port ${PORT}`);
    });
}
// --- Stdio Server Implementation ---
async function startStdioServer() {
    console.error('Starting MCP server in stdio mode...');
    // Create MCP server using official SDK
    const server = new index_js_1.Server({
        name: 'agent-context',
        version: '1.0.0',
    }, {
        capabilities: {
            tools: {},
        },
    });
    // Register tools/call handler (single handler for all tools)
    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
        const toolName = request.params.name;
        const args = request.params.arguments || {};
        console.error(`Executing tool: ${toolName}`, request.params);
        if (!toolName || !tools_1.toolImplementations[toolName]) {
            throw new Error(`Tool '${toolName}' not found`);
        }
        try {
            const result = await tools_1.toolImplementations[toolName](args);
            return {
                content: [
                    {
                        type: 'text',
                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
                    },
                ],
                isError: false,
            };
        }
        catch (error) {
            console.error(`Error executing tool '${toolName}':`, error);
            return {
                content: [
                    {
                        type: 'text',
                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
                    },
                ],
                isError: true,
            };
        }
    });
    // Register tools/list handler
    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
        console.error('Handling tools/list request');
        return {
            tools: tools_1.toolSchemas.map(schema => ({
                name: schema.name,
                description: schema.description,
                inputSchema: schema.inputSchema,
            })),
        };
    });
    // Connect to stdio transport
    const transport = new stdio_js_1.StdioServerTransport();
    await server.connect(transport);
    console.error('MCP server connected and listening for requests...');
}
// --- Main Export ---
async function startServer(options) {
    if (options.stdio) {
        await startStdioServer();
    }
    else {
        startHttpServer();
    }
}