@andrebuzeli/git-mcp 5.8.0 → 5.8.2

package/dist/index.js

@@ -1,10 +1,43 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const server_1 = require("./server");
+const readline = __importStar(require("readline"));
 const providerManager_1 = require("./providers/providerManager");
 const config_1 = require("./config");
 const gitFiles_1 = require("./tools/gitFiles");
@@ -65,63 +98,147 @@ async function main() {
     const resources = [
         toolsGuide_1.default
     ];
+    const toolRegistry = new Map();
+    for (const t of tools)
+        toolRegistry.set(t.name, t);
+    const resourceRegistry = new Map();
+    for (const r of resources)
+        resourceRegistry.set(r.uri, r);
     // Silent mode for MCP clients - only log to stderr in debug mode
     if (process.env.DEBUG) {
         console.error(`Registered ${tools.length} Git tools`);
         console.error(`Registered ${resources.length} resource(s)`);
     }
-    const app = (0, server_1.createServer)({ tools, providerManager, resources });
-    // Try default port, then find available port if occupied
-    let port = parseInt(process.env.PORT || '3210');
-    const startServer = (attemptPort) => {
-        return new Promise((resolve, reject) => {
-            const server = app.listen(attemptPort, () => {
-                // Send success message to stderr (MCP clients expect JSON on stdout)
-                if (process.env.DEBUG) {
-                    console.error(`✅ git-mcp server ready on http://localhost:${attemptPort}`);
-                    console.error(`Tools: ${tools.map(t => t.name).join(', ')}`);
-                    console.error(`Resources: ${resources.map(r => r.uri).join(', ')}`);
-                }
-                resolve(server);
-            });
-            server.on('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    // Port in use, try next port
-                    server.close();
-                    resolve(null);
-                }
-                else {
-                    reject(err);
+    // MCP JSON-RPC over stdio
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+    rl.on('line', async (line) => {
+        let requestId = null;
+        try {
+            const request = JSON.parse(line);
+            const { jsonrpc, id, method, params } = request;
+            requestId = id;
+            let response = { jsonrpc: '2.0', id };
+            switch (method) {
+                case 'initialize':
+                    response.result = {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            tools: {},
+                            resources: {}
+                        },
+                        serverInfo: {
+                            name: 'git-mcp',
+                            version: '5.8.1'
+                        }
+                    };
+                    break;
+                case 'tools/list':
+                    response.result = {
+                        tools: tools.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: {
+                                type: 'object',
+                                properties: {},
+                                required: []
+                            }
+                        }))
+                    };
+                    break;
+                case 'tools/call':
+                    const toolName = params?.name;
+                    const tool = toolRegistry.get(toolName);
+                    if (!tool) {
+                        response.error = {
+                            code: -32601,
+                            message: `Tool not found: ${toolName}`
+                        };
+                    }
+                    else {
+                        try {
+                            const result = await tool.handle(params?.arguments ?? {}, { providerManager });
+                            response.result = {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: JSON.stringify(result, null, 2)
+                                    }
+                                ]
+                            };
+                        }
+                        catch (err) {
+                            response.error = {
+                                code: -32603,
+                                message: err.message || String(err)
+                            };
+                        }
+                    }
+                    break;
+                case 'resources/list':
+                    response.result = {
+                        resources: Array.from(resourceRegistry.values()).map(r => ({
+                            uri: r.uri,
+                            name: r.name,
+                            description: r.description,
+                            mimeType: r.mimeType
+                        }))
+                    };
+                    break;
+                case 'resources/read':
+                    const uri = params?.uri;
+                    const resource = resourceRegistry.get(uri);
+                    if (!resource) {
+                        response.error = {
+                            code: -32601,
+                            message: `Resource not found: ${uri}`
+                        };
+                    }
+                    else {
+                        response.result = {
+                            contents: [
+                                {
+                                    uri: resource.uri,
+                                    mimeType: resource.mimeType,
+                                    text: resource.content
+                                }
+                            ]
+                        };
+                    }
+                    break;
+                default:
+                    response.error = {
+                        code: -32601,
+                        message: `Method not found: ${method}`
+                    };
+            }
+            console.log(JSON.stringify(response));
+        }
+        catch (err) {
+            // Always send a proper JSON-RPC error response, even for parse errors
+            const errorResponse = {
+                jsonrpc: '2.0',
+                id: requestId,
+                error: {
+                    code: -32700,
+                    message: `Parse error: ${err.message || String(err)}`
                 }
-            });
-        });
-    };
-    // Try to start server on available port
-    let server = null;
-    const maxAttempts = 10;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        const tryPort = port + attempt;
-        server = await startServer(tryPort);
-        if (server) {
-            port = tryPort;
-            break;
+            };
+            console.log(JSON.stringify(errorResponse));
+            if (process.env.DEBUG) {
+                console.error('Error processing request:', err);
+            }
         }
-    }
-    if (!server) {
-        console.error(`❌ Failed to find available port after ${maxAttempts} attempts`);
-        process.exit(1);
-    }
-    server.on('error', (err) => {
-        console.error('❌ Server error:', err);
-        process.exit(1);
     });
     // Keep process alive
     process.on('SIGINT', () => {
-        console.log('\n👋 Shutting down server...');
-        server.close(() => {
-            console.log('Server closed');
-            process.exit(0);
-        });
+        if (process.env.DEBUG) {
+            console.error('\n👋 Shutting down server...');
+        }
+        process.exit(0);
     });
 }
 main().catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "5.8.0",
+  "version": "5.8.2",
   "description": "Professional MCP server for Git operations - automatic dual-provider execution (GitHub + Gitea), no provider parameter needed, organized responses by provider, enhanced security and safety features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",