@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/modules/collector/CodeCollector.d.ts

@@ -3,16 +3,32 @@ import type { CollectCodeOptions, CollectCodeResult, CodeFile, PuppeteerConfig }
 import { CodeCache } from '../collector/CodeCache.js';
 import { SmartCodeCollector } from '../collector/SmartCodeCollector.js';
 import { CodeCompressor } from '../collector/CodeCompressor.js';
+type ChromeReleaseChannel = 'stable' | 'beta' | 'dev' | 'canary';
+export interface ChromeConnectOptions {
+    browserURL?: string;
+    wsEndpoint?: string;
+    autoConnect?: boolean;
+    channel?: ChromeReleaseChannel;
+    userDataDir?: string;
+}
+export interface ResolvedPageDescriptor {
+    index: number;
+    url: string;
+    title: string;
+    page: Page;
+}
 export declare class CodeCollector {
     private config;
     private browser;
     private collectedUrls;
     private initPromise;
     private collectLock;
+    private connectAttemptId;
     private readonly MAX_COLLECTED_URLS;
     private readonly MAX_FILES_PER_COLLECT;
     private readonly MAX_RESPONSE_SIZE;
     private readonly MAX_SINGLE_FILE_SIZE;
+    private readonly CONNECT_TIMEOUT_MS;
     private readonly viewport;
     private readonly userAgent;
     private collectedFilesCache;
@@ -27,6 +43,9 @@ export declare class CodeCollector {
     private activePageIndex;
     private currentHeadless;
     private explicitlyClosed;
+    private connectedToExistingBrowser;
+    private chromePid;
+    private static readonly BROWSER_CLOSE_TIMEOUT_MS;
     constructor(config: PuppeteerConfig);
     setCacheEnabled(enabled: boolean): void;
     clearFileCache(): Promise<void>;
@@ -64,12 +83,19 @@ export declare class CodeCollector {
     private initInner;
     private resolveExecutablePath;
     close(): Promise<void>;
+    private closeBrowserWithForceKill;
+    static forceKillPid(pid: number | null): void;
+    getChromePid(): number | null;
+    private getPageTargets;
+    private resolvePageTargetHandle;
+    isExistingBrowserConnection(): boolean;
     getActivePage(): Promise<Page>;
     listPages(): Promise<Array<{
         index: number;
         url: string;
         title: string;
     }>>;
+    listResolvedPages(timeoutMs?: number): Promise<ResolvedPageDescriptor[]>;
     selectPage(index: number): Promise<void>;
     createPage(url?: string): Promise<Page>;
     private applyAntiDetection;
@@ -85,7 +111,15 @@ export declare class CodeCollector {
     navigateWithRetry(page: Page, url: string, options: NonNullable<Parameters<Page['goto']>[1]>, maxRetries?: number): Promise<void>;
     getPerformanceMetrics(page: Page): Promise<Record<string, number>>;
     collectPageMetadata(page: Page): Promise<Record<string, unknown>>;
-    connect(endpoint: string): Promise<void>;
+    private resolveDefaultChromeUserDataDir;
+    private resolveAutoConnectWsEndpoint;
+    private resolveConnectOptions;
+    private isAutoConnectRequest;
+    private getUnknownErrorMessage;
+    private normalizeConnectError;
+    private buildConnectTimeoutError;
+    private connectWithTimeout;
+    connect(endpointOrOptions: string | ChromeConnectOptions): Promise<void>;
     getBrowser(): Browser | null;
     getCollectionStats(): {
         totalCollected: number;
@@ -114,3 +148,4 @@ export declare class CodeCollector {
     };
     clearCollectedFilesCache(): void;
 }
+export {};

package/dist/src/modules/collector/CodeCollector.js

@@ -1,4 +1,7 @@
 import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
 import puppeteer from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
 import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
@@ -8,17 +11,19 @@ import { CodeCompressor } from '../collector/CodeCompressor.js';
 import { calculatePriorityScore } from '../collector/PageScriptCollectors.js';
 import { findBrowserExecutable } from '../../utils/browserExecutable.js';
 import { collectInnerImpl } from '../collector/CodeCollectorCollectInternal.js';
-import { shouldCollectUrlImpl, navigateWithRetryImpl, getPerformanceMetricsImpl, collectPageMetadataImpl } from '../collector/CodeCollectorUtilsInternal.js';
+import { shouldCollectUrlImpl, navigateWithRetryImpl, getPerformanceMetricsImpl, collectPageMetadataImpl, } from '../collector/CodeCollectorUtilsInternal.js';
 export class CodeCollector {
     config;
     browser = null;
     collectedUrls = new Set();
     initPromise = null;
     collectLock = null;
+    connectAttemptId = 0;
     MAX_COLLECTED_URLS;
     MAX_FILES_PER_COLLECT;
     MAX_RESPONSE_SIZE;
     MAX_SINGLE_FILE_SIZE;
+    CONNECT_TIMEOUT_MS;
     viewport;
     userAgent;
     collectedFilesCache = new Map();
@@ -31,12 +36,16 @@ export class CodeCollector {
     activePageIndex = null;
     currentHeadless = null;
     explicitlyClosed = false;
+    connectedToExistingBrowser = false;
+    chromePid = null;
+    static BROWSER_CLOSE_TIMEOUT_MS = 5000;
     constructor(config) {
         this.config = config;
         this.MAX_COLLECTED_URLS = config.maxCollectedUrls ?? 10000;
         this.MAX_FILES_PER_COLLECT = config.maxFilesPerCollect ?? 200;
         this.MAX_RESPONSE_SIZE = config.maxTotalContentSize ?? 512 * 1024;
         this.MAX_SINGLE_FILE_SIZE = config.maxSingleFileSize ?? 200 * 1024;
+        this.CONNECT_TIMEOUT_MS = 15000;
         this.viewport = config.viewport ?? { width: 1920, height: 1080 };
         this.userAgent =
             config.userAgent ??
@@ -139,11 +148,18 @@ export class CodeCollector {
         }
         logger.info('Initializing browser with anti-detection...');
         this.browser = await puppeteer.launch(launchOptions);
+        this.connectedToExistingBrowser = false;
+        this.chromePid = this.browser.process()?.pid ?? null;
+        if (this.chromePid) {
+            logger.debug(`Chrome child process PID: ${this.chromePid}`);
+        }
         this.currentHeadless = useHeadless === undefined ? true : useHeadless !== false;
         this.browser.on('disconnected', () => {
             logger.warn('Browser disconnected');
             this.browser = null;
             this.currentHeadless = null;
+            this.connectedToExistingBrowser = false;
+            this.chromePid = null;
             if (this.cdpSession) {
                 this.cdpSession = null;
                 this.cdpListeners = {};
@@ -172,17 +188,77 @@ export class CodeCollector {
         this.explicitlyClosed = true;
         this.activePageIndex = null;
         const browser = this.browser;
+        const disconnectOnly = this.connectedToExistingBrowser;
+        const pid = this.chromePid;
         this.browser = null;
         this.currentHeadless = null;
+        this.connectedToExistingBrowser = false;
+        this.chromePid = null;
         if (this.cdpSession) {
             this.cdpSession = null;
             this.cdpListeners = {};
         }
         if (browser) {
-            await browser.close();
+            if (disconnectOnly) {
+                await browser.disconnect();
+            }
+            else {
+                await this.closeBrowserWithForceKill(browser, pid);
+            }
         }
         logger.info('Browser closed and all data cleared');
     }
+    async closeBrowserWithForceKill(browser, pid) {
+        try {
+            await Promise.race([
+                browser.close(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('browser.close() timed out')), CodeCollector.BROWSER_CLOSE_TIMEOUT_MS)),
+            ]);
+        }
+        catch (error) {
+            logger.warn('browser.close() failed or timed out, attempting force-kill:', error);
+            CodeCollector.forceKillPid(pid);
+        }
+    }
+    static forceKillPid(pid) {
+        if (!pid)
+            return;
+        try {
+            process.kill(pid, 'SIGKILL');
+            logger.info(`Force-killed Chrome process PID ${pid}`);
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH') {
+                logger.warn(`Failed to force-kill Chrome PID ${pid}:`, error);
+            }
+        }
+    }
+    getChromePid() {
+        return this.chromePid;
+    }
+    getPageTargets() {
+        if (!this.browser) {
+            return [];
+        }
+        return this.browser.targets().filter((target) => target.type() === 'page');
+    }
+    async resolvePageTargetHandle(target, timeoutMs = 5000) {
+        const page = await Promise.race([
+            target.page(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new PrerequisiteError(`Timed out after ${timeoutMs}ms while resolving a Puppeteer Page handle from the attached Chrome target.`));
+                }, timeoutMs);
+            }),
+        ]);
+        if (!page) {
+            throw new PrerequisiteError('Attached browser target does not expose a Puppeteer Page handle in the current Chrome remote debugging mode.');
+        }
+        return page;
+    }
+    isExistingBrowserConnection() {
+        return this.connectedToExistingBrowser;
+    }
     async getActivePage() {
         if (!this.browser) {
             if (this.explicitlyClosed) {
@@ -195,49 +271,73 @@ export class CodeCollector {
                 throw new PrerequisiteError(`Browser not available: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        const pages = await this.browser.pages();
-        if (pages.length === 0) {
+        const pageTargets = this.getPageTargets();
+        if (pageTargets.length === 0) {
             return await this.browser.newPage();
         }
-        if (this.activePageIndex !== null && this.activePageIndex < pages.length) {
-            return pages[this.activePageIndex];
+        if (this.activePageIndex !== null && this.activePageIndex < pageTargets.length) {
+            return await this.resolvePageTargetHandle(pageTargets[this.activePageIndex]);
         }
-        const lastPage = pages[pages.length - 1];
-        if (!lastPage) {
+        const lastTarget = pageTargets[pageTargets.length - 1];
+        if (!lastTarget) {
             throw new Error('Failed to get active page');
         }
-        return lastPage;
+        return await this.resolvePageTargetHandle(lastTarget);
     }
     async listPages() {
         if (!this.browser) {
             return [];
         }
-        const pages = await this.browser.pages();
-        const results = await Promise.all(pages.map(async (page, index) => {
-            let url = '';
-            let title = '';
+        const targets = this.getPageTargets();
+        return targets.map((target, index) => ({
+            index,
+            url: target.url(),
+            title: '',
+        }));
+    }
+    async listResolvedPages(timeoutMs = 1500) {
+        if (!this.browser) {
+            return [];
+        }
+        const targets = this.getPageTargets();
+        const pages = await Promise.all(targets.map(async (target, index) => {
             try {
-                url = page.url();
+                const page = await this.resolvePageTargetHandle(target, timeoutMs);
+                let title = '';
+                try {
+                    title = await Promise.race([
+                        page.title(),
+                        new Promise((resolve) => {
+                            setTimeout(() => resolve(''), timeoutMs);
+                        }),
+                    ]);
+                }
+                catch {
+                    title = '';
+                }
+                return {
+                    index,
+                    url: target.url(),
+                    title,
+                    page,
+                };
             }
-            catch { }
-            try {
-                title = await page.title();
+            catch {
+                return null;
             }
-            catch { }
-            return { index, url, title };
         }));
-        return results;
+        return pages.filter((page) => page !== null);
     }
     async selectPage(index) {
         if (!this.browser) {
             throw new Error('Browser not connected');
         }
-        const pages = await this.browser.pages();
+        const pages = await this.listPages();
         if (index < 0 || index >= pages.length) {
             throw new Error(`Page index ${index} out of range (0-${pages.length - 1})`);
         }
         this.activePageIndex = index;
-        logger.info(`Active page set to index ${index}: ${pages[index].url()}`);
+        logger.info(`Active page set to index ${index}: ${pages[index].url}`);
     }
     async createPage(url) {
         if (!this.browser) {
@@ -292,8 +392,8 @@ export class CodeCollector {
             };
         }
         try {
-            const pages = await this.browser.pages();
             const version = await this.browser.version();
+            const pages = this.getPageTargets();
             return {
                 running: true,
                 pagesCount: pages.length,
@@ -314,11 +414,15 @@ export class CodeCollector {
             try {
                 await this.collectLock;
             }
-            catch { }
+            catch {
+            }
         }
         let resolve;
         let reject;
-        this.collectLock = new Promise((res, rej) => { resolve = res; reject = rej; });
+        this.collectLock = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
         try {
             const result = await this.collectInner(options);
             resolve(result);
@@ -347,26 +451,210 @@ export class CodeCollector {
     async collectPageMetadata(page) {
         return collectPageMetadataImpl(page);
     }
-    async connect(endpoint) {
+    resolveDefaultChromeUserDataDir(channel = 'stable') {
+        const home = homedir();
+        if (process.platform === 'win32') {
+            const localAppData = process.env.LOCALAPPDATA ?? join(home, 'AppData', 'Local');
+            switch (channel) {
+                case 'beta':
+                    return join(localAppData, 'Google', 'Chrome Beta', 'User Data');
+                case 'dev':
+                    return join(localAppData, 'Google', 'Chrome Dev', 'User Data');
+                case 'canary':
+                    return join(localAppData, 'Google', 'Chrome SxS', 'User Data');
+                case 'stable':
+                default:
+                    return join(localAppData, 'Google', 'Chrome', 'User Data');
+            }
+        }
+        if (process.platform === 'darwin') {
+            const appSupport = join(home, 'Library', 'Application Support');
+            switch (channel) {
+                case 'beta':
+                    return join(appSupport, 'Google', 'Chrome Beta');
+                case 'dev':
+                    return join(appSupport, 'Google', 'Chrome Dev');
+                case 'canary':
+                    return join(appSupport, 'Google', 'Chrome Canary');
+                case 'stable':
+                default:
+                    return join(appSupport, 'Google', 'Chrome');
+            }
+        }
+        const configHome = process.env.XDG_CONFIG_HOME ?? join(home, '.config');
+        switch (channel) {
+            case 'beta':
+                return join(configHome, 'google-chrome-beta');
+            case 'dev':
+                return join(configHome, 'google-chrome-unstable');
+            case 'canary':
+                return join(configHome, 'google-chrome-canary');
+            case 'stable':
+            default:
+                return join(configHome, 'google-chrome');
+        }
+    }
+    async resolveAutoConnectWsEndpoint(options) {
+        const channel = options.channel ?? 'stable';
+        const userDataDir = options.userDataDir ?? this.resolveDefaultChromeUserDataDir(channel);
+        const devToolsActivePortPath = join(userDataDir, 'DevToolsActivePort');
+        let fileContent;
+        try {
+            fileContent = await readFile(devToolsActivePortPath, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Could not read DevToolsActivePort from "${devToolsActivePortPath}". Check if Chrome is running from this profile and remote debugging is enabled at chrome://inspect/#remote-debugging.`, { cause: error });
+        }
+        const [rawPort, rawPath] = fileContent
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        if (!rawPort || !rawPath) {
+            throw new Error(`Invalid DevToolsActivePort contents found in "${devToolsActivePortPath}".`);
+        }
+        const port = Number.parseInt(rawPort, 10);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+            throw new Error(`Invalid remote debugging port "${rawPort}" in "${devToolsActivePortPath}".`);
+        }
+        return `ws://127.0.0.1:${port}${rawPath}`;
+    }
+    async resolveConnectOptions(endpointOrOptions) {
+        if (typeof endpointOrOptions === 'string') {
+            const endpoint = endpointOrOptions.trim();
+            if (!endpoint) {
+                throw new Error('Connection endpoint cannot be empty.');
+            }
+            return endpoint.startsWith('ws://') || endpoint.startsWith('wss://')
+                ? { browserWSEndpoint: endpoint }
+                : { browserURL: endpoint };
+        }
+        if (endpointOrOptions.wsEndpoint) {
+            return { browserWSEndpoint: endpointOrOptions.wsEndpoint };
+        }
+        if (endpointOrOptions.browserURL) {
+            return { browserURL: endpointOrOptions.browserURL };
+        }
+        if (endpointOrOptions.autoConnect ||
+            endpointOrOptions.userDataDir ||
+            endpointOrOptions.channel) {
+            return {
+                browserWSEndpoint: await this.resolveAutoConnectWsEndpoint(endpointOrOptions),
+            };
+        }
+        throw new Error('browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required to connect to an existing browser.');
+    }
+    isAutoConnectRequest(endpointOrOptions) {
+        return (typeof endpointOrOptions !== 'string' &&
+            Boolean(endpointOrOptions.autoConnect || endpointOrOptions.userDataDir || endpointOrOptions.channel));
+    }
+    getUnknownErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'object' && error !== null) {
+            const directMessage = 'message' in error && typeof error.message === 'string' ? error.message.trim() : '';
+            if (directMessage) {
+                return directMessage;
+            }
+            const nestedError = 'error' in error ? error.error : undefined;
+            if (nestedError instanceof Error && nestedError.message) {
+                return nestedError.message;
+            }
+            if (typeof nestedError === 'object' && nestedError !== null) {
+                const nestedMessage = 'message' in nestedError && typeof nestedError.message === 'string'
+                    ? nestedError.message.trim()
+                    : '';
+                if (nestedMessage) {
+                    return nestedMessage;
+                }
+            }
+            const serialized = JSON.stringify(error);
+            if (serialized && serialized !== '{}') {
+                return serialized;
+            }
+        }
+        return String(error);
+    }
+    normalizeConnectError(error, target, endpointOrOptions) {
+        const message = this.getUnknownErrorMessage(error);
+        if (this.isAutoConnectRequest(endpointOrOptions) && /ECONNREFUSED/i.test(message)) {
+            return new Error(`Failed to connect to existing browser: ${message}. ` +
+                `Chrome is not currently listening at ${target}. ` +
+                'DevToolsActivePort may be stale after a browser restart. ' +
+                'Re-open Chrome, confirm remote debugging is enabled at chrome://inspect/#remote-debugging, click Allow if prompted, and retry.');
+        }
+        return error instanceof Error
+            ? error
+            : new Error(`Failed to connect to existing browser: ${message}`);
+    }
+    buildConnectTimeoutError(target, endpointOrOptions) {
+        const baseMessage = `Timed out after ${this.CONNECT_TIMEOUT_MS}ms while connecting to existing browser: ${target}. ` +
+            'The CDP handshake did not complete in time.';
+        if (this.isAutoConnectRequest(endpointOrOptions)) {
+            return new Error(`${baseMessage} If Chrome prompted for remote debugging approval, click Allow in Chrome and then retry the tool call.`);
+        }
+        return new Error(`${baseMessage} Verify that the browser debugging endpoint is reachable and retry.`);
+    }
+    async connectWithTimeout(connectOptions, target, endpointOrOptions) {
+        const attemptId = ++this.connectAttemptId;
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                settled = true;
+                if (this.connectAttemptId === attemptId) {
+                    this.connectAttemptId += 1;
+                }
+                reject(this.buildConnectTimeoutError(target, endpointOrOptions));
+            }, this.CONNECT_TIMEOUT_MS);
+            void puppeteer
+                .connect(connectOptions)
+                .then(async (browser) => {
+                if (settled || this.connectAttemptId !== attemptId) {
+                    try {
+                        await browser.disconnect();
+                    }
+                    catch {
+                    }
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve(browser);
+            })
+                .catch((error) => {
+                if (settled || this.connectAttemptId !== attemptId) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                reject(this.normalizeConnectError(error, target, endpointOrOptions));
+            });
+        });
+    }
+    async connect(endpointOrOptions) {
         this.explicitlyClosed = false;
         if (this.browser) {
             try {
                 await this.browser.disconnect();
             }
-            catch { }
+            catch {
+            }
             this.browser = null;
             this.currentHeadless = null;
         }
         this.activePageIndex = null;
-        logger.info(`Connecting to existing browser: ${endpoint}`);
-        const connectOptions = endpoint.startsWith('ws://') || endpoint.startsWith('wss://')
-            ? { browserWSEndpoint: endpoint }
-            : { browserURL: endpoint };
-        this.browser = await puppeteer.connect(connectOptions);
+        const connectOptions = await this.resolveConnectOptions(endpointOrOptions);
+        const target = connectOptions.browserWSEndpoint ??
+            connectOptions.browserURL ??
+            'auto-detected Chrome debugging endpoint';
+        logger.info(`Connecting to existing browser: ${target}`);
+        this.browser = await this.connectWithTimeout(connectOptions, target, endpointOrOptions);
+        this.connectedToExistingBrowser = true;
         this.browser.on('disconnected', () => {
             logger.warn('Browser disconnected');
             this.browser = null;
             this.currentHeadless = null;
+            this.connectedToExistingBrowser = false;
             if (this.cdpSession) {
                 this.cdpSession = null;
                 this.cdpListeners = {};

package/dist/src/modules/collector/CodeCollectorCollectInternal.js

@@ -1,5 +1,5 @@
 import { logger } from '../../utils/logger.js';
-import { collectInlineScripts, collectServiceWorkers, collectWebWorkers, analyzeDependencies, } from '../collector/PageScriptCollectors.js';
+import { collectInlineScripts, collectServiceWorkers, collectWebWorkers, analyzeDependencies, setupWebWorkerTracking, } from '../collector/PageScriptCollectors.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -39,7 +39,9 @@ function assertCollectorInternals(value) {
     if (!isRecord(value)) {
         throw new Error('Invalid collector context');
     }
-    if (typeof value.init !== 'function' || typeof value.applyAntiDetection !== 'function') {
+    if (typeof value.init !== 'function' ||
+        typeof value.applyAntiDetection !== 'function' ||
+        typeof value.shouldCollectUrl !== 'function') {
         throw new Error('Invalid collector context');
     }
 }
@@ -65,7 +67,21 @@ export async function collectInnerImpl(self, options) {
         page.setDefaultTimeout(timeoutMs);
         await page.setUserAgent(self.userAgent);
         await self.applyAntiDetection(page);
+        if (options.includeWebWorker !== false) {
+            await setupWebWorkerTracking(page);
+        }
         const files = [];
+        const appendFilesWithinLimit = (incoming, label) => {
+            const remaining = self.MAX_FILES_PER_COLLECT - files.length;
+            if (remaining <= 0) {
+                logger.warn(`Reached max files limit (${self.MAX_FILES_PER_COLLECT}), skipping ${label}`);
+                return;
+            }
+            if (incoming.length > remaining) {
+                logger.warn(`Collected ${incoming.length} ${label}, limiting to remaining ${remaining} files`);
+            }
+            files.push(...incoming.slice(0, remaining));
+        };
         self.cdpSession = await page.createCDPSession();
         await self.cdpSession.send('Network.enable');
         await self.cdpSession.send('Runtime.enable');
@@ -83,6 +99,12 @@ export async function collectInnerImpl(self, options) {
             }
             self.cleanupCollectedUrls();
             if (type === 'Script' || response.mimeType?.includes('javascript') || url.endsWith('.js')) {
+                if (options.includeExternal === false) {
+                    return;
+                }
+                if (!self.shouldCollectUrl(url, options.filterRules)) {
+                    return;
+                }
                 try {
                     const responseBody = (await self.cdpSession.send('Network.getResponseBody', {
                         requestId,
@@ -116,9 +138,12 @@ export async function collectInnerImpl(self, options) {
                                 }
                                 : undefined,
                         };
-                        files.push(file);
-                        self.collectedFilesCache.set(url, file);
-                        logger.debug(`[CDP] Collected (${files.length}/${self.MAX_FILES_PER_COLLECT}): ${url} (${(finalContent.length / 1024).toFixed(2)} KB)${truncated ? ' [TRUNCATED]' : ''}`);
+                        const fileCountBeforeAppend = files.length;
+                        appendFilesWithinLimit([file], 'external scripts');
+                        if (files.length > fileCountBeforeAppend) {
+                            self.collectedFilesCache.set(url, file);
+                            logger.debug(`[CDP] Collected (${files.length}/${self.MAX_FILES_PER_COLLECT}): ${url} (${(finalContent.length / 1024).toFixed(2)} KB)${truncated ? ' [TRUNCATED]' : ''}`);
+                        }
                     }
                 }
                 catch (error) {
@@ -135,17 +160,17 @@ export async function collectInnerImpl(self, options) {
         if (options.includeInline !== false) {
             logger.info('Collecting inline scripts...');
             const inlineScripts = await collectInlineScripts(page, self.MAX_SINGLE_FILE_SIZE, self.MAX_FILES_PER_COLLECT);
-            files.push(...inlineScripts);
+            appendFilesWithinLimit(inlineScripts, 'inline scripts');
         }
         if (options.includeServiceWorker !== false) {
             logger.info('Collecting Service Workers...');
-            const serviceWorkerFiles = await collectServiceWorkers(page);
-            files.push(...serviceWorkerFiles);
+            const serviceWorkerFiles = await collectServiceWorkers(page, (url) => self.shouldCollectUrl(url, options.filterRules));
+            appendFilesWithinLimit(serviceWorkerFiles, 'service workers');
         }
         if (options.includeWebWorker !== false) {
             logger.info('Collecting Web Workers...');
-            const webWorkerFiles = await collectWebWorkers(page);
-            files.push(...webWorkerFiles);
+            const webWorkerFiles = await collectWebWorkers(page, (url) => self.shouldCollectUrl(url, options.filterRules));
+            appendFilesWithinLimit(webWorkerFiles, 'web workers');
         }
         if (options.includeDynamic) {
             logger.info('Waiting for dynamic scripts...');
@@ -160,7 +185,6 @@ export async function collectInnerImpl(self, options) {
             self.cdpListeners = {};
         }
         const collectTime = Date.now() - startTime;
-        const totalSize = files.reduce((sum, file) => sum + file.size, 0);
         const truncatedFiles = files.filter((f) => f.metadata?.truncated);
         if (truncatedFiles.length > 0) {
             logger.warn(`${truncatedFiles.length} files were truncated due to size limits`);
@@ -253,6 +277,7 @@ export async function collectInnerImpl(self, options) {
             }
         }
         const dependencies = analyzeDependencies(processedFiles);
+        const totalSize = processedFiles.reduce((sum, file) => sum + file.size, 0);
         logger.success(`Collected ${processedFiles.length} files (${(totalSize / 1024).toFixed(2)} KB) in ${collectTime}ms`);
         const result = {
             files: processedFiles,