repoburg 1.3.161 → 1.3.163

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,381 @@
+"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");
+// ---------------------------------------------------------------------------
+// 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.',
+};
+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: ${err.message}`);
+            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
+            if (name === 'list_instances') {
+                return this.handleListInstances();
+            }
+            if (name === 'start_instance') {
+                return this.handleStartInstance(toolArgs);
+            }
+            if (name === 'stop_instance') {
+                return this.handleStopInstance(toolArgs);
+            }
+            // manage_* tools — proxy to the target instance
+            return this.handleManageTool(name, toolArgs);
+        });
+        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 tools = (await resp.json());
+            this.toolCache = tools.map((tool) => this.augmentWithInstanceName(tool));
+            console.log(`[McpGateway] Cached ${this.toolCache.length} manage_* tools from instance '${runningInstance.name}'.`);
+        }
+        catch (err) {
+            console.warn(`[McpGateway] Could not refresh tool cache: ${err.message}`);
+        }
+        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 (!projectPath) {
+            return this.errorResult('Missing required parameter: path');
+        }
+        try {
+            const service = await serviceManager_1.serviceManager.start(projectPath, args.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: ${err.message}`);
+        }
+    }
+    async handleStopInstance(args) {
+        const name = args.name;
+        if (!name) {
+            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: ${err.message}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // manage_* tool proxy — routes to the target instance's backend
+    // -------------------------------------------------------------------------
+    async handleManageTool(toolName, args) {
+        const instanceName = args.instance_name;
+        if (!instanceName) {
+            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}': ${err.message}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // 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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repoburg",
-  "version": "1.3.161",
+  "version": "1.3.163",
   "description": "A local AI-powered software developer assistant that runs on your own machine.",
   "author": "Celal Ertug",
   "license": "SEE LICENSE IN LICENSE",

package/backend/.env

@@ -1,27 +0,0 @@
-#react project
-#REPOBURG_PROJECT_PATH='/Users/celalertug/WebstormProjects/ttt1234'
-#REPOBURG_PROJECT_PATH=/Users/celalertug/Desktop/tmp/repoburg-preview-boilerplate-main
-
-#modern football
-#REPOBURG_PROJECT_PATH=/Users/celalertug/WebstormProjects/fm1
-
-# handbag
-# REPOBURG_PROJECT_PATH=/Users/celalertug/tmp/handbag-main
-
-
-# webcoder
-# REPOBURG_PROJECT_PATH=/Users/celalertug/github/webcoder
-
-REPOBURG_PROJECT_PATH=/Users/celalertug/tmp/randomproject
-# REPOBURG_PROJECT_PATH=/Users/celalertug/repoburg-projects/rp42
-# REPOBURG_PROJECT_PATH=/Users/celalertug/repoburg-projects/simple-erp
-
-# appdev
-# REPOBURG_PROJECT_PATH=/Users/celalertug/everest/tmpappdev2
-# REPOBURG_PROJECT_PATH=/Users/celalertug/everest/tmpappdev2-session2
-
-# REPOBURG_PROJECT_PATH=/Users/celalertug/repoburg-projects/isgorusmetakip
-# REPOBURG_PROJECT_PATH=/Users/celalertug/repoburg-projects/rp36 # data
-    
-
-QUICK_EDIT_LOG_DIR=/Users/celalertug/.repoburg/quick-edit-logs

package/backend/section-modified.txt

@@ -1 +0,0 @@
-current

package/daemon/dist/api/system.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = require("express");
-const child_process_1 = require("child_process");
-const checkAuth_1 = require("../middleware/checkAuth");
-const router = (0, express_1.Router)();
-router.post('/update', checkAuth_1.checkAuth, (req, res) => {
-    try {
-        console.log('[DAEMON] Received request to start update process.');
-        // Using `spawn` with `detached: true` and `stdio: 'ignore'` allows the parent (daemon)
-        // to exit while the child (update script) continues running. `unref()` is crucial.
-        const child = (0, child_process_1.spawn)('repoburg', ['update'], {
-            detached: true,
-            stdio: 'ignore',
-            shell: true,
-        });
-        child.unref();
-        res.status(202).json({ message: 'Update process initiated. The daemon and services will restart shortly.' });
-    }
-    catch (error) {
-        console.error('Failed to spawn update process:', error);
-        res.status(500).json({ error: 'Failed to start update process.' });
-    }
-});
-exports.default = router;