@andrebuzeli/git-mcp 10.0.4 → 10.0.6

package/dist/index.js

@@ -3,6 +3,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { ProviderManager } from './providers/providerManager.js';
+import { MCPError } from './utils/errors.js';
 import { IsomorphicGitAdapter } from './utils/gitAdapter.js';
 import { GitFilesTool } from './tools/gitFiles.js';
 import { GitWorkflowTool } from './tools/gitWorkflow.js';
@@ -28,9 +29,11 @@ import { GitFixTool } from './tools/gitFix.tool.js';
 import { GitIgnoreTool } from './tools/gitIgnore.js';
 import { GIT_PROMPTS } from './prompts/gitPrompts.js';
 import TOOLS_GUIDE from './resources/toolsGuide.js';
+import { Logger, logToolExecution, logSecurityEvent, logPerformanceMetric } from './utils/logger.js';
 async function main() {
     const providerManager = new ProviderManager();
     const gitAdapter = new IsomorphicGitAdapter(providerManager);
+    const logger = Logger.getInstance();
     // Skip validation on startup to prevent hanging (validation happens on first use)
     // Provider validation moved to lazy initialization
     // Register all 22 Git tools
@@ -64,17 +67,18 @@ async function main() {
     ];
     // 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)`);
-        console.error(`Registered ${GIT_PROMPTS.length} prompt(s)`);
+        logger.info(`Registered ${tools.length} Git tools`);
+        logger.info(`Registered ${resources.length} resource(s)`);
+        logger.info(`Registered ${GIT_PROMPTS.length} prompt(s)`);
     }
     // Create MCP Server with STDIO transport
     const server = new Server({
         name: '@andrebuzeli/git-mcp',
-        version: '10.0.1',
+        version: '10.0.6',
     });
     // Register tool list handler
     server.setRequestHandler(ListToolsRequestSchema, async () => {
+        logger.debug('Listing available tools');
         return {
             tools: tools.map(tool => ({
                 name: tool.name,
@@ -87,15 +91,42 @@ async function main() {
             })),
         };
     });
-    // Register tool execution handler
+    // Register tool execution handler with logging e segurança aprimorados
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const toolName = request.params.name;
         const tool = tools.find(t => t.name === toolName);
+        const startTime = Date.now();
         if (!tool) {
+            logSecurityEvent('TOOL_NOT_FOUND', { toolName });
             throw new Error(`Tool not found: ${toolName}`);
         }
         try {
-            const result = await tool.handle(request.params.arguments ?? {}, { providerManager, gitAdapter });
+            // Validar argumentos contra o schema da ferramenta
+            const args = request.params.arguments ?? {};
+            // Validação básica de segurança
+            if (typeof args !== 'object' || args === null) {
+                logSecurityEvent('INVALID_ARGUMENTS', { toolName, args });
+                throw new MCPError('VALIDATION_ERROR', 'Arguments must be an object');
+            }
+            // Validar projectPath se existir
+            if ('projectPath' in args) {
+                const projectPath = args.projectPath;
+                if (typeof projectPath !== 'string') {
+                    logSecurityEvent('INVALID_PROJECT_PATH_TYPE', { toolName, projectPath });
+                    throw new MCPError('VALIDATION_ERROR', 'projectPath must be a string');
+                }
+                if (!projectPath || projectPath.includes('..')) {
+                    logSecurityEvent('PATH_TRAVERSION_ATTEMPT', { toolName, projectPath });
+                    throw new MCPError('VALIDATION_ERROR', 'Invalid project path');
+                }
+            }
+            // Log da execução
+            logger.info(`Executing tool: ${toolName}`, { args }, toolName);
+            // Executar a ferramenta
+            const result = await tool.handle(args, { providerManager, gitAdapter });
+            const duration = Date.now() - startTime;
+            logPerformanceMetric(`tool_${toolName}`, duration, { success: true });
+            logToolExecution(toolName, args, result);
             return {
                 content: [
                     {
@@ -106,6 +137,9 @@ async function main() {
             };
         }
         catch (error) {
+            const duration = Date.now() - startTime;
+            logPerformanceMetric(`tool_${toolName}`, duration, { success: false, error: error.message });
+            logToolExecution(toolName, request.params.arguments ?? {}, undefined, error);
             return {
                 content: [
                     {
@@ -119,6 +153,7 @@ async function main() {
     });
     // Register resource list handler
     server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        logger.debug('Listing available resources');
         return {
             resources: resources.map(resource => ({
                 uri: resource.uri,
@@ -133,8 +168,10 @@ async function main() {
         const uri = request.params.uri;
         const resource = resources.find(r => r.uri === uri);
         if (!resource) {
+            logger.warn(`Resource not found: ${uri}`);
             throw new Error(`Resource not found: ${uri}`);
         }
+        logger.debug(`Reading resource: ${uri}`);
         return {
             contents: [
                 {
@@ -147,6 +184,7 @@ async function main() {
     });
     // Register prompt list handler
     server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        logger.debug('Listing available prompts');
         return {
             prompts: GIT_PROMPTS.map(prompt => ({
                 name: prompt.name,
@@ -160,8 +198,10 @@ async function main() {
         const promptName = request.params.name;
         const prompt = GIT_PROMPTS.find(p => p.name === promptName);
         if (!prompt) {
+            logger.warn(`Prompt not found: ${promptName}`);
             throw new Error(`Prompt not found: ${promptName}`);
         }
+        logger.debug(`Generating prompt: ${promptName}`);
         const result = await prompt.generate(request.params.arguments ?? {}, { providerManager, gitAdapter });
         return {
             description: result.description,
@@ -172,10 +212,10 @@ async function main() {
     await server.connect(transport);
     // Only log in debug mode
     if (process.env.DEBUG) {
-        console.error(`✅ git-mcp MCP server running via STDIO`);
-        console.error(`Tools: ${tools.length} registered`);
-        console.error(`Resources: ${resources.length} registered`);
-        console.error(`Prompts: ${GIT_PROMPTS.length} registered`);
+        logger.info(`✅ git-mcp MCP server running via STDIO`);
+        logger.info(`Tools: ${tools.length} registered`);
+        logger.info(`Resources: ${resources.length} registered`);
+        logger.info(`Prompts: ${GIT_PROMPTS.length} registered`);
     }
 }
 main().catch(err => {

package/dist/server-new.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server-new.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ProviderManager } from './providers/providerManager.js';
+import { MCPError } from './utils/errors.js';
+import { IsomorphicGitAdapter } from './utils/gitAdapter.js';
+import { GitFilesTool } from './tools/gitFiles.js';
+import { GitWorkflowTool } from './tools/gitWorkflow.js';
+import { GitBranchesTool } from './tools/gitBranches.js';
+import { GitIssuesTool } from './tools/gitIssues.js';
+import { GitPullsTool } from './tools/gitPulls.js';
+import { GitTagsTool } from './tools/gitTags.js';
+import { GitReleaseTool } from './tools/gitRelease.js';
+import { GitRemoteTool } from './tools/gitRemote.js';
+import { GitResetTool } from './tools/gitReset.js';
+import { GitStashTool } from './tools/gitStash.js';
+import { GitConfigTool } from './tools/gitConfig.js';
+import { GitMonitorTool } from './tools/gitMonitor.js';
+import { GitBackupTool } from './tools/gitBackup.js';
+import { GitArchiveTool } from './tools/gitArchive.js';
+import { GitSyncTool } from './tools/gitSync.js';
+import { GitPackagesTool } from './tools/gitPackages.js';
+import { GitAnalyticsTool } from './tools/gitAnalytics.js';
+import { GitUploadTool } from './tools/gitUpload.js';
+import { GitUpdateTool } from './tools/gitUpdate.js';
+import { GitHistoryTool } from './tools/gitHistory.js';
+import { GitFixTool } from './tools/gitFix.tool.js';
+import { GitIgnoreTool } from './tools/gitIgnore.js';
+import { GIT_PROMPTS } from './prompts/gitPrompts.js';
+import TOOLS_GUIDE from './resources/toolsGuide.js';
+import { Logger, logToolExecution, logSecurityEvent, logPerformanceMetric } from './utils/logger.js';
+async function main() {
+    const providerManager = new ProviderManager();
+    const gitAdapter = new IsomorphicGitAdapter(providerManager);
+    const logger = Logger.getInstance();
+    // Skip validation on startup to prevent hanging (validation happens on first use)
+    // Provider validation moved to lazy initialization
+    // Register all 22 Git tools
+    const tools = [
+        new GitWorkflowTool(),
+        new GitFilesTool(),
+        new GitBranchesTool(),
+        new GitIssuesTool(),
+        new GitPullsTool(),
+        new GitTagsTool(),
+        new GitReleaseTool(),
+        new GitRemoteTool(),
+        new GitResetTool(),
+        new GitStashTool(),
+        new GitConfigTool(),
+        new GitMonitorTool(),
+        new GitBackupTool(),
+        new GitArchiveTool(),
+        new GitSyncTool(),
+        new GitPackagesTool(),
+        new GitAnalyticsTool(),
+        new GitUploadTool(),
+        new GitUpdateTool(),
+        new GitHistoryTool(),
+        new GitFixTool(),
+        new GitIgnoreTool(),
+    ];
+    // Register resources
+    const resources = [
+        TOOLS_GUIDE
+    ];
+    // Silent mode for MCP clients - only log to stderr in debug mode
+    if (process.env.DEBUG) {
+        logger.info(`Registered ${tools.length} Git tools`);
+        logger.info(`Registered ${resources.length} resource(s)`);
+        logger.info(`Registered ${GIT_PROMPTS.length} prompt(s)`);
+    }
+    // Create MCP Server with STDIO transport
+    const server = new Server({
+        name: '@andrebuzeli/git-mcp',
+        version: '10.0.4',
+    });
+    // Register tool list handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        logger.debug('Listing available tools');
+        return {
+            tools: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema || {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: true,
+                },
+            })),
+        };
+    });
+    // Register tool execution handler with logging e segurança aprimorados
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolName = request.params.name;
+        const tool = tools.find(t => t.name === toolName);
+        const startTime = Date.now();
+        if (!tool) {
+            logSecurityEvent('TOOL_NOT_FOUND', { toolName });
+            throw new Error(`Tool not found: ${toolName}`);
+        }
+        try {
+            // Validar argumentos contra o schema da ferramenta
+            const args = request.params.arguments ?? {};
+            // Validação básica de segurança
+            if (typeof args !== 'object' || args === null) {
+                logSecurityEvent('INVALID_ARGUMENTS', { toolName, args });
+                throw new MCPError('VALIDATION_ERROR', 'Arguments must be an object');
+            }
+            // Validar projectPath se existir
+            if ('projectPath' in args) {
+                const projectPath = args.projectPath;
+                if (typeof projectPath !== 'string') {
+                    logSecurityEvent('INVALID_PROJECT_PATH_TYPE', { toolName, projectPath });
+                    throw new MCPError('VALIDATION_ERROR', 'projectPath must be a string');
+                }
+                if (!projectPath || projectPath.includes('..')) {
+                    logSecurityEvent('PATH_TRAVERSION_ATTEMPT', { toolName, projectPath });
+                    throw new MCPError('VALIDATION_ERROR', 'Invalid project path');
+                }
+            }
+            // Log da execução
+            logger.info(`Executing tool: ${toolName}`, { args }, toolName);
+            // Executar a ferramenta
+            const result = await tool.handle(args, { providerManager, gitAdapter });
+            const duration = Date.now() - startTime;
+            logPerformanceMetric(`tool_${toolName}`, duration, { success: true });
+            logToolExecution(toolName, args, result);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            logPerformanceMetric(`tool_${toolName}`, duration, { success: false, error: error.message });
+            logToolExecution(toolName, request.params.arguments ?? {}, undefined, error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error.message || String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Register resource list handler
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        logger.debug('Listing available resources');
+        return {
+            resources: resources.map(resource => ({
+                uri: resource.uri,
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+            })),
+        };
+    });
+    // Register resource read handler
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri;
+        const resource = resources.find(r => r.uri === uri);
+        if (!resource) {
+            logger.warn(`Resource not found: ${uri}`);
+            throw new Error(`Resource not found: ${uri}`);
+        }
+        logger.debug(`Reading resource: ${uri}`);
+        return {
+            contents: [
+                {
+                    uri: resource.uri,
+                    mimeType: resource.mimeType,
+                    text: resource.content,
+                },
+            ],
+        };
+    });
+    // Register prompt list handler
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        logger.debug('Listing available prompts');
+        return {
+            prompts: GIT_PROMPTS.map(prompt => ({
+                name: prompt.name,
+                description: prompt.description,
+                arguments: prompt.arguments,
+            })),
+        };
+    });
+    // Register prompt get handler
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const promptName = request.params.name;
+        const prompt = GIT_PROMPTS.find(p => p.name === promptName);
+        if (!prompt) {
+            logger.warn(`Prompt not found: ${promptName}`);
+            throw new Error(`Prompt not found: ${promptName}`);
+        }
+        logger.debug(`Generating prompt: ${promptName}`);
+        const result = await prompt.generate(request.params.arguments ?? {}, { providerManager, gitAdapter });
+        return {
+            description: result.description,
+            messages: result.messages,
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Only log in debug mode
+    if (process.env.DEBUG) {
+        logger.info(`✅ git-mcp MCP server running via STDIO`);
+        logger.info(`Tools: ${tools.length} registered`);
+        logger.info(`Resources: ${resources.length} registered`);
+        logger.info(`Prompts: ${GIT_PROMPTS.length} registered`);
+    }
+}
+main().catch(err => {
+    console.error('❌ Failed to start git-mcp:', err);
+    process.exit(1);
+});

package/dist/tools/gitFiles-new.d.ts

@@ -0,0 +1,89 @@
+import { Tool } from '../types.js';
+export declare class GitFilesTool implements Tool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            filePath: {
+                type: string;
+                description: string;
+            };
+            directoryPath: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            comment: {
+                type: string;
+                description: string;
+            };
+            patterns: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            searchText: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            searchPath: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    handle(params: Record<string, any>): Promise<any>;
+    /**
+     * Lê arquivo com cache
+     */
+    private handleRead;
+    /**
+     * Lista diretório com cache
+     */
+    private handleList;
+    /**
+     * Cria arquivo com validação de segurança
+     */
+    private handleCreate;
+    /**
+     * Atualiza arquivo com validação de segurança
+     */
+    private handleUpdate;
+    /**
+     * Deleta arquivo com validação de segurança
+     */
+    private handleDelete;
+    /**
+     * Busca texto em arquivos com cache
+     */
+    private handleSearch;
+    /**
+     * Busca recursivamente em diretórios
+     */
+    private searchInDirectory;
+    /**
+     * Verifica se arquivo é buscável
+     */
+    private isSearchableFile;
+}