real-browser-mcp-server 1.4.5 → 1.5.0

package/dist/src/mcp/handlers/network.d.ts

@@ -22,6 +22,8 @@ export declare const networkHandlers: {
         error?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -35,6 +37,8 @@ export declare const networkHandlers: {
         error?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -58,6 +62,8 @@ export declare const networkHandlers: {
         error?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -71,6 +77,8 @@ export declare const networkHandlers: {
         error?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -84,6 +92,8 @@ export declare const networkHandlers: {
         note?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -97,6 +107,8 @@ export declare const networkHandlers: {
         apiCalls?: undefined;
         interceptedApis?: undefined;
         error?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
@@ -110,13 +122,22 @@ export declare const networkHandlers: {
         interceptedApis?: undefined;
         note?: undefined;
         totalMessages?: undefined;
+        graphql?: undefined;
+        har?: undefined;
         recording?: undefined;
         records?: undefined;
     } | {
         success: boolean;
-        recording: boolean;
         count: number;
-        records: import("../../types").NetworkRecord[];
+        graphql: {
+            url: any;
+            method: any;
+            operationName: any;
+            query: any;
+            variables: any;
+            response: any;
+            timestamp: any;
+        }[];
         mediaUrls?: undefined;
         navigations?: undefined;
         apiCalls?: undefined;
@@ -125,23 +146,85 @@ export declare const networkHandlers: {
         error?: undefined;
         totalMessages?: undefined;
         websockets?: undefined;
-    }>;
-    cookie_manager(params?: any): Promise<{
+        har?: undefined;
+        recording?: undefined;
+        records?: undefined;
+    } | {
         success: boolean;
-        cookies: import("patchright-core").Cookie[];
-        message?: undefined;
+        count: number;
+        har: {
+            log: {
+                version: string;
+                creator: {
+                    name: string;
+                    version: string;
+                };
+                entries: {
+                    startedDateTime: string;
+                    request: {
+                        method: any;
+                        url: any;
+                        headers: {
+                            name: string;
+                            value: string;
+                        }[];
+                        postData: {
+                            text: any;
+                        } | undefined;
+                    };
+                    response: {
+                        status: any;
+                        content: {
+                            mimeType: any;
+                            text: any;
+                        };
+                    };
+                    time: number;
+                }[];
+            };
+        };
+        mediaUrls?: undefined;
+        navigations?: undefined;
+        apiCalls?: undefined;
+        interceptedApis?: undefined;
+        note?: undefined;
         error?: undefined;
+        totalMessages?: undefined;
+        websockets?: undefined;
+        graphql?: undefined;
+        recording?: undefined;
+        records?: undefined;
     } | {
         success: boolean;
-        message: string;
-        cookies?: undefined;
+        recording: boolean;
+        count: number;
+        records: import("../../types").NetworkRecord[];
+        mediaUrls?: undefined;
+        navigations?: undefined;
+        apiCalls?: undefined;
+        interceptedApis?: undefined;
+        note?: undefined;
+        error?: undefined;
+        totalMessages?: undefined;
+        websockets?: undefined;
+        graphql?: undefined;
+        har?: undefined;
+    }>;
+    extract_data(params?: any): Promise<any>;
+    replay_request(params: any): Promise<{
+        success: boolean;
+        result: {
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: string | null;
+        };
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
-        cookies?: undefined;
-        message?: undefined;
+        error: any;
+        result?: undefined;
     }>;
-    extract_data(params?: any): Promise<any>;
 };
 //# sourceMappingURL=network.d.ts.map

package/dist/src/mcp/handlers/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../src/mcp/handlers/network.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;4BACI,GAAG;;;;;;;;;8BAiHF,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAqTL,GAAG;;;;;;;;;;;;;;;;0BAwDL,GAAG;CAwqB/B,CAAC"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../src/mcp/handlers/network.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;4BACI,GAAG;;;;;;;;;8BAiHF,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4WP,GAAG;2BA6wBD,GAAG;;;;;;;;;;;;;;;CAuBjC,CAAC"}

package/dist/src/mcp/handlers/network.js

@@ -401,6 +401,57 @@ exports.networkHandlers = {
                     return { success: false, error: 'Failed to retrieve WebSocket data: ' + e.message, websockets: [] };
                 }
             }
+            // ====== FEATURE 4: GraphQL Inspector ======
+            case 'get_graphql': {
+                const gqlRecords = state_1.state.networkRecords.filter((r) => r.isApiCall && r.requestBody && (r.requestBody.includes('"query"') || r.requestBody.includes('query '))).map((r) => {
+                    let parsedQuery = null, parsedVariables = null, operationName = null;
+                    try {
+                        const body = JSON.parse(r.requestBody);
+                        parsedQuery = body.query;
+                        parsedVariables = body.variables;
+                        operationName = body.operationName;
+                    }
+                    catch (e) { }
+                    return {
+                        url: r.url,
+                        method: r.method,
+                        operationName: operationName || 'unknown',
+                        query: parsedQuery || r.requestBody,
+                        variables: parsedVariables,
+                        response: r.responseJson || r.responseBody,
+                        timestamp: r.timestamp
+                    };
+                });
+                return { success: true, count: gqlRecords.length, graphql: gqlRecords };
+            }
+            // ====== FEATURE 5: HAR Exporter ======
+            case 'export_har': {
+                // ponytail: minimal HAR 1.2 mapping without dependencies
+                const har = {
+                    log: {
+                        version: '1.2',
+                        creator: { name: 'Real Browser MCP', version: '1.0' },
+                        entries: state_1.state.networkRecords.filter((r) => r.type === 'response').map((r) => ({
+                            startedDateTime: new Date(r.timestamp).toISOString(),
+                            request: {
+                                method: r.method || 'GET',
+                                url: r.url,
+                                headers: Object.entries(r.headers || {}).map(([name, value]) => ({ name, value: String(value) })),
+                                postData: r.requestBody ? { text: r.requestBody } : undefined
+                            },
+                            response: {
+                                status: r.status || 200,
+                                content: {
+                                    mimeType: r.contentType || 'text/plain',
+                                    text: r.responseBody || ''
+                                }
+                            },
+                            time: 0
+                        }))
+                    }
+                };
+                return { success: true, count: har.log.entries.length, har };
+            }
         }
         let records = state_1.state.networkRecords;
         if (filter.resourceType) {
@@ -418,54 +469,6 @@ exports.networkHandlers = {
         }
         return { success: true, recording: state_1.state.isRecordingNetwork, count: records.length, records: records.slice(-200) };
     },
-    async cookie_manager(params = {}) {
-        const { page } = (0, state_1.requireBrowser)();
-        const { action = 'get', name, value, domain, expires } = params;
-        (0, state_1.notifyProgress)('cookie_manager', 'started', `Cookie action: ${action}`);
-        // Playwright/Patchright: cookies are managed via the BrowserContext, not the page
-        const context = page.context();
-        switch (action) {
-            case 'get': {
-                const cookies = await context.cookies();
-                (0, state_1.notifyProgress)('cookie_manager', 'completed', `Retrieved ${cookies.length} cookies`);
-                return { success: true, cookies: name ? cookies.filter(c => c.name === name) : cookies };
-            }
-            case 'set': {
-                await context.addCookies([{
-                        name,
-                        value,
-                        domain: domain || new URL(page.url()).hostname,
-                        path: '/',
-                        ...(expires ? { expires } : {})
-                    }]);
-                (0, state_1.notifyProgress)('cookie_manager', 'completed', `Cookie set: ${name}`);
-                return { success: true, message: `Cookie ${name} set` };
-            }
-            case 'delete': {
-                // Playwright has no per-cookie delete: clear all, then re-add the ones we keep
-                const toDelete = await context.cookies();
-                const remaining = name ? toDelete.filter(c => c.name !== name) : [];
-                const removedCount = toDelete.length - remaining.length;
-                await context.clearCookies();
-                if (remaining.length) {
-                    await context.addCookies(remaining.map(c => ({
-                        name: c.name, value: c.value, domain: c.domain, path: c.path,
-                        ...(c.expires && c.expires > 0 ? { expires: c.expires } : {}),
-                        httpOnly: c.httpOnly, secure: c.secure, sameSite: c.sameSite
-                    })));
-                }
-                (0, state_1.notifyProgress)('cookie_manager', 'completed', `Deleted ${removedCount} cookie(s)`);
-                return { success: true, message: `Deleted ${removedCount} cookie(s)` };
-            }
-            case 'clear': {
-                const allCookies = await context.cookies();
-                await context.clearCookies();
-                (0, state_1.notifyProgress)('cookie_manager', 'completed', `Cleared ${allCookies.length} cookies`);
-                return { success: true, message: `Cleared ${allCookies.length} cookies` };
-            }
-        }
-        return { success: false, error: 'Invalid action' };
-    },
     async extract_data(params = {}) {
         const { page } = (0, state_1.requireBrowser)();
         const { type = 'auto', pattern, selector, jsonPath, source = 'all', autoDecode = true, flags = 'gi', types = ['all'], includeTitle = true, includeCanonical = true, maxMatches = 100, maxJsonObjects = 50, waitForSelector = false, selectorTimeout = 10000 } = params;
@@ -699,8 +702,112 @@ exports.networkHandlers = {
             }
             return autoResults;
         };
+        // Helper: Extract Links (merged from link_harvester)
+        const extractLinks = async () => {
+            const { includeHidden = true, searchIframes = false } = params;
+            const doExtract = async (context) => {
+                return await context.evaluate(({ incHidden }) => {
+                    const allLinks = [];
+                    const seenUrls = new Set();
+                    const addLink = (href, text, source, element) => {
+                        if (!href || seenUrls.has(href))
+                            return;
+                        if (!href.startsWith('http') && !href.startsWith('//'))
+                            return;
+                        if (href.startsWith('//'))
+                            href = window.location.protocol + href;
+                        seenUrls.add(href);
+                        allLinks.push({
+                            href,
+                            text: (text || '').trim().substring(0, 100),
+                            source,
+                            hidden: element ? (element.offsetParent === null || getComputedStyle(element).display === 'none' || getComputedStyle(element).visibility === 'hidden') : false
+                        });
+                    };
+                    document.querySelectorAll('a[href]').forEach(a => addLink(a.href, a.textContent, 'anchor', a));
+                    const dataAttrs = ['data-href', 'data-url', 'data-link', 'data-src', 'data-file', 'data-download'];
+                    dataAttrs.forEach(attr => document.querySelectorAll(`[${attr}]`).forEach(el => addLink(el.getAttribute(attr), el.textContent, `${attr}`, el)));
+                    if (incHidden) {
+                        document.querySelectorAll('[onclick]').forEach(el => {
+                            const onclick = el.getAttribute('onclick');
+                            if (!onclick)
+                                return;
+                            const urlMatches = onclick.match(/https?:\/\/[^\s"'<>]+/gi) || [];
+                            urlMatches.forEach(url => addLink(url, el.textContent, 'onclick', el));
+                            const hrefMatch = onclick.match(/location\.href\s*=\s*['"]([^'"]+)['"]/);
+                            if (hrefMatch)
+                                addLink(hrefMatch[1], el.textContent, 'onclick-location', el);
+                            const openMatch = onclick.match(/window\.open\s*\(\s*['"]([^'"]+)['"]/);
+                            if (openMatch)
+                                addLink(openMatch[1], el.textContent, 'onclick-window-open', el);
+                        });
+                        const scripts = [...document.querySelectorAll('script')].slice(0, 20);
+                        scripts.forEach(script => {
+                            const content = script.textContent || '';
+                            const patterns = [
+                                /["']?(https?:\/\/[^"'\s<>]+\.(mp4|mkv|avi|m3u8|mpd|zip|rar|pdf))[^"'\s<>]*["']?/gi,
+                                /download[_-]?url\s*[:=]\s*["']([^"']+)["']/gi,
+                                /file\s*[:=]\s*["']([^"']+)["']/gi
+                            ];
+                            patterns.forEach(pattern => {
+                                let match;
+                                while ((match = pattern.exec(content)) !== null)
+                                    addLink(match[1], 'script-extracted', 'script', null);
+                            });
+                        });
+                    }
+                    document.querySelectorAll('a[href^="javascript:"]').forEach(a => {
+                        const match = a.getAttribute('href')?.match(/https?:\/\/[^\s"'<>]+/gi);
+                        if (match)
+                            match.forEach(url => addLink(url, a.textContent, 'javascript-href', a));
+                    });
+                    document.querySelectorAll('input[type="hidden"]').forEach((input) => {
+                        if (input.value && (input.value.startsWith('http') || input.value.startsWith('//')))
+                            addLink(input.value, input.name || input.id, 'hidden-input', input);
+                    });
+                    const metaRefresh = document.querySelector('meta[http-equiv="refresh"]');
+                    if (metaRefresh) {
+                        const match = metaRefresh.getAttribute('content')?.match(/url=(.+)/i);
+                        if (match)
+                            addLink(match[1].trim().replace(/['"]/g, ''), 'meta-refresh', 'meta', null);
+                    }
+                    document.querySelectorAll('iframe[src]').forEach((iframe) => addLink(iframe.src, 'iframe', 'iframe', iframe));
+                    return allLinks;
+                }, { incHidden: includeHidden }).catch(() => []);
+            };
+            let links = await doExtract(page);
+            if (searchIframes) {
+                const frames = page.frames();
+                for (let i = 1; i < frames.length && i < 5; i++) {
+                    try {
+                        const frame = frames[i];
+                        if (frame.url() && frame.url() !== 'about:blank') {
+                            const frameLinks = await doExtract(frame);
+                            frameLinks.forEach((link) => link.source = `iframe:${link.source}`);
+                            links = [...links, ...frameLinks];
+                        }
+                    }
+                    catch (e) { }
+                }
+            }
+            if (!includeHidden)
+                links = links.filter((link) => !link.hidden);
+            const seen = new Set();
+            return links.filter((link) => {
+                if (seen.has(link.href))
+                    return false;
+                seen.add(link.href);
+                return true;
+            });
+        };
         // Main switch based on type
         switch (type) {
+            case 'links': {
+                const links = await extractLinks();
+                results.extracted = { count: links.length, links };
+                (0, state_1.notifyProgress)('extract_data', 'completed', `Links: ${links.length} extracted`);
+                break;
+            }
             case 'regex': {
                 if (!pattern) {
                     return { success: false, error: 'Pattern is required for regex extraction' };
@@ -728,7 +835,7 @@ exports.networkHandlers = {
             }
             case 'structured': {
                 if (!selector) {
-                    return { success: false, error: 'Selector is required for structured extraction' };
+                    return { success: false, error: 'Selector is required for structured extraction. 💡 AI HINT: Run see_page(annotate: true) first to discover valid selectors or annotation IDs.' };
                 }
                 results.extracted = await extractStructured(selector, waitForSelector, selectorTimeout);
                 if (results.extracted.error) {
@@ -1143,6 +1250,28 @@ exports.networkHandlers = {
                 return { success: false, error: `Unknown type: ${type}. Supported: regex, json, meta, structured, auto, deobfuscate, apiDiscovery, decrypt` };
         }
         return results;
+    },
+    async replay_request(params) {
+        const { page } = (0, state_1.requireBrowser)();
+        const { url, method = 'GET', headers, body } = params;
+        (0, state_1.notifyProgress)('replay_request', 'started', `Replaying ${method} to ${url}`);
+        // ponytail: reuse page.evaluate to fire native fetch, bypasses CORS & uses exact browser context auth/cookies
+        try {
+            const result = await page.evaluate(async ({ u, m, h, b }) => {
+                const res = await fetch(u, { method: m, headers: h, body: b });
+                return {
+                    status: res.status,
+                    headers: Object.fromEntries(res.headers.entries()),
+                    body: await res.text().catch(() => null)
+                };
+            }, { u: url, m: method, h: headers || {}, b: body });
+            (0, state_1.notifyProgress)('replay_request', 'completed', `Replay finished with status ${result.status}`);
+            return { success: true, result };
+        }
+        catch (e) {
+            (0, state_1.notifyProgress)('replay_request', 'error', `Replay failed: ${e.message}`);
+            return { success: false, error: e.message };
+        }
     }
 };
 //# sourceMappingURL=network.js.map