cbrowser 7.4.1 → 7.4.4

package/dist/mcp-server-remote.js

@@ -0,0 +1,890 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CBrowser Remote MCP Server
+ *
+ * HTTP-based MCP server for remote access via claude.ai custom connectors.
+ * Uses StreamableHTTPServerTransport for HTTP/SSE communication.
+ *
+ * Run with: cbrowser mcp-remote
+ * Or: npx cbrowser mcp-remote
+ * Or: node dist/mcp-server-remote.js
+ *
+ * Environment variables:
+ *   PORT - Port to listen on (default: 3000)
+ *   HOST - Host to bind to (default: 0.0.0.0)
+ *   MCP_SESSION_MODE - 'stateful' or 'stateless' (default: stateless)
+ *   MCP_API_KEY - API key for authentication (optional, if not set server is open)
+ *   MCP_API_KEYS - Comma-separated list of valid API keys (optional, alternative to MCP_API_KEY)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRemoteMcpServer = startRemoteMcpServer;
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const zod_1 = require("zod");
+const browser_js_1 = require("./browser.js");
+// Visual module imports
+const index_js_1 = require("./visual/index.js");
+// Testing module imports
+const index_js_2 = require("./testing/index.js");
+// Analysis module imports
+const index_js_3 = require("./analysis/index.js");
+// Performance module imports
+const index_js_4 = require("./performance/index.js");
+// Shared browser instance
+let browser = null;
+async function getBrowser() {
+    if (!browser) {
+        browser = new browser_js_1.CBrowser({
+            headless: true,
+            persistent: true,
+        });
+    }
+    return browser;
+}
+// Transport instances by session (for stateful mode)
+const transports = new Map();
+/**
+ * Get configured API keys from environment
+ */
+function getApiKeys() {
+    const singleKey = process.env.MCP_API_KEY;
+    const multipleKeys = process.env.MCP_API_KEYS;
+    if (!singleKey && !multipleKeys) {
+        return null; // No authentication configured
+    }
+    const keys = new Set();
+    if (singleKey) {
+        keys.add(singleKey);
+    }
+    if (multipleKeys) {
+        multipleKeys.split(",").map(k => k.trim()).filter(k => k).forEach(k => keys.add(k));
+    }
+    return keys;
+}
+/**
+ * Validate API key from request headers
+ * Supports: Authorization: Bearer <key> or X-API-Key: <key>
+ */
+function validateApiKey(req, validKeys) {
+    // Check Authorization header (Bearer token)
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+        const token = authHeader.slice(7);
+        if (validKeys.has(token)) {
+            return true;
+        }
+    }
+    // Check X-API-Key header
+    const apiKeyHeader = req.headers["x-api-key"];
+    if (typeof apiKeyHeader === "string" && validKeys.has(apiKeyHeader)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Send 401 Unauthorized response
+ */
+function sendUnauthorized(res) {
+    res.writeHead(401, {
+        "Content-Type": "application/json",
+        "WWW-Authenticate": "Bearer realm=\"cbrowser-mcp\""
+    });
+    res.end(JSON.stringify({
+        error: "Unauthorized",
+        message: "Valid API key required. Use Authorization: Bearer <key> or X-API-Key: <key>"
+    }));
+}
+/**
+ * Configure all CBrowser tools on an MCP server instance.
+ * This is shared between stdio and HTTP transports.
+ */
+function configureMcpTools(server) {
+    // =========================================================================
+    // Navigation Tools
+    // =========================================================================
+    server.tool("navigate", "Navigate to a URL and take a screenshot", {
+        url: zod_1.z.string().url().describe("The URL to navigate to"),
+    }, async ({ url }) => {
+        const b = await getBrowser();
+        const result = await b.navigate(url);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        url: result.url,
+                        title: result.title,
+                        loadTime: result.loadTime,
+                        screenshot: result.screenshot,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Interaction Tools
+    // =========================================================================
+    server.tool("click", "Click an element on the page using text, selector, or description", {
+        selector: zod_1.z.string().describe("Element to click (text content, CSS selector, or description)"),
+        force: zod_1.z.boolean().optional().describe("Bypass safety checks for destructive actions"),
+    }, async ({ selector, force }) => {
+        const b = await getBrowser();
+        const result = await b.click(selector, { force });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: result.success,
+                        message: result.message,
+                        screenshot: result.screenshot,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("smart_click", "Click with auto-retry and self-healing selectors", {
+        selector: zod_1.z.string().describe("Element to click"),
+        maxRetries: zod_1.z.number().optional().default(3).describe("Maximum retry attempts"),
+    }, async ({ selector, maxRetries }) => {
+        const b = await getBrowser();
+        const result = await b.smartClick(selector, { maxRetries });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: result.success,
+                        attempts: result.attempts.length,
+                        finalSelector: result.finalSelector,
+                        message: result.message,
+                        aiSuggestion: result.aiSuggestion,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("fill", "Fill a form field with text", {
+        selector: zod_1.z.string().describe("Input field to fill (name, placeholder, label, or selector)"),
+        value: zod_1.z.string().describe("Value to enter"),
+    }, async ({ selector, value }) => {
+        const b = await getBrowser();
+        const result = await b.fill(selector, value);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: result.success,
+                        message: result.message,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Extraction Tools
+    // =========================================================================
+    server.tool("screenshot", "Take a screenshot of the current page", {
+        path: zod_1.z.string().optional().describe("Optional path to save the screenshot"),
+    }, async ({ path }) => {
+        const b = await getBrowser();
+        const file = await b.screenshot(path);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ screenshot: file }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("extract", "Extract data from the page", {
+        what: zod_1.z.enum(["links", "headings", "forms", "images", "text"]).describe("What to extract"),
+    }, async ({ what }) => {
+        const b = await getBrowser();
+        const result = await b.extract(what);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.data, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Assertion Tools
+    // =========================================================================
+    server.tool("assert", "Assert a condition using natural language", {
+        assertion: zod_1.z.string().describe("Natural language assertion like \"page contains 'Welcome'\" or \"title is 'Home'\""),
+    }, async ({ assertion }) => {
+        const b = await getBrowser();
+        const result = await b.assert(assertion);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        passed: result.passed,
+                        message: result.message,
+                        actual: result.actual,
+                        expected: result.expected,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Analysis Tools
+    // =========================================================================
+    server.tool("analyze_page", "Analyze page structure for forms, buttons, links", {}, async () => {
+        const b = await getBrowser();
+        const analysis = await b.analyzePage();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        title: analysis.title,
+                        forms: analysis.forms.length,
+                        buttons: analysis.buttons.length,
+                        links: analysis.links.length,
+                        hasLogin: analysis.hasLogin,
+                        hasSearch: analysis.hasSearch,
+                        hasNavigation: analysis.hasNavigation,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("generate_tests", "Generate test scenarios for a page", {
+        url: zod_1.z.string().url().optional().describe("URL to analyze (uses current page if not provided)"),
+    }, async ({ url }) => {
+        const b = await getBrowser();
+        const result = await b.generateTests(url);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        testsGenerated: result.tests.length,
+                        tests: result.tests.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            steps: t.steps.length,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Session Tools
+    // =========================================================================
+    server.tool("save_session", "Save browser session (cookies, storage) for later use", {
+        name: zod_1.z.string().describe("Name for the saved session"),
+    }, async ({ name }) => {
+        const b = await getBrowser();
+        await b.saveSession(name);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, sessionName: name }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("load_session", "Load a previously saved session", {
+        name: zod_1.z.string().describe("Name of the session to load"),
+    }, async ({ name }) => {
+        const b = await getBrowser();
+        const loaded = await b.loadSession(name);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: loaded, sessionName: name }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("list_sessions", "List all saved sessions", {}, async () => {
+        const b = await getBrowser();
+        const sessions = await b.listSessions();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(sessions, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Self-Healing Tools
+    // =========================================================================
+    server.tool("heal_stats", "Get self-healing selector cache statistics", {}, async () => {
+        const b = await getBrowser();
+        const stats = b.getSelectorCacheStats();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(stats, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Visual Testing Tools (v7.0.0+)
+    // =========================================================================
+    server.tool("visual_baseline", "Capture a visual baseline for a URL", {
+        url: zod_1.z.string().url().describe("URL to capture baseline for"),
+        name: zod_1.z.string().describe("Name for the baseline"),
+    }, async ({ url, name }) => {
+        const result = await (0, index_js_1.captureVisualBaseline)(url, name, {});
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        name: result.name,
+                        url: result.url,
+                        timestamp: result.timestamp,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("visual_regression", "Run AI visual regression test against a baseline", {
+        url: zod_1.z.string().url().describe("URL to test"),
+        baselineName: zod_1.z.string().describe("Name of baseline to compare against"),
+    }, async ({ url, baselineName }) => {
+        const result = await (0, index_js_1.runVisualRegression)(url, baselineName);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        passed: result.passed,
+                        similarityScore: result.analysis?.similarityScore,
+                        summary: result.analysis?.summary,
+                        changes: result.analysis?.changes?.length || 0,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("cross_browser_test", "Test page rendering across multiple browsers", {
+        url: zod_1.z.string().url().describe("URL to test"),
+        browsers: zod_1.z.array(zod_1.z.enum(["chromium", "firefox", "webkit"])).optional().describe("Browsers to test"),
+    }, async ({ url, browsers }) => {
+        const result = await (0, index_js_1.runCrossBrowserTest)(url, { browsers });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        url: result.url,
+                        overallStatus: result.overallStatus,
+                        summary: result.summary,
+                        screenshotCount: result.screenshots.length,
+                        comparisonCount: result.comparisons.length,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("cross_browser_diff", "Quick diff of page metrics across browsers", {
+        url: zod_1.z.string().url().describe("URL to compare"),
+        browsers: zod_1.z.array(zod_1.z.enum(["chromium", "firefox", "webkit"])).optional().describe("Browsers to compare"),
+    }, async ({ url, browsers }) => {
+        const result = await (0, index_js_1.crossBrowserDiff)(url, browsers);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        url: result.url,
+                        browsers: result.browsers,
+                        differences: result.differences,
+                        metrics: result.metrics,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("responsive_test", "Test page across different viewport sizes", {
+        url: zod_1.z.string().url().describe("URL to test"),
+        viewports: zod_1.z.array(zod_1.z.string()).optional().describe("Viewport presets (mobile, tablet, desktop, etc.)"),
+    }, async ({ url, viewports }) => {
+        const result = await (0, index_js_1.runResponsiveTest)(url, { viewports });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        url: result.url,
+                        overallStatus: result.overallStatus,
+                        summary: result.summary,
+                        viewportsCount: result.screenshots.length,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("ab_comparison", "Compare two URLs visually (staging vs production)", {
+        urlA: zod_1.z.string().url().describe("First URL (e.g., staging)"),
+        urlB: zod_1.z.string().url().describe("Second URL (e.g., production)"),
+        labelA: zod_1.z.string().optional().describe("Label for first URL"),
+        labelB: zod_1.z.string().optional().describe("Label for second URL"),
+    }, async ({ urlA, urlB, labelA, labelB }) => {
+        const labels = labelA && labelB ? { a: labelA, b: labelB } : undefined;
+        const result = await (0, index_js_1.runABComparison)(urlA, urlB, { labels });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        overallStatus: result.overallStatus,
+                        similarityScore: result.analysis?.similarityScore,
+                        summary: result.analysis?.summary,
+                        changesCount: result.analysis?.changes?.length || 0,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Testing Tools (v6.0.0+)
+    // =========================================================================
+    server.tool("nl_test_file", "Run natural language test suite from a file", {
+        filepath: zod_1.z.string().describe("Path to the test file"),
+    }, async ({ filepath }) => {
+        const result = await (0, index_js_2.runNLTestFile)(filepath);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        name: result.name,
+                        total: result.summary.total,
+                        passed: result.summary.passed,
+                        failed: result.summary.failed,
+                        passRate: `${result.summary.passRate.toFixed(1)}%`,
+                        duration: result.duration,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("nl_test_inline", "Run natural language tests from inline content", {
+        content: zod_1.z.string().describe("Test content with instructions like 'go to https://...' and 'click login'"),
+        name: zod_1.z.string().optional().describe("Name for the test suite"),
+    }, async ({ content, name }) => {
+        const suite = (0, index_js_2.parseNLTestSuite)(content, name || "Inline Test");
+        const result = await (0, index_js_2.runNLTestSuite)(suite);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        name: result.name,
+                        total: result.summary.total,
+                        passed: result.summary.passed,
+                        failed: result.summary.failed,
+                        passRate: `${result.summary.passRate.toFixed(1)}%`,
+                        duration: result.duration,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("repair_test", "AI-powered test repair for broken tests", {
+        testName: zod_1.z.string().describe("Name for the test"),
+        steps: zod_1.z.array(zod_1.z.string()).describe("Test step instructions"),
+        autoApply: zod_1.z.boolean().optional().describe("Automatically apply repairs"),
+    }, async ({ testName, steps, autoApply }) => {
+        const testCase = {
+            name: testName,
+            steps: steps.map(instruction => ({
+                instruction,
+                action: "unknown",
+            })),
+        };
+        const result = await (0, index_js_2.repairTest)(testCase, { autoApply: autoApply || false });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        originalTest: result.originalTest.name,
+                        failedSteps: result.failedSteps,
+                        repairedSteps: result.repairedSteps,
+                        repairedTestPasses: result.repairedTestPasses,
+                        repairs: result.failureAnalyses.map(a => ({
+                            step: a.step.instruction,
+                            error: a.error,
+                            suggestion: a.suggestions[0]?.suggestedInstruction || "No suggestion",
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("detect_flaky_tests", "Detect flaky/unreliable tests by running multiple times", {
+        testContent: zod_1.z.string().describe("Test content to analyze"),
+        runs: zod_1.z.number().optional().default(5).describe("Number of times to run each test"),
+        threshold: zod_1.z.number().optional().default(20).describe("Flakiness threshold percentage"),
+    }, async ({ testContent, runs, threshold }) => {
+        const suite = (0, index_js_2.parseNLTestSuite)(testContent, "Flaky Test Analysis");
+        const result = await (0, index_js_2.detectFlakyTests)(suite, { runs, flakinessThreshold: threshold });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        suiteName: result.suiteName,
+                        totalTests: result.summary.totalTests,
+                        stablePass: result.summary.stablePassTests,
+                        stableFail: result.summary.stableFailTests,
+                        flakyTests: result.summary.flakyTests,
+                        overallFlakiness: `${result.summary.overallFlakinessScore.toFixed(1)}%`,
+                        analyses: result.testAnalyses.map(a => ({
+                            test: a.testName,
+                            classification: a.classification,
+                            passRate: `${((a.passCount / a.totalRuns) * 100).toFixed(0)}%`,
+                            flakiness: `${a.flakinessScore}%`,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("coverage_map", "Generate test coverage map for a site", {
+        baseUrl: zod_1.z.string().url().describe("Base URL to analyze"),
+        testFiles: zod_1.z.array(zod_1.z.string()).describe("Array of test file paths"),
+        maxPages: zod_1.z.number().optional().default(100).describe("Maximum pages to crawl"),
+    }, async ({ baseUrl, testFiles, maxPages }) => {
+        const result = await (0, index_js_2.generateCoverageMap)(baseUrl, testFiles, { maxPages });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        totalPages: result.sitePages.length,
+                        testedPages: result.testedPages.length,
+                        untestedPages: result.analysis.untestedPages,
+                        overallCoverage: `${result.analysis.coveragePercent.toFixed(1)}%`,
+                        gaps: result.gaps.slice(0, 10).map(g => ({
+                            url: g.page.url,
+                            priority: g.priority,
+                            reason: g.reason,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Analysis Tools (v4.0.0+)
+    // =========================================================================
+    server.tool("hunt_bugs", "Autonomous bug hunting - crawl and find issues", {
+        url: zod_1.z.string().url().describe("Starting URL to hunt from"),
+        maxPages: zod_1.z.number().optional().default(10).describe("Maximum pages to visit"),
+        timeout: zod_1.z.number().optional().default(60000).describe("Timeout in milliseconds"),
+    }, async ({ url, maxPages, timeout }) => {
+        const b = await getBrowser();
+        const result = await (0, index_js_3.huntBugs)(b, url, { maxPages, timeout });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        pagesVisited: result.pagesVisited,
+                        bugsFound: result.bugs.length,
+                        duration: result.duration,
+                        bugs: result.bugs.slice(0, 10),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("chaos_test", "Inject failures and test resilience", {
+        url: zod_1.z.string().url().describe("URL to test"),
+        networkLatency: zod_1.z.number().optional().describe("Simulate network latency (ms)"),
+        offline: zod_1.z.boolean().optional().describe("Simulate offline mode"),
+        blockUrls: zod_1.z.array(zod_1.z.string()).optional().describe("URL patterns to block"),
+    }, async ({ url, networkLatency, offline, blockUrls }) => {
+        const b = await getBrowser();
+        const result = await (0, index_js_3.runChaosTest)(b, url, { networkLatency, offline, blockUrls });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        passed: result.passed,
+                        errors: result.errors,
+                        duration: result.duration,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("compare_personas", "Compare how different user personas experience a journey", {
+        url: zod_1.z.string().url().describe("Starting URL"),
+        goal: zod_1.z.string().describe("Goal to accomplish"),
+        personas: zod_1.z.array(zod_1.z.string()).describe("Persona names to compare"),
+    }, async ({ url, goal, personas }) => {
+        const result = await (0, index_js_3.comparePersonas)({
+            startUrl: url,
+            goal,
+            personas,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        url: result.url,
+                        goal: result.goal,
+                        personasCompared: result.personas.length,
+                        summary: result.summary,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("find_element_by_intent", "AI-powered semantic element finding", {
+        intent: zod_1.z.string().describe("Natural language description like 'the cheapest product' or 'login form'"),
+    }, async ({ intent }) => {
+        const b = await getBrowser();
+        const result = await (0, index_js_3.findElementByIntent)(b, intent);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result || { found: false, message: "No matching element found" }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Performance Tools (v6.4.0+)
+    // =========================================================================
+    server.tool("perf_baseline", "Capture performance baseline for a URL", {
+        url: zod_1.z.string().url().describe("URL to capture baseline for"),
+        name: zod_1.z.string().describe("Name for the baseline"),
+        runs: zod_1.z.number().optional().default(3).describe("Number of runs to average"),
+    }, async ({ url, name, runs }) => {
+        const result = await (0, index_js_4.capturePerformanceBaseline)(url, { name, runs });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        name: result.name,
+                        url: result.url,
+                        lcp: result.metrics.lcp,
+                        fcp: result.metrics.fcp,
+                        ttfb: result.metrics.ttfb,
+                        cls: result.metrics.cls,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("perf_regression", "Detect performance regression against baseline", {
+        url: zod_1.z.string().url().describe("URL to test"),
+        baselineName: zod_1.z.string().describe("Name of baseline to compare against"),
+        thresholdLcp: zod_1.z.number().optional().default(20).describe("LCP threshold percentage"),
+    }, async ({ url, baselineName, thresholdLcp }) => {
+        const result = await (0, index_js_4.detectPerformanceRegression)(url, baselineName, {
+            thresholds: { lcp: thresholdLcp },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        passed: result.passed,
+                        regressions: result.regressions,
+                        currentMetrics: result.currentMetrics,
+                        baseline: result.baseline.name,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("list_baselines", "List all saved baselines (visual and performance)", {}, async () => {
+        const visualBaselines = await (0, index_js_1.listVisualBaselines)();
+        const perfBaselines = await (0, index_js_4.listPerformanceBaselines)();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        visual: visualBaselines,
+                        performance: perfBaselines,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}
+/**
+ * Create a configured MCP server instance
+ */
+function createMcpServer() {
+    const server = new mcp_js_1.McpServer({
+        name: "cbrowser",
+        version: "7.4.2",
+    });
+    configureMcpTools(server);
+    return server;
+}
+/**
+ * Handle incoming HTTP MCP request
+ */
+async function handleMcpRequest(req, res, transport) {
+    // Handle CORS
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    // Parse body for POST requests
+    if (req.method === "POST") {
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(chunk);
+        }
+        const body = Buffer.concat(chunks).toString("utf-8");
+        const parsedBody = body ? JSON.parse(body) : undefined;
+        await transport.handleRequest(req, res, parsedBody);
+    }
+    else {
+        await transport.handleRequest(req, res);
+    }
+}
+/**
+ * Start the remote HTTP MCP server
+ */
+async function startRemoteMcpServer() {
+    const port = parseInt(process.env.PORT || "3000", 10);
+    const host = process.env.HOST || "0.0.0.0";
+    const sessionMode = process.env.MCP_SESSION_MODE || "stateless";
+    const apiKeys = getApiKeys();
+    const authEnabled = apiKeys !== null && apiKeys.size > 0;
+    console.log(`Starting CBrowser Remote MCP Server v7.4.4...`);
+    console.log(`Mode: ${sessionMode}`);
+    console.log(`Auth: ${authEnabled ? "enabled" : "disabled (open access)"}`);
+    console.log(`Listening on ${host}:${port}`);
+    const httpServer = (0, node_http_1.createServer)(async (req, res) => {
+        const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        // Health check endpoint (always open, no auth required)
+        if (url.pathname === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", version: "7.4.4", auth: authEnabled }));
+            return;
+        }
+        // Server info endpoint (always open)
+        if (url.pathname === "/info") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                name: "cbrowser",
+                version: "7.4.4",
+                description: "Cognitive Browser - AI-powered browser automation with constitutional safety",
+                mcp_endpoint: "/mcp",
+                auth_required: authEnabled,
+                capabilities: ["navigation", "interaction", "visual-testing", "nlp-testing", "performance"],
+            }));
+            return;
+        }
+        // Auth check for protected endpoints
+        if (authEnabled && apiKeys) {
+            if (!validateApiKey(req, apiKeys)) {
+                sendUnauthorized(res);
+                return;
+            }
+        }
+        // MCP endpoint
+        if (url.pathname === "/mcp" || url.pathname === "/") {
+            // Get or create session
+            const sessionId = req.headers["mcp-session-id"];
+            let transport;
+            if (sessionMode === "stateful" && sessionId && transports.has(sessionId)) {
+                transport = transports.get(sessionId);
+            }
+            else {
+                // Create new transport
+                transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: sessionMode === "stateful" ? () => (0, node_crypto_1.randomUUID)() : undefined,
+                });
+                // Create and connect server
+                const server = createMcpServer();
+                await server.connect(transport);
+                // Store transport for stateful mode
+                if (sessionMode === "stateful") {
+                    const newSessionId = transport.sessionId;
+                    if (newSessionId) {
+                        transports.set(newSessionId, transport);
+                        transport.onclose = () => {
+                            transports.delete(newSessionId);
+                        };
+                    }
+                }
+            }
+            await handleMcpRequest(req, res, transport);
+            return;
+        }
+        // 404 for other paths
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+    httpServer.listen(port, host, () => {
+        console.log(`\nCognitive Browser Remote MCP Server running at http://${host}:${port}`);
+        console.log(`\nEndpoints:`);
+        console.log(`  MCP:    http://${host}:${port}/mcp`);
+        console.log(`  Health: http://${host}:${port}/health`);
+        console.log(`  Info:   http://${host}:${port}/info`);
+        if (authEnabled) {
+            console.log(`\nAuthentication:`);
+            console.log(`  Header: Authorization: Bearer <your-api-key>`);
+            console.log(`  Or:     X-API-Key: <your-api-key>`);
+        }
+        console.log(`\nFor claude.ai custom connector:`);
+        console.log(`  URL: https://cbrowser-mcp.wyldfyre.ai/mcp`);
+    });
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log("\nShutting down...");
+        if (browser) {
+            await browser.close();
+        }
+        httpServer.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+// Run if executed directly
+if (process.argv[1]?.endsWith("mcp-server-remote.js") ||
+    process.argv[1]?.endsWith("mcp-server-remote.ts")) {
+    startRemoteMcpServer().catch((err) => {
+        console.error("Failed to start remote MCP server:", err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=mcp-server-remote.js.map