@andrebuzeli/git-mcp 10.0.4 → 10.0.6

package/dist/utils/validation.js

@@ -0,0 +1,270 @@
+/**
+ * Sistema de validação e tratamento de erros aprimorado para Git-MCP
+ * Fornece validação robusta de parâmetros e mensagens de erro detalhadas
+ */
+import { MCPError } from './errors.js';
+import path from 'path';
+/**
+ * Tipos de validação disponíveis
+ */
+export var ValidationType;
+(function (ValidationType) {
+    ValidationType["REQUIRED"] = "required";
+    ValidationType["STRING"] = "string";
+    ValidationType["NUMBER"] = "number";
+    ValidationType["BOOLEAN"] = "boolean";
+    ValidationType["ARRAY"] = "array";
+    ValidationType["OBJECT"] = "object";
+    ValidationType["PATH"] = "path";
+    ValidationType["URL"] = "url";
+    ValidationType["EMAIL"] = "email";
+    ValidationType["ENUM"] = "enum";
+    ValidationType["PATTERN"] = "pattern";
+    ValidationType["RANGE"] = "range";
+    ValidationType["LENGTH"] = "length";
+})(ValidationType || (ValidationType = {}));
+/**
+ * Validador robusto de parâmetros
+ */
+export class ParameterValidator {
+    constructor() {
+        this.rules = [];
+    }
+    /**
+     * Adiciona regra de validação
+     */
+    addRule(rule) {
+        this.rules.push(rule);
+        return this;
+    }
+    /**
+     * Valida parâmetros contra as regras
+     */
+    validate(params) {
+        const errors = [];
+        const warnings = [];
+        for (const rule of this.rules) {
+            const value = params[rule.field];
+            // Validação de campo obrigatório
+            if (rule.required && (value === undefined || value === null || value === '')) {
+                errors.push({
+                    field: rule.field,
+                    type: ValidationType.REQUIRED,
+                    message: rule.message || `Field '${rule.field}' is required`,
+                    value,
+                });
+                continue;
+            }
+            // Se não é obrigatório e não tem valor, pular validações adicionais
+            if (!rule.required && (value === undefined || value === null || value === '')) {
+                continue;
+            }
+            // Validação por tipo
+            const typeError = this.validateType(rule, value, params);
+            if (typeError) {
+                errors.push(typeError);
+                continue;
+            }
+            // Validação customizada
+            if (rule.custom) {
+                const customResult = rule.custom(value, params);
+                if (customResult !== true) {
+                    errors.push({
+                        field: rule.field,
+                        type: ValidationType.PATTERN,
+                        message: typeof customResult === 'string' ? customResult : `Field '${rule.field}' failed custom validation`,
+                        value,
+                    });
+                }
+            }
+            // Avisos e sugestões
+            this.addWarnings(rule, value, warnings);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Valida tipo do valor
+     */
+    validateType(rule, value, allParams) {
+        switch (rule.type) {
+            case ValidationType.STRING:
+                if (typeof value !== 'string') {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.STRING,
+                        message: rule.message || `Field '${rule.field}' must be a string`,
+                        value,
+                        expected: 'string',
+                    };
+                }
+                // Validação de comprimento
+                if (rule.minLength && value.length < rule.minLength) {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.LENGTH,
+                        message: rule.message || `Field '${rule.field}' must be at least ${rule.minLength} characters`,
+                        value,
+                        expected: `>= ${rule.minLength}`,
+                    };
+                }
+                if (rule.maxLength && value.length > rule.maxLength) {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.LENGTH,
+                        message: rule.message || `Field '${rule.field}' must be at most ${rule.maxLength} characters`,
+                        value,
+                        expected: `<= ${rule.maxLength}`,
+                    };
+                }
+                // Validação de padrão
+                if (rule.pattern && !rule.pattern.test(value)) {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.PATTERN,
+                        message: rule.message || `Field '${rule.field}' does not match required pattern`,
+                        value,
+                        expected: rule.pattern.toString(),
+                    };
+                }
+                // Validação de enum
+                if (rule.enum && !rule.enum.includes(value)) {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.ENUM,
+                        message: rule.message || `Field '${rule.field}' must be one of: ${rule.enum.join(', ')}`,
+                        value,
+                        expected: rule.enum,
+                    };
+                }
+                break;
+            case ValidationType.PATH:
+                if (typeof value !== 'string') {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.PATH,
+                        message: rule.message || `Field '${rule.field}' must be a path string`,
+                        value,
+                        expected: 'string',
+                    };
+                }
+                // Verificar path traversal
+                if (value.includes('..') || value.includes('~')) {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.PATH,
+                        message: rule.message || `Field '${rule.field}' contains invalid path characters`,
+                        value,
+                    };
+                }
+                break;
+            default:
+                // Para outros tipos, implementação básica
+                if (rule.type === ValidationType.NUMBER && typeof value !== 'number') {
+                    return {
+                        field: rule.field,
+                        type: ValidationType.NUMBER,
+                        message: rule.message || `Field '${rule.field}' must be a number`,
+                        value,
+                        expected: 'number',
+                    };
+                }
+                break;
+        }
+        return null;
+    }
+    /**
+     * Adiciona avisos baseados na validação
+     */
+    addWarnings(rule, value, warnings) {
+        if (rule.type === ValidationType.STRING && typeof value === 'string') {
+            // Aviso para strings vazias em campos não obrigatórios
+            if (value.trim() === '' && !rule.required) {
+                warnings.push({
+                    field: rule.field,
+                    message: `Field '${rule.field}' is empty`,
+                    suggestion: 'Consider removing this field if not needed',
+                });
+            }
+        }
+        if (rule.type === ValidationType.PATH && typeof value === 'string') {
+            // Aviso para paths absolutos
+            if (path.isAbsolute(value)) {
+                warnings.push({
+                    field: rule.field,
+                    message: `Field '${rule.field}' contains an absolute path`,
+                    suggestion: 'Consider using relative paths for better portability',
+                });
+            }
+        }
+    }
+    /**
+     * Limpa todas as regras
+     */
+    clear() {
+        this.rules = [];
+    }
+}
+/**
+ * Validadores pré-configurados para casos comuns
+ */
+export const commonValidators = {
+    /**
+     * Validador para parâmetros Git básicos
+     */
+    gitParams: () => new ParameterValidator()
+        .addRule({ field: 'projectPath', type: ValidationType.STRING, required: true })
+        .addRule({
+        field: 'projectPath',
+        type: ValidationType.PATH,
+        custom: (value) => {
+            if (value.includes('..'))
+                return 'Path cannot contain .. (parent directory)';
+            if (value.includes('~'))
+                return 'Path cannot contain ~ (home directory)';
+            return true;
+        }
+    }),
+    /**
+     * Validador para ações Git
+     */
+    gitAction: (allowedActions) => new ParameterValidator()
+        .addRule({
+        field: 'action',
+        type: ValidationType.STRING,
+        required: true,
+        enum: allowedActions,
+    }),
+    /**
+     * Validador para branches
+     */
+    branchName: () => new ParameterValidator()
+        .addRule({
+        field: 'branchName',
+        type: ValidationType.STRING,
+        required: true,
+        pattern: /^[a-zA-Z0-9._/-]+$/,
+        message: 'Branch name can only contain letters, numbers, dots, underscores, hyphens and forward slashes',
+    }),
+};
+/**
+ * Função helper para validação rápida
+ */
+export function validateParams(params, rules) {
+    const validator = new ParameterValidator();
+    rules.forEach(rule => validator.addRule(rule));
+    return validator.validate(params);
+}
+/**
+ * Função helper para validação com throw de erro
+ */
+export function validateOrThrow(params, rules) {
+    const result = validateParams(params, rules);
+    if (!result.isValid) {
+        const errorMessages = result.errors.map((e) => e.message).join('; ');
+        throw new MCPError('VALIDATION_ERROR', errorMessages, result.errors.map((e) => e.message));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "10.0.4",
+  "version": "10.0.6",
   "type": "module",
   "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop, Trae AI, Kiro.dev). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. Smart parameter normalization handles both 'action' and 'command' formats. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
   "main": "dist/index.js",

package/dist/config.d.ts

@@ -1,5 +0,0 @@
-export type MCPConfig = {
-    env?: Record<string, string>;
-    [k: string]: any;
-};
-export declare function loadMCPConfig(configPath?: string): MCPConfig | null;

package/dist/config.js

@@ -1,35 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-function maskSecret(value) {
-    if (!value)
-        return 'undefined';
-    if (value.length <= 8)
-        return '****';
-    return `${value.slice(0, 4)}...${value.slice(-4)}`;
-}
-export function loadMCPConfig(configPath) {
-    const cfgPath = path.resolve(process.cwd(), configPath ?? 'mcp.json');
-    if (!fs.existsSync(cfgPath))
-        return null;
-    try {
-        const raw = fs.readFileSync(cfgPath, 'utf8');
-        const cfg = JSON.parse(raw);
-        if (cfg.env) {
-            for (const [k, v] of Object.entries(cfg.env)) {
-                // Only set if not already present in process.env
-                if (process.env[k] == null) {
-                    process.env[k] = v;
-                }
-                // Log to stderr only (stdout is used for MCP protocol)
-                if (process.env.DEBUG) {
-                    console.error(`MCP config: env.${k}=${maskSecret(process.env[k])}`);
-                }
-            }
-        }
-        return cfg;
-    }
-    catch (err) {
-        console.error('Failed to parse mcp.json:', err.message ?? String(err));
-        return null;
-    }
-}