real-browser-mcp-server 1.5.1 → 2.0.0

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.networkHandlers = void 0;
 const state_1 = require("./state");
-// Auto-generated network handlers
+const network_recorder_1 = require("./network-recorder");
+const network_extractors_1 = require("./network-extractors");
 exports.networkHandlers = {
     async redirect_tracer(params) {
         const { page } = (0, state_1.requireBrowser)();
@@ -11,29 +12,19 @@ exports.networkHandlers = {
         const redirects = [];
         const jsNavigations = [];
         let currentUrl = url;
-        // HTTP redirect handler
         const responseHandler = (response) => {
             if ([301, 302, 303, 307, 308].includes(response.status())) {
-                redirects.push({
-                    url: response.url(),
-                    status: response.status(),
-                    type: 'http',
-                    headers: includeHeaders ? response.headers() : undefined
-                });
-                (0, state_1.notifyProgress)('redirect_tracer', 'progress', `HTTP Redirect ${redirects.length}: ${response.status()}`, { status: response.status() });
+                if (redirects.length < maxRedirects) {
+                    redirects.push({ url: response.url(), status: response.status(), type: 'http', headers: includeHeaders ? response.headers() : undefined });
+                    (0, state_1.notifyProgress)('redirect_tracer', 'progress', `HTTP Redirect ${redirects.length}: ${response.status()}`, { status: response.status() });
+                }
             }
         };
-        // JS/Navigation handler for tracking window.location changes
         const frameNavigatedHandler = (frame) => {
             if (frame === page.mainFrame()) {
                 const newUrl = frame.url();
                 if (newUrl !== currentUrl && newUrl !== 'about:blank') {
-                    jsNavigations.push({
-                        url: newUrl,
-                        type: 'js_navigation',
-                        fromUrl: currentUrl,
-                        timestamp: Date.now()
-                    });
+                    jsNavigations.push({ url: newUrl, type: 'js_navigation', fromUrl: currentUrl, timestamp: Date.now() });
                     (0, state_1.notifyProgress)('redirect_tracer', 'progress', `JS Navigation: ${newUrl}`, { type: 'js' });
                     currentUrl = newUrl;
                 }
@@ -43,9 +34,7 @@ exports.networkHandlers = {
         page.on('framenavigated', frameNavigatedHandler);
         try {
             await page.goto(url, { waitUntil: 'networkidle', timeout });
-            // If followJS is enabled, wait a bit and check for meta refreshes and JS redirects
             if (followJS) {
-                // Check for meta refresh tags
                 const metaRefresh = await page.evaluate(() => {
                     const meta = document.querySelector('meta[http-equiv="refresh"]');
                     if (meta) {
@@ -55,14 +44,8 @@ exports.networkHandlers = {
                     }
                     return null;
                 }).catch(() => null);
-                if (metaRefresh) {
-                    jsNavigations.push({
-                        url: metaRefresh,
-                        type: 'meta_refresh',
-                        fromUrl: page.url()
-                    });
-                }
-                // Extract any onclick/href javascript: URLs
+                if (metaRefresh)
+                    jsNavigations.push({ url: metaRefresh, type: 'meta_refresh', fromUrl: page.url() });
                 const jsLinks = await page.evaluate(() => {
                     const links = [];
                     document.querySelectorAll('a[href^="javascript:"], [onclick]').forEach(el => {
@@ -73,9 +56,8 @@ exports.networkHandlers = {
                             if (match)
                                 links.push({ url: match[1], type: 'onclick' });
                         }
-                        if (href && href.includes('location')) {
+                        if (href && href.includes('location'))
                             links.push({ url: href, type: 'javascript_href' });
-                        }
                     });
                     return links;
                 }).catch(() => []);
@@ -87,1183 +69,42 @@ exports.networkHandlers = {
         }
         page.off('response', responseHandler);
         page.off('framenavigated', frameNavigatedHandler);
-        const allRedirects = [
-            ...redirects,
-            ...jsNavigations.filter(nav => nav.url && nav.url.startsWith('http'))
-        ];
+        const allRedirects = [...redirects, ...jsNavigations.filter(nav => nav.url && nav.url.startsWith('http'))];
         (0, state_1.notifyProgress)('redirect_tracer', 'completed', `Found ${redirects.length} HTTP + ${jsNavigations.length} JS redirects`, { httpRedirects: redirects.length, jsNavigations: jsNavigations.length, finalUrl: page.url() });
-        return {
-            success: true,
-            originalUrl: url,
-            finalUrl: page.url(),
-            redirectCount: allRedirects.length,
-            httpRedirects: redirects,
-            jsNavigations: jsNavigations,
-            allRedirects: allRedirects
-        };
+        return { success: true, originalUrl: url, finalUrl: page.url(), redirectCount: allRedirects.length, httpRedirects: redirects, jsNavigations, allRedirects };
     },
     async network_recorder(params = {}) {
         const { page } = (0, state_1.requireBrowser)();
-        const { action = 'get', filter = {}, captureResponses = false } = params;
+        const { action = 'get', filter = {}, captureXhrBody = false } = params;
         switch (action) {
-            case 'start':
-                state_1.state.networkRecords = [];
-                state_1.state.isRecordingNetwork = true;
-                // ====== FEATURE 2: Pre-page-load Runtime API Interception ======
-                // Inject BEFORE any JS runs — catches calls from obfuscated/webpack code
-                try {
-                    await page.addInitScript(() => {
-                        window.__interceptedApis = [];
-                        window.__wsMessages = [];
-                        // --- Monkey-patch fetch ---
-                        const origFetch = window.fetch;
-                        window.fetch = function (...args) {
-                            try {
-                                const url = typeof args[0] === 'string' ? args[0] : (args[0]?.url || String(args[0]));
-                                const opts = args[1] || {};
-                                const entry = {
-                                    type: 'fetch', url, method: opts.method || 'GET',
-                                    headers: opts.headers ? JSON.parse(JSON.stringify(opts.headers)) : null,
-                                    body: typeof opts.body === 'string' ? opts.body.substring(0, 2000) : null,
-                                    timestamp: Date.now()
-                                };
-                                window.__interceptedApis.push(entry);
-                            }
-                            catch (e) { }
-                            return origFetch.apply(this, args);
-                        };
-                        // --- Monkey-patch XMLHttpRequest ---
-                        const origOpen = XMLHttpRequest.prototype.open;
-                        const origSend = XMLHttpRequest.prototype.send;
-                        const origSetHeader = XMLHttpRequest.prototype.setRequestHeader;
-                        XMLHttpRequest.prototype.open = function (method, url, ...rest) {
-                            this.__iUrl = url;
-                            this.__iMethod = method;
-                            this.__iHeaders = {};
-                            return origOpen.apply(this, [method, url, ...rest]);
-                        };
-                        XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
-                            if (this.__iHeaders)
-                                this.__iHeaders[name] = value;
-                            return origSetHeader.apply(this, [name, value]);
-                        };
-                        XMLHttpRequest.prototype.send = function (body) {
-                            try {
-                                window.__interceptedApis.push({
-                                    type: 'xhr', url: this.__iUrl, method: this.__iMethod,
-                                    headers: this.__iHeaders || null,
-                                    body: typeof body === 'string' ? body.substring(0, 2000) : null,
-                                    timestamp: Date.now()
-                                });
-                            }
-                            catch (e) { }
-                            return origSend.apply(this, [body]);
-                        };
-                        // --- Monkey-patch navigator.sendBeacon ---
-                        if (navigator.sendBeacon) {
-                            const origBeacon = navigator.sendBeacon.bind(navigator);
-                            navigator.sendBeacon = function (url, data) {
-                                try {
-                                    window.__interceptedApis.push({
-                                        type: 'beacon', url, method: 'POST',
-                                        body: typeof data === 'string' ? data.substring(0, 2000) : null,
-                                        timestamp: Date.now()
-                                    });
-                                }
-                                catch (e) { }
-                                return origBeacon(url, data);
-                            };
-                        }
-                        // ====== FEATURE 3: WebSocket Recording ======
-                        const OrigWS = window.WebSocket;
-                        window.WebSocket = function (url, protocols) {
-                            const ws = protocols ? new OrigWS(url, protocols) : new OrigWS(url);
-                            const wsId = window.__wsMessages.length;
-                            const wsEntry = { id: wsId, url, openedAt: Date.now(), messages: [], status: 'connecting' };
-                            window.__wsMessages.push(wsEntry);
-                            ws.addEventListener('open', () => { wsEntry.status = 'open'; });
-                            ws.addEventListener('close', (e) => { wsEntry.status = 'closed'; wsEntry.closedAt = Date.now(); wsEntry.closeCode = e.code; });
-                            ws.addEventListener('error', () => { wsEntry.status = 'error'; });
-                            ws.addEventListener('message', (e) => {
-                                try {
-                                    let data = e.data;
-                                    let dataType = 'text';
-                                    if (data instanceof Blob) {
-                                        dataType = 'blob';
-                                        data = `[Blob ${data.size} bytes]`;
-                                    }
-                                    else if (data instanceof ArrayBuffer) {
-                                        dataType = 'binary';
-                                        data = `[ArrayBuffer ${data.byteLength} bytes]`;
-                                    }
-                                    else if (typeof data === 'string' && data.length > 5000) {
-                                        data = data.substring(0, 5000) + '...';
-                                    }
-                                    wsEntry.messages.push({ direction: 'received', data, dataType, timestamp: Date.now() });
-                                }
-                                catch (e) { }
-                            });
-                            // Intercept send
-                            const origWsSend = ws.send.bind(ws);
-                            ws.send = function (data) {
-                                try {
-                                    let sendData = data;
-                                    let dataType = 'text';
-                                    if (data instanceof Blob) {
-                                        dataType = 'blob';
-                                        sendData = `[Blob ${data.size} bytes]`;
-                                    }
-                                    else if (data instanceof ArrayBuffer) {
-                                        dataType = 'binary';
-                                        sendData = `[ArrayBuffer ${data.byteLength} bytes]`;
-                                    }
-                                    else if (typeof data === 'string' && data.length > 5000) {
-                                        sendData = data.substring(0, 5000) + '...';
-                                    }
-                                    wsEntry.messages.push({ direction: 'sent', data: sendData, dataType, timestamp: Date.now() });
-                                }
-                                catch (e) { }
-                                return origWsSend(data);
-                            };
-                            return ws;
-                        };
-                        window.WebSocket.prototype = OrigWS.prototype;
-                        window.WebSocket.CONNECTING = OrigWS.CONNECTING;
-                        window.WebSocket.OPEN = OrigWS.OPEN;
-                        window.WebSocket.CLOSING = OrigWS.CLOSING;
-                        window.WebSocket.CLOSED = OrigWS.CLOSED;
-                    });
-                }
-                catch (e) { /* addInitScript may fail on already-loaded pages, that's OK */ }
-                // Request handler
-                page.on('request', req => {
-                    if (state_1.state.isRecordingNetwork) {
-                        state_1.state.networkRecords.push({
-                            type: 'request',
-                            url: req.url(),
-                            method: req.method(),
-                            resourceType: req.resourceType(),
-                            headers: req.headers(),
-                            timestamp: Date.now()
-                        });
-                    }
-                });
-                // Response handler for capturing video/media URLs
-                page.on('response', async (res) => {
-                    if (state_1.state.isRecordingNetwork) {
-                        const url = res.url();
-                        const contentType = res.headers()['content-type'] || '';
-                        const isMedia = contentType.includes('video') ||
-                            contentType.includes('audio') ||
-                            contentType.includes('mpegurl') ||
-                            url.includes('.m3u8') ||
-                            url.includes('.mpd') ||
-                            url.includes('.mp4') ||
-                            url.includes('.ts');
-                        const isApiCall = contentType.includes('json') ||
-                            contentType.includes('x-www-form-urlencoded') ||
-                            url.match(/\.(php|api|json|do|action)($|\?)/) ||
-                            (res.request().resourceType() === 'xhr') ||
-                            (res.request().resourceType() === 'fetch');
-                        const isBinaryBody = isMedia ||
-                            contentType.includes('octet-stream') ||
-                            contentType.includes('application/pdf') ||
-                            contentType.includes('image/') ||
-                            contentType.includes('font/') ||
-                            contentType.includes('zip') ||
-                            contentType.includes('rar');
-                        const record = {
-                            type: 'response',
-                            url: url,
-                            method: res.request().method(),
-                            status: res.status(),
-                            contentType: contentType,
-                            isMedia: isMedia,
-                            isApiCall: isApiCall,
-                            resourceType: res.request().resourceType(),
-                            timestamp: Date.now()
-                        };
-                        // For media URLs, try to get more details
-                        if (isMedia) {
-                            record.mediaType = url.includes('.m3u8') ? 'hls' :
-                                url.includes('.mpd') ? 'dash' :
-                                    url.includes('.mp4') ? 'mp4' : 'other';
-                        }
-                        // Capture request/response body for API calls
-                        if (isApiCall) {
-                            try {
-                                const postData = res.request().postData();
-                                if (postData)
-                                    record.requestBody = postData.substring(0, 2000);
-                                if (isBinaryBody) {
-                                    record.responseBody = `[binary/media body omitted: ${contentType || 'unknown content-type'}]`;
-                                }
-                                else {
-                                    const responseBody = await res.text().catch(() => null);
-                                    if (responseBody) {
-                                        record.responseBody = responseBody.substring(0, 5000);
-                                        record.responseTruncated = responseBody.length > 5000;
-                                        try {
-                                            record.responseJson = JSON.parse(responseBody);
-                                        }
-                                        catch (e) { }
-                                    }
-                                }
-                            }
-                            catch (e) { }
-                        }
-                        state_1.state.networkRecords.push(record);
-                    }
-                });
-                // Frame navigation handler for JS redirects
-                page.on('framenavigated', frame => {
-                    if (state_1.state.isRecordingNetwork && frame === page.mainFrame()) {
-                        state_1.state.networkRecords.push({
-                            type: 'navigation',
-                            url: frame.url(),
-                            timestamp: Date.now()
-                        });
-                    }
-                });
-                (0, state_1.notifyProgress)('network_recorder', 'started', 'Power recording started (requests + responses + API interception + WebSocket + navigations)');
-                break;
+            case 'start': return (0, network_recorder_1.startRecording)(page).then(() => ({ success: true, message: 'Recording started' }));
             case 'stop':
-                state_1.state.isRecordingNetwork = false;
-                (0, state_1.notifyProgress)('network_recorder', 'completed', `Recording stopped: ${state_1.state.networkRecords.length} events captured`);
-                break;
+                (0, network_recorder_1.stopRecording)();
+                return { success: true };
             case 'clear':
-                state_1.state.networkRecords = [];
-                // Also clear intercepted data
-                try {
-                    await page.evaluate(() => { window.__interceptedApis = []; window.__wsMessages = []; });
-                }
-                catch (e) { }
-                (0, state_1.notifyProgress)('network_recorder', 'completed', 'Network records cleared');
-                break;
-            case 'get_media':
-                // Special action to get only media URLs
-                const mediaRecords = state_1.state.networkRecords.filter(r => r.isMedia);
-                return {
-                    success: true,
-                    count: mediaRecords.length,
-                    mediaUrls: mediaRecords.map(r => ({ url: r.url, type: r.mediaType }))
-                };
-            case 'get_navigations':
-                // Get only navigation events (for tracking JS redirects)
-                const navRecords = state_1.state.networkRecords.filter(r => r.type === 'navigation');
-                return {
-                    success: true,
-                    count: navRecords.length,
-                    navigations: navRecords
-                };
-            case 'get_api_calls': {
-                const apiRecords = state_1.state.networkRecords.filter(r => r.isApiCall);
-                return {
-                    success: true,
-                    count: apiRecords.length,
-                    apiCalls: apiRecords.map(r => ({
-                        url: r.url, method: r.method || 'GET', status: r.status,
-                        contentType: r.contentType, resourceType: r.resourceType,
-                        requestBody: r.requestBody || null, responseBody: r.responseBody || null,
-                        responseJson: r.responseJson || null, timestamp: r.timestamp
-                    }))
-                };
-            }
-            // ====== FEATURE 2: Get Intercepted APIs (from monkey-patched fetch/XHR/beacon) ======
-            case 'get_intercepted_apis': {
-                try {
-                    const intercepted = await page.evaluate(() => window.__interceptedApis || []);
-                    return {
-                        success: true,
-                        count: intercepted.length,
-                        interceptedApis: intercepted,
-                        note: 'These are runtime-intercepted API calls captured via monkey-patched fetch/XHR/sendBeacon (pre-page-load injection)'
-                    };
-                }
-                catch (e) {
-                    return { success: false, error: 'Failed to retrieve intercepted APIs: ' + e.message, interceptedApis: [] };
-                }
-            }
-            // ====== FEATURE 3: Get WebSocket Messages ======
-            case 'get_websockets': {
-                try {
-                    const wsData = await page.evaluate(() => window.__wsMessages || []);
-                    const totalMessages = wsData.reduce((sum, ws) => sum + ws.messages.length, 0);
-                    return {
-                        success: true,
-                        count: wsData.length,
-                        totalMessages: totalMessages,
-                        websockets: wsData,
-                        note: 'WebSocket connections and messages captured via constructor monkey-patch'
-                    };
-                }
-                catch (e) {
-                    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) {
-            records = records.filter(r => r.resourceType === filter.resourceType);
+                await (0, network_recorder_1.clearRecording)(page);
+                return { success: true };
+            case 'get_media': return (0, network_recorder_1.getMediaRecords)();
+            case 'get_navigations': return (0, network_recorder_1.getNavigationRecords)();
+            case 'get_api_calls': return (0, network_recorder_1.getApiCallRecords)();
+            case 'get_intercepted_apis': return await (0, network_recorder_1.getInterceptedApis)(page);
+            case 'get_websockets': return await (0, network_recorder_1.getWebSocketRecords)(page);
+            case 'get_graphql': return (0, network_recorder_1.getGraphQLRecords)();
+            case 'export_har': return (0, network_recorder_1.exportHAR)();
         }
-        if (filter.urlPattern) {
-            const regex = new RegExp(filter.urlPattern);
-            records = records.filter(r => regex.test(r.url));
-        }
-        if (filter.type) {
-            records = records.filter(r => r.type === filter.type);
-        }
-        if (filter.mediaOnly) {
-            records = records.filter(r => r.isMedia);
-        }
-        return { success: true, recording: state_1.state.isRecordingNetwork, count: records.length, records: records.slice(-200) };
+        return (0, network_recorder_1.getFilteredRecords)(filter);
     },
     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;
-        (0, state_1.notifyProgress)('extract_data', 'started', `Extracting data (type: ${type})...`);
-        const results = {
-            success: true,
-            type,
-            url: page.url(),
-            extracted: {}
-        };
-        // Helper: Extract regex matches
-        const extractRegex = async (regexPattern, regexFlags, contentSource) => {
-            let content;
-            if (contentSource === 'html') {
-                content = await page.content();
-            }
-            else if (contentSource === 'scripts') {
-                content = await page.$$eval('script', scripts => scripts.map(s => s.textContent).join('\n'));
-            }
-            else if (contentSource === 'text') {
-                content = await page.evaluate(() => document.body.innerText);
-            }
-            else {
-                // 'all' - search in both HTML and scripts
-                const html = await page.content();
-                const scripts = await page.$$eval('script', scripts => scripts.map(s => s.textContent).join('\n'));
-                content = html + '\n' + scripts;
-            }
-            const regex = new RegExp(regexPattern, regexFlags);
-            const matches = content.match(regex) || [];
-            return {
-                pattern: regexPattern,
-                flags: regexFlags,
-                matchCount: matches.length,
-                matches: matches.slice(0, maxMatches)
-            };
-        };
-        // Helper: Extract JSON data
-        const extractJson = async (jsonSource, sel, path) => {
-            const jsonData = [];
-            if (jsonSource === 'ld+json') {
-                const ldJson = await page.$$eval('script[type="application/ld+json"]', scripts => scripts.map(s => {
-                    try {
-                        return JSON.parse(s.textContent);
-                    }
-                    catch {
-                        return null;
-                    }
-                }).filter(Boolean));
-                jsonData.push(...ldJson);
-            }
-            else if (jsonSource === 'scripts') {
-                const content = await page.$$eval('script', scripts => scripts.map(s => s.textContent).join('\n'));
-                // Look for JSON objects in scripts
-                const jsonRegex = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}|\[[^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*\]/g;
-                const matches = content.match(jsonRegex) || [];
-                for (const match of matches.slice(0, maxJsonObjects)) {
-                    try {
-                        const parsed = JSON.parse(match);
-                        jsonData.push(parsed);
-                    }
-                    catch { }
-                }
-            }
-            else if (jsonSource === 'api') {
-                // Try to find API responses in page data
-                const apiData = await page.evaluate(() => {
-                    const data = [];
-                    // Look for common API data storage patterns
-                    if (window.__DATA__)
-                        data.push(window.__DATA__);
-                    if (window.__INITIAL_STATE__)
-                        data.push(window.__INITIAL_STATE__);
-                    if (window.__APP_DATA__)
-                        data.push(window.__APP_DATA__);
-                    if (window.data)
-                        data.push(window.data);
-                    if (window.config)
-                        data.push(window.config);
-                    return data;
-                });
-                jsonData.push(...apiData);
-            }
-            else if (sel) {
-                try {
-                    const text = await page.$eval(sel, el => el.textContent);
-                    const parsed = JSON.parse(text);
-                    jsonData.push(parsed);
-                }
-                catch { }
-            }
-            else {
-                // 'page' - try all sources
-                const ldJson = await page.$$eval('script[type="application/ld+json"]', scripts => scripts.map(s => {
-                    try {
-                        return JSON.parse(s.textContent);
-                    }
-                    catch {
-                        return null;
-                    }
-                }).filter(Boolean));
-                jsonData.push(...ldJson);
-            }
-            // Apply JSONPath if specified
-            if (path && jsonData.length > 0) {
-                // Simple JSONPath implementation
-                const getPath = (obj, pathStr) => {
-                    const parts = pathStr.replace(/^\$\./, '').split('.');
-                    let current = obj;
-                    for (const part of parts) {
-                        if (current === null || current === undefined)
-                            return undefined;
-                        if (part.includes('[') && part.includes(']')) {
-                            const arrName = part.substring(0, part.indexOf('['));
-                            const idx = parseInt(part.match(/\[(\d+)\]/)?.[1] || '0');
-                            current = current[arrName]?.[idx];
-                        }
-                        else {
-                            current = current[part];
-                        }
-                    }
-                    return current;
-                };
-                return jsonData.map(obj => ({
-                    original: obj,
-                    extracted: getPath(obj, path)
-                }));
-            }
-            return jsonData;
-        };
-        // Helper: Extract meta tags
-        const extractMeta = async (metaTypes) => {
-            const meta = await page.evaluate(([includeTitle, includeCanonical]) => {
-                const result = { meta: {}, og: {}, twitter: {} };
-                document.querySelectorAll('meta').forEach(tag => {
-                    const name = tag.getAttribute('name') || tag.getAttribute('property');
-                    const content = tag.getAttribute('content');
-                    if (name && content) {
-                        if (name.startsWith('og:')) {
-                            result.og[name.replace('og:', '')] = content;
-                        }
-                        else if (name.startsWith('twitter:')) {
-                            result.twitter[name.replace('twitter:', '')] = content;
-                        }
-                        else {
-                            result.meta[name] = content;
-                        }
-                    }
-                });
-                if (includeTitle) {
-                    result.title = document.title;
-                }
-                if (includeCanonical) {
-                    result.canonical = document.querySelector('link[rel="canonical"]')?.href;
-                }
-                return result;
-            }, [includeTitle, includeCanonical]);
-            // Filter by requested types
-            const filtered = {};
-            if (metaTypes.includes('all')) {
-                return meta;
-            }
-            if (metaTypes.includes('meta'))
-                filtered.meta = meta.meta;
-            if (metaTypes.includes('og'))
-                filtered.og = meta.og;
-            if (metaTypes.includes('twitter'))
-                filtered.twitter = meta.twitter;
-            if (includeTitle)
-                filtered.title = meta.title;
-            if (includeCanonical)
-                filtered.canonical = meta.canonical;
-            return filtered;
-        };
-        // Helper: Extract structured data from selector
-        const extractStructured = async (sel, wait = false, timeout = 10000) => {
-            if (wait) {
-                await page.waitForSelector(sel, { timeout });
-            }
-            const element = await page.$(sel);
-            if (!element) {
-                return { error: `Element not found: ${sel}` };
-            }
-            const data = await element.evaluate(el => ({
-                tagName: el.tagName,
-                text: el.innerText,
-                html: el.innerHTML,
-                attributes: Object.fromEntries([...el.attributes].map(a => [a.name, a.value])),
-                childCount: el.children.length,
-                boundingBox: el.getBoundingClientRect ? {
-                    x: el.getBoundingClientRect().x,
-                    y: el.getBoundingClientRect().y,
-                    width: el.getBoundingClientRect().width,
-                    height: el.getBoundingClientRect().height
-                } : null
-            }));
-            return data;
-        };
-        // Helper: Auto-detect and extract all
-        const extractAuto = async () => {
-            const autoResults = {
-                meta: null,
-                json: null,
-                structured: null,
-                patterns: []
-            };
-            // Extract meta tags
-            try {
-                autoResults.meta = await extractMeta(['all']);
-            }
-            catch (e) { }
-            // Extract JSON-LD
-            try {
-                autoResults.json = await extractJson('ld+json');
-            }
-            catch (e) { }
-            // Look for common data patterns
-            const commonPatterns = [
-                { name: 'emails', pattern: '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' },
-                { name: 'phones', pattern: '(\+?1?[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}' },
-                { name: 'urls', pattern: 'https?://[^\s<>"{}|\\^`\[\]]+' },
-                { name: 'ipv4', pattern: '\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b' }
-            ];
-            const pageText = await page.evaluate(() => document.body.innerText);
-            for (const { name, pattern } of commonPatterns) {
-                const regex = new RegExp(pattern, 'gi');
-                const matches = [...new Set(pageText.match(regex) || [])];
-                if (matches.length > 0) {
-                    autoResults.patterns.push({ type: name, count: matches.length, samples: matches.slice(0, 10) });
-                }
-            }
-            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' };
-                }
-                results.extracted = await extractRegex(pattern, flags, source);
-                (0, state_1.notifyProgress)('extract_data', 'completed', `Regex: ${results.extracted.matchCount} matches`);
-                break;
-            }
-            case 'json': {
-                results.extracted = await extractJson(source, selector, jsonPath);
-                results.count = Array.isArray(results.extracted) ? results.extracted.length : 0;
-                (0, state_1.notifyProgress)('extract_data', 'completed', `JSON: ${results.count} objects`);
-                break;
-            }
-            case 'meta': {
-                results.extracted = await extractMeta(types);
-                const tagCount = Object.values(results.extracted).reduce((sum, val) => {
-                    if (typeof val === 'object' && val !== null) {
-                        return sum + Object.keys(val).length;
-                    }
-                    return sum + (val ? 1 : 0);
-                }, 0);
-                (0, state_1.notifyProgress)('extract_data', 'completed', `Meta: ${tagCount} tags`);
-                break;
-            }
-            case 'structured': {
-                if (!selector) {
-                    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) {
-                    results.success = false;
-                    results.error = results.extracted.error;
-                    delete results.extracted;
-                }
-                (0, state_1.notifyProgress)('extract_data', 'completed', results.success ? 'Structured data extracted' : 'Extraction failed');
-                break;
-            }
-            case 'auto': {
-                results.extracted = await extractAuto();
-                const summary = [];
-                if (results.extracted.meta)
-                    summary.push('meta');
-                if (results.extracted.json?.length)
-                    summary.push('json');
-                if (results.extracted.patterns?.length)
-                    summary.push('patterns');
-                (0, state_1.notifyProgress)('extract_data', 'completed', `Auto: ${summary.join(', ')}`);
-                break;
-            }
-            case 'deobfuscate': {
-                (0, state_1.notifyProgress)('extract_data', 'in_progress', 'Deobfuscating JavaScript (enhanced)...');
-                const scriptContents = await page.evaluate(() => {
-                    return Array.from(document.querySelectorAll('script')).map(s => s.textContent).join('\n');
-                }).catch(() => '');
-                const externalScripts = await page.evaluate(() => {
-                    return Array.from(document.querySelectorAll('script[src]')).map(s => s.src);
-                }).catch(() => []);
-                let allJs = scriptContents;
-                for (const src of externalScripts.slice(0, 10)) {
-                    try {
-                        const resp = await fetch(src);
-                        allJs += '\n' + await resp.text();
-                    }
-                    catch (e) { }
-                }
-                const deobfuscated = {
-                    stringArrays: [], decodedStrings: [], functionMappings: [],
-                    apiEndpoints: [], urls: [], fetchCalls: [],
-                    webpackModules: [], evalUnpacked: [], resolvedConcats: [], unicodeDecoded: []
-                };
-                // 1. Original _0x style string arrays
-                const arrayPattern = /(?:const|var|let)\s+(_0x[a-f0-9]+)\s*=\s*\[([^\]]{20,})\]/g;
-                let match;
-                while ((match = arrayPattern.exec(allJs)) !== null) {
-                    const varName = match[1];
-                    try {
-                        const items = match[2].match(/'([^']*)'|"([^"]*)"/g) || [];
-                        const decoded = items.map(s => s.replace(/^['"]|['"]$/g, ''));
-                        deobfuscated.stringArrays.push({ variable: varName, count: decoded.length, strings: decoded });
-                        deobfuscated.decodedStrings.push(...decoded);
-                    }
-                    catch (e) { }
-                }
-                // 2. Hex-encoded strings
-                const hexStrings = [...new Set((allJs.match(/(?:'(?:\\x[0-9a-f]{2})+[^']*'|"(?:\\x[0-9a-f]{2})+[^"]*")/gi) || []))];
-                for (const hs of hexStrings.slice(0, 50)) {
-                    try {
-                        const decoded = hs.slice(1, -1).replace(/\\x([0-9a-f]{2})/gi, (_, h) => String.fromCharCode(parseInt(h, 16)));
-                        if (decoded.length > 2)
-                            deobfuscated.decodedStrings.push(decoded);
-                    }
-                    catch (e) { }
-                }
-                // 3. NEW: Unicode escape sequences (\u0066\u0065\u0074\u0063\u0068 → fetch)
-                const unicodePattern = /(?:'(?:\\u[0-9a-f]{4})+[^']*'|"(?:\\u[0-9a-f]{4})+[^"]*")/gi;
-                const unicodeMatches = allJs.match(unicodePattern) || [];
-                for (const um of unicodeMatches.slice(0, 50)) {
-                    try {
-                        const decoded = um.slice(1, -1).replace(/\\u([0-9a-f]{4})/gi, (_, h) => String.fromCharCode(parseInt(h, 16)));
-                        if (decoded.length > 1) {
-                            deobfuscated.unicodeDecoded.push(decoded);
-                            deobfuscated.decodedStrings.push(decoded);
-                        }
-                    }
-                    catch (e) { }
-                }
-                // 4. NEW: Eval unpacker — eval(function(p,a,c,k,e,d){...})
-                const evalPattern = /eval\s*\(\s*function\s*\(\s*p\s*,\s*a\s*,\s*c\s*,\s*k\s*,\s*e\s*,?\s*[dr]?\s*\)\s*\{[^}]*\}\s*\(\s*'([^']*)'(?:\s*,\s*(\d+)){2}\s*,\s*'([^']*)'/g;
-                let evalMatch;
-                while ((evalMatch = evalPattern.exec(allJs)) !== null) {
-                    try {
-                        const p = evalMatch[1], a = parseInt(evalMatch[2]) || 62;
-                        const keywords = evalMatch[3].split('|');
-                        const unpacked = p.replace(/\b\w+\b/g, w => {
-                            const n = parseInt(w, a);
-                            return (n < keywords.length && keywords[n]) ? keywords[n] : w;
-                        });
-                        deobfuscated.evalUnpacked.push(unpacked.substring(0, 3000));
-                        // Extract strings from unpacked code
-                        const unpackedStrings = unpacked.match(/['"]([^'"]{3,})['"]/g) || [];
-                        for (const s of unpackedStrings.slice(0, 100)) {
-                            deobfuscated.decodedStrings.push(s.replace(/^['"]|['"]$/g, ''));
-                        }
-                    }
-                    catch (e) { }
-                }
-                // Also handle simpler eval patterns
-                const simpleEval = /eval\s*\(\s*['"]([^'"]{10,})['"]\s*\)/g;
-                let seMatch;
-                while ((seMatch = simpleEval.exec(allJs)) !== null) {
-                    deobfuscated.evalUnpacked.push(seMatch[1].substring(0, 2000));
-                }
-                // 5. NEW: Webpack module detection
-                const webpackPatterns = [
-                    /(?:__webpack_require__|__webpack_modules__)\s*\[\s*['"]?(\w+)['"]?\s*\]/g,
-                    /(?:const|var|let)\s+\w+\s*=\s*\{[\s\S]{0,50}__webpack_require__/g,
-                    /\(\s*function\s*\(\s*modules\s*\)\s*\{[\s\S]{0,200}__webpack_require__/g
-                ];
-                const webpackExports = allJs.match(/(?:module\.exports|exports\.\w+)\s*=\s*['"]([^'"]+)['"]/g) || [];
-                for (const exp of webpackExports.slice(0, 30)) {
-                    const val = exp.match(/=\s*['"]([^'"]+)['"]/);
-                    if (val) {
-                        deobfuscated.webpackModules.push(val[1]);
-                        deobfuscated.decodedStrings.push(val[1]);
-                    }
-                }
-                // Detect webpack chunk loading and module IDs
-                const chunkIds = allJs.match(/webpackChunk\w*\.push\s*\(\s*\[\s*\[([^\]]+)\]/g) || [];
-                for (const ci of chunkIds.slice(0, 10)) {
-                    deobfuscated.webpackModules.push(`chunk: ${ci.substring(0, 100)}`);
-                }
-                // 6. NEW: Terser/UglifyJS single-letter variable mappings
-                const terserPattern = /(?:var|let|const)\s+([a-z])\s*=\s*['"]([^'"]{2,})['"]/gi;
-                let terserMatch;
-                const terserMappings = {};
-                while ((terserMatch = terserPattern.exec(allJs)) !== null) {
-                    const varName = terserMatch[1], value = terserMatch[2];
-                    if (value.length > 2 && value.length < 200) {
-                        terserMappings[varName] = value;
-                        deobfuscated.functionMappings.push({ variable: varName, value: value });
-                        deobfuscated.decodedStrings.push(value);
-                    }
-                }
-                // 7. NEW: String concatenation resolution ("htt"+"ps://" → "https://")
-                const concatPattern = /(?:['"][^'"]*['"]\s*\+\s*){2,}['"][^'"]*['"]/g;
-                const concatMatches = allJs.match(concatPattern) || [];
-                for (const cm of concatMatches.slice(0, 50)) {
-                    try {
-                        const parts = cm.match(/['"]([^'"]*)['"]|(['"])/g) || [];
-                        const resolved = parts.map(p => p.replace(/^['"]|['"]$/g, '')).join('');
-                        if (resolved.length > 3) {
-                            deobfuscated.resolvedConcats.push(resolved);
-                            deobfuscated.decodedStrings.push(resolved);
-                        }
-                    }
-                    catch (e) { }
-                }
-                // 8. NEW: Array rotation detection — function with push/shift on array
-                const rotationPattern = /function\s+\w*\s*\(\s*(_0x[a-f0-9]+)\s*,\s*\w+\s*\)\s*\{[\s\S]{0,500}push\s*\(\s*\1\s*\.\s*shift\s*\(\s*\)\s*\)/g;
-                const rotations = allJs.match(rotationPattern) || [];
-                if (rotations.length > 0) {
-                    deobfuscated.functionMappings.push({ type: 'array_rotation', count: rotations.length, note: 'Array rotation functions detected — strings may be shifted' });
-                }
-                // Extract URLs and API endpoints from all decoded strings
-                deobfuscated.urls = [...new Set(deobfuscated.decodedStrings.filter((s) => s.match(/^(https?:\/\/|\/)/) || s.match(/\.(php|json|api|asp|jsp)$/i)))].slice(0, 50);
-                deobfuscated.apiEndpoints = [...new Set(deobfuscated.decodedStrings.filter((s) => s.match(/^\/[a-z]/i) && s.length > 3 && s.length < 100))].slice(0, 30);
-                // Find fetch patterns
-                const fetchPatterns = allJs.match(/fetch\s*\(\s*['"]([^'"]+)['"]/g) || [];
-                deobfuscated.fetchCalls = fetchPatterns.map(f => f.replace(/fetch\s*\(\s*['"]/, '').replace(/['"]$/, '')).slice(0, 20);
-                deobfuscated.decodedStrings = [...new Set(deobfuscated.decodedStrings)].slice(0, 500);
-                results.extracted = deobfuscated;
-                const summary = `${deobfuscated.stringArrays.length} arrays, ${deobfuscated.decodedStrings.length} strings, ${deobfuscated.evalUnpacked.length} eval unpacked, ${deobfuscated.webpackModules.length} webpack modules, ${deobfuscated.resolvedConcats.length} concats resolved, ${deobfuscated.unicodeDecoded.length} unicode decoded`;
-                (0, state_1.notifyProgress)('extract_data', 'completed', `Deobfuscated(enhanced): ${summary}`);
-                break;
-            }
-            case 'apiDiscovery': {
-                (0, state_1.notifyProgress)('extract_data', 'in_progress', 'Discovering hidden API endpoints...');
-                const apiResults = {
-                    fetchEndpoints: [], xhrEndpoints: [], formActions: [],
-                    scriptSources: [], inlineApiPatterns: [], postBodies: [], dynamicApis: []
-                };
-                // 1. Intercept runtime fetch/XHR
-                try {
-                    const runtimeApis = await page.evaluate(() => {
-                        return new Promise((resolve) => {
-                            const found = [];
-                            if (window.__capturedApis) {
-                                resolve(window.__capturedApis);
-                                return;
-                            }
-                            const origFetch = window.fetch;
-                            window.fetch = function (...args) {
-                                try {
-                                    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url;
-                                    const opts = args[1] || {};
-                                    found.push({
-                                        type: 'fetch', url, method: opts.method || 'GET',
-                                        body: typeof opts.body === 'string' ? opts.body.substring(0, 500) : null
-                                    });
-                                }
-                                catch (e) { }
-                                return origFetch.apply(this, args);
-                            };
-                            const origOpen = XMLHttpRequest.prototype.open;
-                            const origSend = XMLHttpRequest.prototype.send;
-                            XMLHttpRequest.prototype.open = function (method, url, ...rest) { this.__apiUrl = url; this.__apiMethod = method; return origOpen.apply(this, [method, url, ...rest]); };
-                            XMLHttpRequest.prototype.send = function (body) {
-                                found.push({
-                                    type: 'xhr', url: this.__apiUrl, method: this.__apiMethod,
-                                    body: typeof body === 'string' ? body.substring(0, 500) : null
-                                });
-                                return origSend.apply(this, [body]);
-                            };
-                            window.__capturedApis = found;
-                            setTimeout(() => resolve(found), 3000);
-                        });
-                    });
-                    apiResults.dynamicApis = runtimeApis;
-                }
-                catch (e) {
-                    apiResults.dynamicApis = [];
-                }
-                // 2. Static analysis
-                const allScriptContent = await page.evaluate(() => {
-                    return Array.from(document.querySelectorAll('script')).map(s => s.textContent).join('\n');
-                }).catch(() => '');
-                const fetchRegex = /fetch\s*\(\s*(?:['"`]([^'"`]+)['"`]|([a-zA-Z_$][a-zA-Z0-9_$]*))/g;
-                let fMatch;
-                while ((fMatch = fetchRegex.exec(allScriptContent)) !== null) {
-                    apiResults.fetchEndpoints.push((fMatch[1] || fMatch[2]));
-                }
-                apiResults.fetchEndpoints = [...new Set(apiResults.fetchEndpoints)].slice(0, 30);
-                const xhrRegex = /\.open\s*\(\s*['"](?:GET|POST|PUT|DELETE)['"]\s*,\s*['"`]([^'"`]+)['"`]/gi;
-                let xMatch;
-                while ((xMatch = xhrRegex.exec(allScriptContent)) !== null) {
-                    apiResults.xhrEndpoints.push(xMatch[1]);
-                }
-                apiResults.xhrEndpoints = [...new Set(apiResults.xhrEndpoints)].slice(0, 30);
-                apiResults.formActions = await page.evaluate(() => {
-                    return Array.from(document.querySelectorAll('form[action]')).map((f) => ({ action: f.action, method: f.method || 'GET', id: f.id || null }));
-                }).catch(() => []);
-                const postBodyPatterns = allScriptContent.match(/(?:URLSearchParams|FormData|JSON\.stringify)\s*\(\s*\{[^}]{5,200}\}/g) || [];
-                apiResults.postBodies = postBodyPatterns.slice(0, 10);
-                const apiUrlPattern = /['"`]((?:https?:\/\/[^'"`]+|\/)(?:[a-zA-Z0-9_\-\/]+\.(?:php|json|api|asp|aspx|do|action))[^'"`]*)['"`]/g;
-                let apiMatch;
-                while ((apiMatch = apiUrlPattern.exec(allScriptContent)) !== null) {
-                    apiResults.inlineApiPatterns.push(apiMatch[1]);
-                }
-                apiResults.inlineApiPatterns = [...new Set(apiResults.inlineApiPatterns)].slice(0, 30);
-                apiResults.scriptSources = await page.evaluate(() => {
-                    return Array.from(document.querySelectorAll('script[src]')).map(s => s.src);
-                }).catch(() => []);
-                results.extracted = apiResults;
-                const totalFound = apiResults.fetchEndpoints.length + apiResults.xhrEndpoints.length +
-                    apiResults.inlineApiPatterns.length + apiResults.dynamicApis.length;
-                (0, state_1.notifyProgress)('extract_data', 'completed', `API Discovery: ${totalFound} endpoints found`);
-                break;
-            }
-            // ====== FEATURE 4: Response Auto-Decryption ======
-            case 'decrypt': {
-                (0, state_1.notifyProgress)('extract_data', 'in_progress', 'Auto-decrypting data...');
-                const { encryptedData, autoFindKey = true } = params;
-                const decryptResults = {
-                    original: null, decoded: [], detectedEncoding: [], extractedKeys: [], aesDecrypted: null
-                };
-                // Get data to decrypt — from param or from page
-                let dataToDecrypt = encryptedData;
-                if (!dataToDecrypt) {
-                    // Try to get from clipboard or last API response
-                    const lastApiResponse = state_1.state.networkRecords.filter(r => r.responseBody).pop();
-                    if (lastApiResponse)
-                        dataToDecrypt = lastApiResponse.responseBody;
-                }
-                if (!dataToDecrypt) {
-                    return { success: false, error: 'No data to decrypt. Provide encryptedData parameter or start network_recorder first.' };
-                }
-                decryptResults.original = dataToDecrypt.substring(0, 500);
-                // 1. Base64 chain decode (recursive, up to 5 levels)
-                let b64Data = dataToDecrypt.trim();
-                for (let level = 0; level < 5; level++) {
-                    if (!/^[A-Za-z0-9+/=]+$/.test(b64Data) || b64Data.length < 4)
-                        break;
-                    try {
-                        const decoded = Buffer.from(b64Data, 'base64').toString('utf-8');
-                        if (decoded && decoded.length > 0 && !/[\x00-\x08\x0e-\x1f]/.test(decoded.substring(0, 100))) {
-                            decryptResults.decoded.push({ level: level + 1, type: 'base64', value: decoded.substring(0, 5000) });
-                            decryptResults.detectedEncoding.push('base64');
-                            // Check if result is JSON
-                            try {
-                                const json = JSON.parse(decoded);
-                                decryptResults.decoded.push({ level: level + 1, type: 'base64_json', value: json });
-                            }
-                            catch (e) { }
-                            b64Data = decoded; // Continue chain
-                        }
-                        else
-                            break;
-                    }
-                    catch (e) {
-                        break;
-                    }
-                }
-                // 2. Hex decode
-                const hexClean = dataToDecrypt.replace(/\s+/g, '');
-                if (/^[0-9a-f]+$/i.test(hexClean) && hexClean.length >= 6 && hexClean.length % 2 === 0) {
-                    try {
-                        const hexDecoded = Buffer.from(hexClean, 'hex').toString('utf-8');
-                        if (hexDecoded && !/[\x00-\x08\x0e-\x1f]/.test(hexDecoded.substring(0, 50))) {
-                            decryptResults.decoded.push({ type: 'hex', value: hexDecoded.substring(0, 5000) });
-                            decryptResults.detectedEncoding.push('hex');
-                        }
-                    }
-                    catch (e) { }
-                }
-                // 3. URL decode (multi-level)
-                if (dataToDecrypt.includes('%')) {
-                    try {
-                        let urlDecoded = decodeURIComponent(dataToDecrypt);
-                        decryptResults.decoded.push({ type: 'url', value: urlDecoded.substring(0, 5000) });
-                        decryptResults.detectedEncoding.push('url');
-                        // Double URL decode
-                        if (urlDecoded.includes('%')) {
-                            urlDecoded = decodeURIComponent(urlDecoded);
-                            decryptResults.decoded.push({ type: 'url_double', value: urlDecoded.substring(0, 5000) });
-                        }
-                    }
-                    catch (e) { }
-                }
-                // 4. ROT13
-                try {
-                    const rot13 = dataToDecrypt.replace(/[a-zA-Z]/g, (c) => {
-                        const base = c <= 'Z' ? 65 : 97;
-                        return String.fromCharCode(((c.charCodeAt(0) - base + 13) % 26) + base);
-                    });
-                    if (rot13 !== dataToDecrypt && (rot13.includes('http') || rot13.includes('www') || rot13.includes('.com'))) {
-                        decryptResults.decoded.push({ type: 'rot13', value: rot13.substring(0, 5000) });
-                        decryptResults.detectedEncoding.push('rot13');
-                    }
-                }
-                catch (e) { }
-                // 5. Auto-extract encryption keys from page scripts
-                if (autoFindKey) {
-                    try {
-                        const keys = await page.evaluate(() => {
-                            const scripts = Array.from(document.querySelectorAll('script')).map(s => s.textContent).join('\n');
-                            const found = [];
-                            // CryptoJS patterns
-                            const cryptoPatterns = [
-                                /CryptoJS\.AES\.decrypt\s*\(\s*\w+\s*,\s*['"]([^'"]+)['"]/g,
-                                /CryptoJS\.AES\.encrypt\s*\(\s*\w+\s*,\s*['"]([^'"]+)['"]/g,
-                                /CryptoJS\.enc\.Utf8\.parse\s*\(\s*['"]([^'"]+)['"]/g,
-                                /(?:secret|key|pass|password|iv|salt)\s*[:=]\s*['"]([^'"]{8,})['"]/gi,
-                                /aes(?:Key|_key|Secret)\s*[:=]\s*['"]([^'"]{8,})['"]/gi
-                            ];
-                            for (const pat of cryptoPatterns) {
-                                let m;
-                                while ((m = pat.exec(scripts)) !== null) {
-                                    found.push({ pattern: pat.source.substring(0, 50), key: m[1] });
-                                }
-                            }
-                            return found;
-                        });
-                        decryptResults.extractedKeys = keys.slice(0, 20);
-                    }
-                    catch (e) { }
-                }
-                // 6. AES decryption — try with extracted keys or user-provided key
-                const aesKey = params.aesKey || (decryptResults.extractedKeys[0]?.key);
-                if (aesKey && dataToDecrypt.length > 10) {
-                    try {
-                        const crypto = require('crypto');
-                        // Try AES-256-CBC
-                        for (const keyEncoding of ['utf8', 'hex', 'base64']) {
-                            try {
-                                let keyBuf;
-                                if (keyEncoding === 'utf8')
-                                    keyBuf = Buffer.alloc(32); // pad to 32 bytes
-                                else
-                                    keyBuf = Buffer.from(aesKey, keyEncoding);
-                                if (keyEncoding === 'utf8') {
-                                    const kb = Buffer.from(aesKey, 'utf8');
-                                    kb.copy(keyBuf);
-                                }
-                                // Try to decode the data from base64 first
-                                const dataBuf = Buffer.from(dataToDecrypt, 'base64');
-                                if (dataBuf.length > 16) {
-                                    // IV might be first 16 bytes
-                                    const iv = params.aesIV ? Buffer.from(params.aesIV, keyEncoding) : dataBuf.slice(0, 16);
-                                    const encrypted = params.aesIV ? dataBuf : dataBuf.slice(16);
-                                    const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuf, iv);
-                                    decipher.setAutoPadding(true);
-                                    let decrypted = decipher.update(encrypted, undefined, 'utf8');
-                                    decrypted += decipher.final('utf8');
-                                    if (decrypted && decrypted.length > 0) {
-                                        decryptResults.aesDecrypted = decrypted.substring(0, 5000);
-                                        decryptResults.detectedEncoding.push('aes-256-cbc');
-                                        // Try JSON parse
-                                        try {
-                                            decryptResults.aesDecrypted = JSON.parse(decrypted);
-                                        }
-                                        catch (e) { }
-                                        break;
-                                    }
-                                }
-                            }
-                            catch (e) {
-                                continue;
-                            }
-                        }
-                    }
-                    catch (e) { }
-                }
-                results.extracted = decryptResults;
-                const decodedCount = decryptResults.decoded.length + (decryptResults.aesDecrypted ? 1 : 0);
-                (0, state_1.notifyProgress)('extract_data', 'completed', `Decrypted: ${decodedCount} decodings, ${decryptResults.extractedKeys.length} keys found, encodings: ${decryptResults.detectedEncoding.join(', ') || 'none'}`);
-                break;
-            }
-            default:
-                return { success: false, error: `Unknown type: ${type}. Supported: regex, json, meta, structured, auto, deobfuscate, apiDiscovery, decrypt` };
-        }
-        return results;
+        return (0, network_extractors_1.extractData)(params);
     },
     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)
-                };
+                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 };