@yasserkhanorg/e2e-agents 0.3.2

package/dist/mcp-server.d.ts

@@ -0,0 +1,35 @@
+interface Tool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * MCP Server for autonomous test discovery, generation, and healing
+ * Provides tools for Claude to interact with test framework
+ */
+export declare class E2EAgentsMCPServer {
+    private repoRoot;
+    private tools;
+    private rateLimiter;
+    constructor(repoRoot?: string);
+    private defineTools;
+    /**
+     * Handle tool calls from Claude/Playwright agents
+     * SECURITY: Rate limiting enforced
+     */
+    callTool(name: string, args: Record<string, unknown>): Promise<string>;
+    private discoverTests;
+    private readFile;
+    private writeFile;
+    private runTests;
+    private getGitChanges;
+    private getRepositoryContext;
+    private getChangedFiles;
+    private analyzeChangesForTests;
+    /**
+     * Get all available tools
+     */
+    getTools(): Tool[];
+}
+export default E2EAgentsMCPServer;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AAaA,UAAU,IAAI;IACV,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AA4GD;;;GAGG;AACH,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAAc;gBAErB,QAAQ,GAAE,MAAsB;IAM5C,OAAO,CAAC,WAAW;IAmGnB;;;OAGG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAwB5E,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,QAAQ;IAmBhB,OAAO,CAAC,SAAS;IAqBjB,OAAO,CAAC,QAAQ;IAyDhB,OAAO,CAAC,aAAa;IA2BrB,OAAO,CAAC,oBAAoB;IAqD5B,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,sBAAsB;IAW9B;;OAEG;IACH,QAAQ,IAAI,IAAI,EAAE;CAGrB;AAYD,eAAe,kBAAkB,CAAC"}

package/dist/mcp-server.js

@@ -0,0 +1,469 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2EAgentsMCPServer = void 0;
+/**
+ * MCP Server for E2E Agents - SECURITY HARDENED
+ * Exposes tools for Claude and Playwright agents to discover, generate, and heal tests
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const glob_1 = require("glob");
+/**
+ * SECURITY: Path validation helper
+ * Prevents directory traversal attacks
+ */
+function validatePathIsWithinRoot(filePath, rootPath) {
+    try {
+        const normalized = (0, path_1.resolve)(filePath);
+        const normalizedRoot = (0, path_1.resolve)(rootPath);
+        return normalized.startsWith(normalizedRoot + '/') || normalized === normalizedRoot;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * SECURITY: Input validation for shell arguments
+ * Prevents command injection attacks
+ */
+function validatePlaywrightPattern(pattern) {
+    // Allow alphanumeric, dots, dashes, slashes, asterisks, underscores only
+    return /^[a-zA-Z0-9_\-.*\/]+$/.test(pattern) && !pattern.includes('..') && pattern.length < 512;
+}
+/**
+ * SECURITY: Validate git refs to prevent argument injection
+ */
+function validateGitRef(ref) {
+    // Allow standard git ref patterns: branches, tags, commit hashes
+    // Blocks patterns that start with -- (options) or contain spaces
+    return (/^[a-zA-Z0-9_\-./~^]+$/.test(ref) &&
+        !ref.startsWith('--') &&
+        ref.length < 256 &&
+        !ref.includes('\n') &&
+        !ref.includes('\0'));
+}
+/**
+ * SECURITY: Validate browser names against allowlist
+ */
+function validateBrowsers(browsers) {
+    const allowedBrowsers = new Set(['chromium', 'firefox', 'webkit']);
+    return browsers.length > 0 && browsers.length <= 3 && browsers.every((b) => allowedBrowsers.has(b));
+}
+/**
+ * SECURITY: Glob pattern validation
+ * Restricts to test-related patterns to prevent enumeration of sensitive files
+ */
+function validateGlobPattern(pattern) {
+    // Block attempts to enumerate sensitive patterns
+    const blockedPatterns = [/\*\*\/\*\*/, /\.env/, /\.pem/, /\.key/, /aws|credentials|secret|password/i];
+    if (pattern.length > 256)
+        return false;
+    if (blockedPatterns.some((p) => p.test(pattern)))
+        return false;
+    if (pattern.includes('..'))
+        return false;
+    return /^[a-zA-Z0-9_\-.*\/]+$/.test(pattern);
+}
+/**
+ * SECURITY: Sanitize error messages to prevent information leakage
+ */
+function sanitizeError(error, operation) {
+    if (error instanceof Error) {
+        // Only return safe error message, hide internal details
+        if (error.message.includes('ENOENT')) {
+            return `File not found (${operation})`;
+        }
+        if (error.message.includes('EACCES')) {
+            return `Permission denied (${operation})`;
+        }
+        if (error.message.includes('EISDIR')) {
+            return `Is a directory (${operation})`;
+        }
+        return `Operation failed: ${operation}`;
+    }
+    return 'An unexpected error occurred';
+}
+/**
+ * SECURITY: Rate limiter helper
+ */
+class RateLimiter {
+    constructor(maxRequests = 100, windowMs = 60000) {
+        this.requests = [];
+        this.maxRequests = maxRequests;
+        this.windowMs = windowMs;
+    }
+    isAllowed() {
+        const now = Date.now();
+        this.requests = this.requests.filter((time) => now - time < this.windowMs);
+        if (this.requests.length >= this.maxRequests) {
+            return false;
+        }
+        this.requests.push(now);
+        return true;
+    }
+}
+/**
+ * MCP Server for autonomous test discovery, generation, and healing
+ * Provides tools for Claude to interact with test framework
+ */
+class E2EAgentsMCPServer {
+    constructor(repoRoot = process.cwd()) {
+        this.repoRoot = repoRoot;
+        this.tools = this.defineTools();
+        this.rateLimiter = new RateLimiter(100, 60000); // 100 requests per minute
+    }
+    defineTools() {
+        return [
+            {
+                name: 'discover_tests',
+                description: 'Discover tests that need to be written based on code changes',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Git ref to compare against (e.g., HEAD~5, main)',
+                        },
+                        pattern: {
+                            type: 'string',
+                            description: "Test file pattern to search (e.g., '**/*.spec.ts')",
+                        },
+                    },
+                },
+            },
+            {
+                name: 'read_file',
+                description: 'Read a file from the repository',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'File path relative to repo root',
+                        },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'write_file',
+                description: 'Write or create a file in the repository',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'File path relative to repo root',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'File content to write',
+                        },
+                    },
+                    required: ['path', 'content'],
+                },
+            },
+            {
+                name: 'run_tests',
+                description: 'Run Playwright tests matching a pattern',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: "Test file pattern (e.g., 'tests/**/*.spec.ts')",
+                        },
+                        browsers: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Browsers to test (chromium, firefox, webkit)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_git_changes',
+                description: 'Get files changed since a git reference',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        since: {
+                            type: 'string',
+                            description: 'Git ref to compare against (e.g., HEAD~5, main)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'get_repository_context',
+                description: 'Get repository structure and project metadata',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        include: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'What to include (package.json, tsconfig, playwright.config, tests)',
+                        },
+                    },
+                },
+            },
+        ];
+    }
+    /**
+     * Handle tool calls from Claude/Playwright agents
+     * SECURITY: Rate limiting enforced
+     */
+    async callTool(name, args) {
+        // SECURITY: Rate limiting
+        if (!this.rateLimiter.isAllowed()) {
+            return JSON.stringify({ error: 'Rate limit exceeded. Too many requests.' });
+        }
+        switch (name) {
+            case 'discover_tests':
+                return this.discoverTests(args);
+            case 'read_file':
+                return this.readFile(args);
+            case 'write_file':
+                return this.writeFile(args);
+            case 'run_tests':
+                return this.runTests(args);
+            case 'get_git_changes':
+                return this.getGitChanges(args);
+            case 'get_repository_context':
+                return this.getRepositoryContext(args);
+            default:
+                return JSON.stringify({ error: 'Unknown tool' });
+        }
+    }
+    discoverTests(args) {
+        try {
+            const since = args.since || 'HEAD~5';
+            const pattern = args.pattern || '**/*.spec.ts';
+            // SECURITY: Validate inputs
+            if (!validateGitRef(since)) {
+                return JSON.stringify({ error: 'Invalid git reference format' });
+            }
+            if (!validateGlobPattern(pattern)) {
+                return JSON.stringify({ error: 'Invalid pattern format' });
+            }
+            // Get changed files
+            const changedFiles = this.getChangedFiles(since);
+            // Find test files that might need updating
+            const testFiles = (0, glob_1.globSync)(pattern, { cwd: this.repoRoot });
+            return JSON.stringify({
+                changedFiles,
+                existingTests: testFiles,
+                recommendedTests: this.analyzeChangesForTests(changedFiles, testFiles),
+            });
+        }
+        catch (error) {
+            return JSON.stringify({ error: sanitizeError(error, 'discover_tests') });
+        }
+    }
+    readFile(args) {
+        try {
+            // SECURITY: Path traversal prevention
+            const filePath = (0, path_1.resolve)(this.repoRoot, args.path);
+            if (!validatePathIsWithinRoot(filePath, this.repoRoot)) {
+                return JSON.stringify({ error: 'Access denied' });
+            }
+            if (!(0, fs_1.existsSync)(filePath)) {
+                return JSON.stringify({ error: 'File not found' });
+            }
+            const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            return JSON.stringify({ path: args.path, content });
+        }
+        catch (error) {
+            return JSON.stringify({ error: sanitizeError(error, 'read_file') });
+        }
+    }
+    writeFile(args) {
+        try {
+            // SECURITY: Path traversal prevention
+            const filePath = (0, path_1.resolve)(this.repoRoot, args.path);
+            if (!validatePathIsWithinRoot(filePath, this.repoRoot)) {
+                return JSON.stringify({ error: 'Access denied' });
+            }
+            // SECURITY: Size limit to prevent resource exhaustion
+            if (args.content.length > 10 * 1024 * 1024) {
+                // 10MB limit
+                return JSON.stringify({ error: 'File too large' });
+            }
+            (0, fs_1.writeFileSync)(filePath, args.content, 'utf-8');
+            return JSON.stringify({ success: true, path: args.path });
+        }
+        catch (error) {
+            return JSON.stringify({ error: sanitizeError(error, 'write_file') });
+        }
+    }
+    runTests(args) {
+        try {
+            const pattern = args.pattern || '**/*.spec.ts';
+            const browsers = args.browsers || ['chromium'];
+            // SECURITY: Validate inputs
+            if (!validatePlaywrightPattern(pattern)) {
+                return JSON.stringify({ error: 'Invalid test pattern' });
+            }
+            if (!validateBrowsers(browsers)) {
+                return JSON.stringify({ error: 'Invalid browser specification' });
+            }
+            const projectArgs = browsers.flatMap((browser) => ['--project', browser]);
+            // SECURITY: Use -- to separate playwright options from test args
+            const result = (0, child_process_1.spawnSync)('npx', [
+                'playwright',
+                'test',
+                ...projectArgs,
+                '--',
+                pattern,
+            ], {
+                cwd: this.repoRoot,
+                encoding: 'utf-8',
+                timeout: 300000, // 5 minute timeout
+                maxBuffer: 1024 * 1024, // 1MB output limit
+            });
+            if (result.error) {
+                return JSON.stringify({
+                    success: false,
+                    error: 'Test execution failed',
+                });
+            }
+            // SECURITY: Don't leak full stdout/stderr, summarize instead
+            const stdout = result.stdout ? result.stdout.substring(0, 5000) : '';
+            const stderr = result.stderr ? result.stderr.substring(0, 5000) : '';
+            return JSON.stringify({
+                success: result.status === 0,
+                summary: `Exit code: ${result.status}`,
+                testsPassed: stdout.includes('passed'),
+                testsFailed: stdout.includes('failed'),
+            });
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: 'Test execution error',
+            });
+        }
+    }
+    getGitChanges(args) {
+        try {
+            const since = args.since || 'HEAD~5';
+            // SECURITY: Validate git ref
+            if (!validateGitRef(since)) {
+                return JSON.stringify({ error: 'Invalid git reference format' });
+            }
+            // SECURITY: Use -- to separate git options from refs
+            const result = (0, child_process_1.spawnSync)('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+                cwd: this.repoRoot,
+                encoding: 'utf-8',
+                timeout: 30000,
+            });
+            if (result.error) {
+                return JSON.stringify({ error: 'Git operation failed' });
+            }
+            const changedFiles = result.stdout.trim().split('\n').filter((f) => f);
+            return JSON.stringify({ changedFiles });
+        }
+        catch (error) {
+            return JSON.stringify({ error: 'Git operation error' });
+        }
+    }
+    getRepositoryContext(args) {
+        try {
+            const defaultInclude = ['package.json', 'tsconfig.json', 'playwright.config.ts', 'playwright.config.js'];
+            const include = args.include || defaultInclude;
+            // SECURITY: Limit to allowed filenames
+            const allowedFiles = new Set([
+                'package.json',
+                'tsconfig.json',
+                'tsconfig.base.json',
+                'playwright.config.ts',
+                'playwright.config.js',
+                'jest.config.js',
+                '.npmrc',
+                'README.md',
+            ]);
+            const context = {};
+            for (const file of include) {
+                // SECURITY: Validate each path
+                if (!allowedFiles.has(file)) {
+                    continue; // Skip non-allowed files
+                }
+                const filePath = (0, path_1.resolve)(this.repoRoot, file);
+                if (!validatePathIsWithinRoot(filePath, this.repoRoot)) {
+                    continue;
+                }
+                if ((0, fs_1.existsSync)(filePath)) {
+                    try {
+                        context[file] = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                    }
+                    catch {
+                        // Ignore read errors for individual files
+                    }
+                }
+            }
+            // Add test structure with safe globbing
+            const testFiles = (0, glob_1.globSync)('**/*.spec.ts', {
+                cwd: this.repoRoot,
+                ignore: 'node_modules/**',
+                maxDepth: 5,
+            });
+            context.testFiles = testFiles.slice(0, 100); // Limit to 100 files
+            return JSON.stringify(context);
+        }
+        catch (error) {
+            return JSON.stringify({ error: sanitizeError(error, 'get_repository_context') });
+        }
+    }
+    getChangedFiles(since) {
+        try {
+            // SECURITY: Validate git ref before use
+            if (!validateGitRef(since)) {
+                return [];
+            }
+            // SECURITY: Use -- separator
+            const result = (0, child_process_1.spawnSync)('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+                cwd: this.repoRoot,
+                encoding: 'utf-8',
+                timeout: 30000,
+            });
+            if (result.error) {
+                return [];
+            }
+            return result.stdout.trim().split('\n').filter((f) => f);
+        }
+        catch {
+            return [];
+        }
+    }
+    analyzeChangesForTests(changedFiles, existingTests) {
+        // Simple heuristic: if a source file changed, suggest a test for it
+        return changedFiles
+            .filter((f) => !f.endsWith('.spec.ts') && !f.endsWith('.test.ts'))
+            .slice(0, 10) // Limit results
+            .map((f) => {
+            const testFile = f.replace(/\.(ts|js)$/, '.spec.ts');
+            return testFile;
+        });
+    }
+    /**
+     * Get all available tools
+     */
+    getTools() {
+        return this.tools;
+    }
+}
+exports.E2EAgentsMCPServer = E2EAgentsMCPServer;
+/**
+ * Start MCP server
+ * Usage: node dist/mcp-server.js
+ */
+if (require.main === module) {
+    const server = new E2EAgentsMCPServer();
+    console.log('E2E Agents MCP Server started');
+    console.log('Tools:', server.getTools().map((t) => t.name).join(', '));
+}
+exports.default = E2EAgentsMCPServer;

package/dist/ollama_provider.d.ts

@@ -0,0 +1,65 @@
+import type { GenerateOptions, ImageInput, LLMResponse, OllamaConfig, ProviderCapabilities } from './provider_interface.js';
+import { BaseProvider } from './base_provider.js';
+/**
+ * Ollama Provider - Free, local LLM execution
+ *
+ * Features:
+ * - Zero cost (runs locally)
+ * - Full privacy (no data leaves your machine)
+ * - OpenAI-compatible API
+ * - Supports DeepSeek-R1, Llama 4, and other open models
+ *
+ * Limitations:
+ * - No vision support (most models)
+ * - Slower inference than cloud APIs (~2-5 sec vs <1 sec)
+ * - Requires local installation and model downloads
+ *
+ * Recommended models:
+ * - deepseek-r1:7b - Fast, good quality, low memory (4GB)
+ * - deepseek-r1:14b - Better quality, medium memory (8GB)
+ * - llama4:13b - High quality, medium memory (8GB)
+ * - deepseek-r1:7b-q4 - Quantized for speed, lower quality
+ *
+ * Setup:
+ * 1. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh
+ * 2. Pull model: ollama pull deepseek-r1:7b
+ * 3. Start: ollama serve (runs on localhost:11434)
+ */
+export declare class OllamaProvider extends BaseProvider {
+    name: string;
+    private client;
+    private model;
+    capabilities: ProviderCapabilities;
+    constructor(config: OllamaConfig);
+    generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    /**
+     * Ollama does not support vision by default
+     * This method throws an error to help users understand the limitation
+     */
+    analyzeImage(images: ImageInput[], prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    /**
+     * Stream text generation for real-time feedback
+     */
+    streamText(prompt: string, options?: GenerateOptions): AsyncGenerator<string, void, unknown>;
+    /**
+     * Check if Ollama is running and accessible
+     */
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+    /**
+     * List available models in Ollama
+     */
+    listModels(): Promise<string[]>;
+}
+/**
+ * Helper function to check if Ollama is installed and suggest setup
+ */
+export declare function checkOllamaSetup(): Promise<{
+    installed: boolean;
+    running: boolean;
+    modelAvailable: boolean;
+    setupInstructions: string;
+}>;
+//# sourceMappingURL=ollama_provider.d.ts.map

package/dist/ollama_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama_provider.d.ts","sourceRoot":"","sources":["../src/ollama_provider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACX,YAAY,EACZ,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAiEhD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC5C,IAAI,SAAY;IAChB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;IAEtB,YAAY,EAAE,oBAAoB,CAShC;gBAEU,MAAM,EAAE,YAAY;IA8B1B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAkEnF;;;OAGG;IAEG,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAIzG;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IAqDnG;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;IAgBjE;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAaxC;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC;IAC9C,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC7B,CAAC,CAoCD"}