Brave Real Browser MCP Server

#!/usr/bin/env node

/**
 * Brave Real Puppeteer Core - Comprehensive Test Suite
 * Tests all patcher features including stealth, version sync, and bot detection bypass
 * 
 * Run with: npm test
 * Or: node test/test.js
 */

const { spawn } = require('child_process');
const path = require('path');
const fs = require('fs');

const colors = {
    red: '\x1b[31m',
    green: '\x1b[32m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m',
    cyan: '\x1b[36m',
    reset: '\x1b[0m',
    bold: '\x1b[1m'
};

class PuppeteerCoreTestSuite {
    constructor() {
        this.results = { passed: 0, failed: 0, skipped: 0, total: 0 };
        this.testsDir = path.resolve(__dirname, '..');
    }

    log(level, msg) {
        const prefix = {
            info: `${colors.blue}[INFO]${colors.reset}`,
            success: `${colors.green}[SUCCESS]${colors.reset}`,
            error: `${colors.red}[ERROR]${colors.reset}`,
            warn: `${colors.yellow}[WARN]${colors.reset}`,
            test: `${colors.cyan}[TEST]${colors.reset}`
        };
        console.log(`${prefix[level]} ${msg}`);
    }

    async runCommand(cmd, args, cwd = this.testsDir) {
        return new Promise((resolve) => {
            const proc = spawn(cmd, args, {
                cwd,
                shell: true,
                stdio: 'pipe'
            });

            let stdout = '', stderr = '';
            proc.stdout?.on('data', d => stdout += d);
            proc.stderr?.on('data', d => stderr += d);

            proc.on('close', code => {
                resolve({ code, stdout, stderr });
            });

            proc.on('error', err => {
                resolve({ code: 1, stdout, stderr: err.message });
            });
        });
    }

    async runTest(name, testFn) {
        this.results.total++;
        this.log('test', `Running: ${name}`);

        try {
            const startTime = Date.now();
            await testFn();
            const duration = Date.now() - startTime;

            this.results.passed++;
            this.log('success', `✅ ${name} (${duration}ms)`);
        } catch (error) {
            this.results.failed++;
            this.log('error', `❌ ${name}: ${error.message}`);
        }
    }

    skipTest(name, reason) {
        this.results.total++;
        this.results.skipped++;
        this.log('warn', `⏭️  Skipped: ${name} (${reason})`);
    }

    // Test 1: Check if patcher script exists
    async testPatcherExists() {
        const patcherPath = path.join(this.testsDir, 'scripts', 'patcher.js');
        if (!fs.existsSync(patcherPath)) {
            throw new Error('patcher.js not found');
        }
        this.log('info', `Patcher found at: ${patcherPath}`);
    }

    // Test 2: Check patches directory
    async testPatchesDirectory() {
        const patchesDir = path.join(this.testsDir, 'patches');
        if (!fs.existsSync(patchesDir)) {
            throw new Error('patches directory not found');
        }

        const patches = fs.readdirSync(patchesDir);
        if (patches.length === 0) {
            throw new Error('No patches found in patches directory');
        }

        this.log('info', `Found ${patches.length} patch file(s)`);
    }

    // Test 3: Check version sync (if puppeteer-core is installed)
    async testVersionSync() {
        const result = await this.runCommand('node', ['./scripts/version-sync-checker.js', 'table']);

        if (result.code !== 0 && !result.stdout.includes('not installed')) {
            throw new Error(`Version sync check failed: ${result.stderr}`);
        }

        this.log('info', 'Version sync check completed');
    }

    // Test 4: Check patcher help command
    async testPatcherHelp() {
        const result = await this.runCommand('node', ['./scripts/patcher.js', '--help']);

        if (!result.stdout.includes('patch') && !result.stdout.includes('unpatch')) {
            throw new Error('Patcher help not showing expected commands');
        }

        this.log('info', 'Patcher CLI working correctly');
    }

    // Test 5: Check stealth features exist
    async testStealthFeaturesExist() {
        const stealthPatches = [
            'patches/core/navigator-languages.patch',
            'patches/core/navigator-plugins.patch',
            'patches/core/webgl-vendor.patch'
        ];

        let found = 0;
        for (const patch of stealthPatches) {
            const patchPath = path.join(this.testsDir, patch);
            if (fs.existsSync(patchPath)) found++;
        }

        // At least some patches should exist
        if (found === 0) {
            // Check alternate location
            const patchesDir = path.join(this.testsDir, 'patches');
            const allPatches = fs.readdirSync(patchesDir, { recursive: true });
            if (allPatches.length === 0) {
                throw new Error('No stealth patches found');
            }
            this.log('info', `Found ${allPatches.length} patch files in patches directory`);
        } else {
            this.log('info', `Found ${found}/${stealthPatches.length} core stealth patches`);
        }
    }

    // Test 6: CJS compatibility
    async testCJSCompatibility() {
        const testPath = path.join(this.testsDir, 'scripts', 'test_cjs.cjs');
        if (!fs.existsSync(testPath)) {
            this.skipTest('CJS Compatibility', 'test_cjs.cjs not found');
            return;
        }

        const result = await this.runCommand('node', ['./scripts/test_cjs.cjs']);

        // Allow timeout or browser-not-found errors in CI
        if (result.code !== 0) {
            if (result.stderr.includes('timeout') ||
                result.stderr.includes('not installed') ||
                result.stdout.includes('Test Passed')) {
                this.log('info', 'CJS test completed (browser-dependent features may vary)');
                return;
            }
        }

        if (result.stdout.includes('Test Passed') || result.stdout.includes('Passed')) {
            this.log('info', 'CJS compatibility verified');
        } else {
            throw new Error('CJS test did not pass');
        }
    }

    // Test 7: Package.json validity
    async testPackageJson() {
        const pkgPath = path.join(this.testsDir, 'package.json');
        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));

        if (!pkg.name) throw new Error('package.json missing name');
        if (!pkg.version) throw new Error('package.json missing version');
        if (!pkg.scripts) throw new Error('package.json missing scripts');
        if (!pkg.bin) throw new Error('package.json missing bin commands');

        this.log('info', `Package: ${pkg.name}@${pkg.version}`);
        this.log('info', `Scripts: ${Object.keys(pkg.scripts).length} defined`);
        this.log('info', `Bin commands: ${Object.keys(pkg.bin).length} defined`);
    }

    // Test 8: AI Agent script exists
    async testAIAgentExists() {
        const aiAgentPath = path.join(this.testsDir, 'scripts', 'ai-agent.js');
        if (!fs.existsSync(aiAgentPath)) {
            throw new Error('ai-agent.js not found');
        }
        this.log('info', 'AI Agent script exists');
    }

    async runAllTests() {
        console.log(`${colors.bold}${colors.cyan}🛡️ Brave Real Puppeteer Core Test Suite${colors.reset}`);
        console.log(`${colors.cyan}${'='.repeat(50)}${colors.reset}\n`);

        const startTime = Date.now();

        await this.runTest('Patcher Script Exists', () => this.testPatcherExists());
        await this.runTest('Patches Directory', () => this.testPatchesDirectory());
        await this.runTest('Package.json Validity', () => this.testPackageJson());
        await this.runTest('Patcher CLI Help', () => this.testPatcherHelp());
        await this.runTest('Stealth Features', () => this.testStealthFeaturesExist());
        await this.runTest('Version Sync Check', () => this.testVersionSync());
        await this.runTest('AI Agent Script', () => this.testAIAgentExists());
        await this.runTest('CJS Compatibility', () => this.testCJSCompatibility());

        const duration = Date.now() - startTime;

        console.log(`\n${colors.bold}${colors.cyan}📊 Test Results${colors.reset}`);
        console.log(`${colors.cyan}${'='.repeat(30)}${colors.reset}`);
        console.log(`${colors.green}✅ Passed: ${this.results.passed}${colors.reset}`);
        console.log(`${colors.red}❌ Failed: ${this.results.failed}${colors.reset}`);
        console.log(`${colors.yellow}⏭️  Skipped: ${this.results.skipped}${colors.reset}`);
        console.log(`${colors.blue}📋 Total: ${this.results.total}${colors.reset}`);
        console.log(`${colors.magenta}⏱️  Duration: ${duration}ms${colors.reset}`);

        const successRate = ((this.results.passed / this.results.total) * 100).toFixed(1);
        console.log(`${colors.cyan}📈 Success Rate: ${successRate}%${colors.reset}\n`);

        if (this.results.failed > 0) {
            console.log(`${colors.red}${colors.bold}❌ Some tests failed!${colors.reset}`);
            process.exit(1);
        } else {
            console.log(`${colors.green}${colors.bold}🎉 All tests passed!${colors.reset}`);
            process.exit(0);
        }
    }
}

// Run tests
const suite = new PuppeteerCoreTestSuite();
suite.runAllTests().catch(err => {
    console.error(`${colors.red}Fatal error: ${err.message}${colors.reset}`);
    process.exit(1);
});