repoburg 1.3.162 → 1.3.165

package/backend/package.json

@@ -12,6 +12,8 @@
     "start:dev": "mkdir -p ../.repoburg/logs && NODE_ENV=production script -q ../.repoburg/logs/backend.log nest start --watch",
     "start:debug": "NODE_ENV=production nest start --debug --watch",
     "start:prod": "NODE_ENV=production node dist/main",
+    "mcp-server": "ts-node -r tsconfig-paths/register src/mcp-server/mcp-server.bootstrap.ts",
+    "mcp-server:prod": "NODE_ENV=production node dist/mcp-server/mcp-server.bootstrap.js",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
     "test": "NODE_ENV=development NODE_OPTIONS=--experimental-vm-modules jest --bail",
     "test:watch": "jest --watch",

package/daemon/dist/index.js

@@ -12,6 +12,7 @@ const serviceManager_1 = require("./serviceManager");
 const services_1 = __importDefault(require("./api/services"));
 const auth_1 = __importDefault(require("./api/auth"));
 const registry_1 = __importDefault(require("./api/registry"));
+const mcp_gateway_1 = require("./mcp-gateway");
 const PORT = 9998;
 async function main() {
     await serviceManager_1.serviceManager.connect();
@@ -28,6 +29,20 @@ async function main() {
     app.use('/services', services_1.default);
     app.use('/auth', (0, auth_1.default)(wss));
     app.use('/registry', registry_1.default);
+    // MCP Gateway — single MCP entry point managing all instances (streamableHttp).
+    app.post('/mcp', (req, res) => mcp_gateway_1.mcpGateway.handleExpressRequest(req, res));
+    app.get('/mcp', (req, res) => mcp_gateway_1.mcpGateway.handleExpressRequest(req, res));
+    app.delete('/mcp', (req, res) => mcp_gateway_1.mcpGateway.handleExpressRequest(req, res));
+    // MCP Gateway info endpoint for the management UI.
+    app.get('/mcp-gateway-info', async (req, res) => {
+        try {
+            const info = await mcp_gateway_1.mcpGateway.getGatewayInfo();
+            res.json(info);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.get('/health', (req, res) => {
         res.status(200).json({ status: 'ok' });
     });
@@ -38,6 +53,16 @@ async function main() {
     });
     server.listen(PORT, () => {
         console.log(`Repoburg Platform Daemon listening on http://localhost:${PORT}`);
+        console.log(`MCP Gateway available at http://localhost:${PORT}/mcp`);
+    });
+    // Clean up MCP gateway sessions on shutdown.
+    process.on('SIGINT', async () => {
+        await mcp_gateway_1.mcpGateway.closeAllSessions();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await mcp_gateway_1.mcpGateway.closeAllSessions();
+        process.exit(0);
     });
 }
 main().catch(err => {

package/daemon/dist/mcp-gateway.js

@@ -0,0 +1,401 @@
+"use strict";
+/**
+ * MCP Gateway — a single MCP server entry point hosted in the daemon that
+ * manages **all** Repoburg instances.
+ *
+ * MCP clients (ChatGPT tunnel, Claude Desktop) connect once to
+ * `http://localhost:9998/mcp`. Each `manage_*` tool call includes an
+ * `instance_name` parameter; the gateway looks up the instance's backend port
+ * from `stateManager` and proxies the call to that instance's
+ * `POST /mcp-internal/execute-tool` endpoint.
+ *
+ * The gateway also exposes daemon-level tools (`list_instances`,
+ * `start_instance`, `stop_instance`) that operate on the daemon's own PM2
+ * process registry — no instance routing needed.
+ *
+ * Tool definitions for `manage_*` are fetched once from any running instance's
+ * `GET /mcp-internal/tools` endpoint, augmented with an `instance_name`
+ * required parameter, and cached.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpGateway = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const crypto_1 = require("crypto");
+const stateManager_1 = require("./stateManager");
+const serviceManager_1 = require("./serviceManager");
+/**
+ * Daemon-level tool names exposed by the gateway (always available, no
+ * instance routing needed).
+ */
+const DAEMON_TOOL_NAMES = ['list_instances', 'start_instance', 'stop_instance'];
+// ---------------------------------------------------------------------------
+// Gateway
+// ---------------------------------------------------------------------------
+const GATEWAY_INFO = { name: 'repoburg-mcp-gateway', version: '1.0.0' };
+const INSTANCE_NAME_PARAM = {
+    type: 'string',
+    description: 'Name of the Repoburg instance to manage. Use the list_instances tool to see available instances.',
+};
+/** Extracts an error message from an unknown catch value. */
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+class McpGateway {
+    constructor() {
+        this.sessions = new Map();
+        this.toolCache = null;
+        this.isRefreshing = false;
+    }
+    // -------------------------------------------------------------------------
+    // Express route handler — mounted at app.post/get/delete('/mcp', ...)
+    // -------------------------------------------------------------------------
+    /**
+     * Express-compatible handler for the `/mcp` route. Manages stateful
+     * streamableHttp sessions: a new transport + Server is created on the
+     * `initialize` request and reused for subsequent requests on that session.
+     */
+    async handleExpressRequest(req, res) {
+        try {
+            if (req.method === 'POST') {
+                const body = req.body;
+                const sessionId = req.headers['mcp-session-id'];
+                const existing = sessionId ? this.sessions.get(sessionId) : undefined;
+                if (existing) {
+                    await existing.handleRequest(req, res, body);
+                    return;
+                }
+                if (body && (0, types_js_1.isInitializeRequest)(body)) {
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+                        onsessioninitialized: (sid) => {
+                            this.sessions.set(sid, transport);
+                        },
+                        onsessionclosed: (sid) => {
+                            this.sessions.delete(sid);
+                        },
+                    });
+                    transport.onclose = () => {
+                        const sid = transport.sessionId;
+                        if (sid)
+                            this.sessions.delete(sid);
+                    };
+                    const server = this.createMcpServerInstance();
+                    await server.connect(transport);
+                    await transport.handleRequest(req, res, body);
+                    return;
+                }
+                // No valid session — reject.
+                res.status(400).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Bad Request: no valid session ID provided',
+                    },
+                    id: null,
+                });
+                return;
+            }
+            if (req.method === 'GET' || req.method === 'DELETE') {
+                const sessionId = req.headers['mcp-session-id'];
+                const transport = sessionId ? this.sessions.get(sessionId) : undefined;
+                if (!transport) {
+                    res.status(400).send('Invalid or missing session ID');
+                    return;
+                }
+                await transport.handleRequest(req, res);
+                return;
+            }
+            res.status(405).send('Method not allowed');
+        }
+        catch (err) {
+            console.error(`[McpGateway] Error handling MCP request: ${errorMessage(err)}`);
+            if (!res.headersSent) {
+                res.status(500).send('Internal server error');
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // MCP Server factory
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a fresh MCP `Server` wired with ListTools + CallTool handlers.
+     * One Server per client session.
+     */
+    createMcpServerInstance() {
+        const server = new index_js_1.Server(GATEWAY_INFO, { capabilities: { tools: {} } });
+        server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            // Best-effort cache refresh (non-blocking if already refreshing).
+            await this.refreshToolCache();
+            const daemonTools = this.buildDaemonTools();
+            const manageTools = this.toolCache ?? [];
+            return { tools: [...daemonTools, ...manageTools] };
+        });
+        server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const toolArgs = args ?? {};
+            // Daemon-level tools
+            let result;
+            if (name === 'list_instances') {
+                result = this.handleListInstances();
+            }
+            else if (name === 'start_instance') {
+                result = await this.handleStartInstance(toolArgs);
+            }
+            else if (name === 'stop_instance') {
+                result = await this.handleStopInstance(toolArgs);
+            }
+            else {
+                // manage_* tools — proxy to the target instance
+                result = await this.handleManageTool(name, toolArgs);
+            }
+            // Cast to the SDK's expected ServerResult union — structurally compatible
+            // but the Zod-inferred type is too narrow for direct assignment.
+            return result;
+        });
+        return server;
+    }
+    // -------------------------------------------------------------------------
+    // Tool cache management
+    // -------------------------------------------------------------------------
+    /**
+     * Fetches tool definitions from a running instance's
+     * `GET /mcp-internal/tools` endpoint, augments each with `instance_name`,
+     * and caches the result. Safe to call repeatedly — skips if already
+     * refreshing or cache is already populated.
+     */
+    async refreshToolCache() {
+        if (this.isRefreshing || this.toolCache)
+            return;
+        this.isRefreshing = true;
+        try {
+            const runningInstance = this.findRunningInstance();
+            if (!runningInstance) {
+                // No instance running — cache stays null; daemon tools still available.
+                return;
+            }
+            const resp = await fetch(`http://localhost:${runningInstance.port}/mcp-internal/tools`);
+            if (!resp.ok) {
+                console.warn(`[McpGateway] Failed to fetch tools from instance '${runningInstance.name}' (${resp.status}).`);
+                return;
+            }
+            const rawTools = (await resp.json());
+            this.toolCache = rawTools.map((raw) => this.augmentWithInstanceName({
+                name: raw.tool_name,
+                description: raw.description,
+                inputSchema: raw.input_schema,
+            }));
+            console.log(`[McpGateway] Cached ${this.toolCache.length} manage_* tools from instance '${runningInstance.name}'.`);
+        }
+        catch (err) {
+            console.warn(`[McpGateway] Could not refresh tool cache: ${errorMessage(err)}`);
+        }
+        finally {
+            this.isRefreshing = false;
+        }
+    }
+    /**
+     * Forces a cache refresh (called after an instance starts). Clears the cache
+     * first so the next ListTools re-fetches.
+     */
+    invalidateToolCache() {
+        this.toolCache = null;
+    }
+    /**
+     * Adds `instance_name` as a required string parameter to a tool definition.
+     */
+    augmentWithInstanceName(tool) {
+        const properties = { ...tool.inputSchema.properties, instance_name: INSTANCE_NAME_PARAM };
+        const required = [
+            ...(tool.inputSchema.required ?? []),
+            'instance_name',
+        ];
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: 'object',
+                properties,
+                required,
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Daemon-level tool handlers
+    // -------------------------------------------------------------------------
+    buildDaemonTools() {
+        return [
+            {
+                name: 'list_instances',
+                description: 'List all registered Repoburg instances with their name, project path, port, and running status.',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'start_instance',
+                description: 'Start a Repoburg instance for a project path. The instance runs as a PM2-managed backend process with its own SQLite database.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project directory.',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Optional custom instance name (defaults to the directory basename).',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'stop_instance',
+                description: 'Stop a running Repoburg instance by name.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the instance to stop.',
+                        },
+                    },
+                    required: ['name'],
+                },
+            },
+        ];
+    }
+    handleListInstances() {
+        const services = stateManager_1.stateManager.getServices();
+        if (services.length === 0) {
+            return this.textResult('No Repoburg instances registered.');
+        }
+        const lines = services.map((s) => `- ${s.name}: ${s.status} (port ${s.port}, path: ${s.path})`);
+        return this.textResult(`Repoburg instances (${services.length}):\n${lines.join('\n')}`);
+    }
+    async handleStartInstance(args) {
+        const projectPath = args.path;
+        if (typeof projectPath !== 'string') {
+            return this.errorResult('Missing required parameter: path');
+        }
+        const name = typeof args.name === 'string' ? args.name : undefined;
+        try {
+            const service = await serviceManager_1.serviceManager.start(projectPath, name);
+            this.invalidateToolCache();
+            return this.textResult(`Instance '${service.name}' started on port ${service.port} (path: ${service.path}).`);
+        }
+        catch (err) {
+            return this.errorResult(`Failed to start instance: ${errorMessage(err)}`);
+        }
+    }
+    async handleStopInstance(args) {
+        const name = args.name;
+        if (typeof name !== 'string') {
+            return this.errorResult('Missing required parameter: name');
+        }
+        try {
+            await serviceManager_1.serviceManager.stop(name);
+            return this.textResult(`Instance '${name}' stopped.`);
+        }
+        catch (err) {
+            return this.errorResult(`Failed to stop instance: ${errorMessage(err)}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // manage_* tool proxy — routes to the target instance's backend
+    // -------------------------------------------------------------------------
+    async handleManageTool(toolName, args) {
+        const instanceName = args.instance_name;
+        if (typeof instanceName !== 'string') {
+            return this.errorResult(`Missing required parameter: instance_name. Use the list_instances tool to see available instances.`);
+        }
+        const service = stateManager_1.stateManager.getService(instanceName);
+        if (!service) {
+            return this.errorResult(`Instance '${instanceName}' not found. Use the list_instances tool to see available instances.`);
+        }
+        if (service.status !== 'running') {
+            return this.errorResult(`Instance '${instanceName}' is not running (status: ${service.status}). Use the start_instance tool to start it.`);
+        }
+        // Strip instance_name — the backend doesn't know about it.
+        const { instance_name: _unused, ...toolArgs } = args;
+        try {
+            const resp = await fetch(`http://localhost:${service.port}/mcp-internal/execute-tool`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    tool_name: toolName,
+                    arguments: toolArgs,
+                }),
+            });
+            if (!resp.ok) {
+                return this.errorResult(`Instance '${instanceName}' returned HTTP ${resp.status} for tool '${toolName}'.`);
+            }
+            const result = (await resp.json());
+            return this.toToolResult(result);
+        }
+        catch (err) {
+            return this.errorResult(`Failed to reach instance '${instanceName}': ${errorMessage(err)}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Gateway info (for the management UI)
+    // -------------------------------------------------------------------------
+    /**
+     * Returns a descriptor of the gateway for the management UI: the gateway
+     * URL, available instances, tool list, and a ready-to-paste client config.
+     */
+    async getGatewayInfo() {
+        await this.refreshToolCache();
+        const daemonTools = this.buildDaemonTools();
+        const manageTools = this.toolCache ?? [];
+        const instances = stateManager_1.stateManager.getServices().map((s) => ({
+            name: s.name,
+            path: s.path,
+            port: s.port,
+            status: s.status,
+        }));
+        return {
+            server_name: 'repoburg-gateway',
+            description: 'Single MCP entry point managing all Repoburg instances. Each manage_* tool requires an instance_name parameter to route to the correct instance.',
+            url: `http://localhost:9998/mcp`,
+            instances,
+            tools: [...daemonTools, ...manageTools],
+            client_config: JSON.stringify({ repoburg: { url: 'http://localhost:9998/mcp' } }, null, 2),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Session cleanup
+    // -------------------------------------------------------------------------
+    async closeAllSessions() {
+        await Promise.all(Array.from(this.sessions.values()).map((t) => t.close()));
+        this.sessions.clear();
+    }
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    findRunningInstance() {
+        return stateManager_1.stateManager
+            .getServices()
+            .find((s) => s.status === 'running');
+    }
+    /**
+     * Maps an `ActionExecutionResult` (returned by the backend's
+     * `/mcp-internal/execute-tool`) to an MCP `CallToolResult`.
+     */
+    toToolResult(result) {
+        const output = result.execution_log?.output || '';
+        const error = result.execution_log?.error_message || result.error_message;
+        const text = error ? `${output}\n\nError: ${error}`.trim() : output;
+        return {
+            content: [{ type: 'text', text }],
+            isError: result.status === 'FAILURE' ? true : undefined,
+        };
+    }
+    textResult(text) {
+        return { content: [{ type: 'text', text }] };
+    }
+    errorResult(message) {
+        return { content: [{ type: 'text', text: message }], isError: true };
+    }
+}
+exports.mcpGateway = new McpGateway();