@jshookmcp/jshook 0.1.9 → 0.2.1

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';
@@ -15,10 +18,12 @@ export class CodeCollector {
     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,14 @@ export class CodeCollector {
     activePageIndex = null;
     currentHeadless = null;
     explicitlyClosed = false;
+    connectedToExistingBrowser = false;
     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 +146,13 @@ export class CodeCollector {
         }
         logger.info('Initializing browser with anti-detection...');
         this.browser = await puppeteer.launch(launchOptions);
+        this.connectedToExistingBrowser = false;
         this.currentHeadless = useHeadless === undefined ? true : useHeadless !== false;
         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 = {};
@@ -172,17 +181,47 @@ export class CodeCollector {
         this.explicitlyClosed = true;
         this.activePageIndex = null;
         const browser = this.browser;
+        const disconnectOnly = this.connectedToExistingBrowser;
         this.browser = null;
         this.currentHeadless = null;
+        this.connectedToExistingBrowser = false;
         if (this.cdpSession) {
             this.cdpSession = null;
             this.cdpListeners = {};
         }
         if (browser) {
-            await browser.close();
+            if (disconnectOnly) {
+                await browser.disconnect();
+            }
+            else {
+                await browser.close();
+            }
         }
         logger.info('Browser closed and all data cleared');
     }
+    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 +234,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 +355,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,
@@ -347,7 +410,189 @@ 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 {
@@ -358,15 +603,18 @@ export class CodeCollector {
             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/server/DomainInstanceRegistry.d.ts

@@ -0,0 +1,132 @@
+import type { CodeCollector } from '../modules/collector/CodeCollector.js';
+import type { PageController } from '../modules/collector/PageController.js';
+import type { DOMInspector } from '../modules/collector/DOMInspector.js';
+import type { ScriptManager } from '../modules/debugger/ScriptManager.js';
+import type { DebuggerManager } from '../modules/debugger/DebuggerManager.js';
+import type { RuntimeInspector } from '../modules/debugger/RuntimeInspector.js';
+import type { ConsoleMonitor } from '../modules/monitor/ConsoleMonitor.js';
+import type { BrowserToolHandlers } from './domains/browser/index.js';
+import type { DebuggerToolHandlers } from './domains/debugger/index.js';
+import type { AdvancedToolHandlers } from './domains/network/index.js';
+import type { AIHookToolHandlers, HookPresetToolHandlers } from './domains/hooks/index.js';
+import type { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
+import type { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
+import type { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
+import type { ObfuscationDetector } from '../modules/detector/ObfuscationDetector.js';
+import type { LLMService } from '../services/LLMService.js';
+import type { CodeAnalyzer } from '../modules/analyzer/CodeAnalyzer.js';
+import type { CryptoDetector } from '../modules/crypto/CryptoDetector.js';
+import type { HookManager } from '../modules/hook/HookManager.js';
+import type { CoreAnalysisHandlers } from './domains/analysis/index.js';
+import type { CoreMaintenanceHandlers, ExtensionManagementHandlers } from './domains/maintenance/index.js';
+import type { ProcessToolHandlers } from './domains/process/index.js';
+import type { WorkflowHandlers } from './domains/workflow/index.js';
+import type { WasmToolHandlers } from './domains/wasm/index.js';
+import type { StreamingToolHandlers } from './domains/streaming/index.js';
+import type { EncodingToolHandlers } from './domains/encoding/index.js';
+import type { AntiDebugToolHandlers } from './domains/antidebug/index.js';
+import type { GraphQLToolHandlers } from './domains/graphql/index.js';
+import type { PlatformToolHandlers } from './domains/platform/index.js';
+import type { SourcemapToolHandlers } from './domains/sourcemap/index.js';
+import type { TransformToolHandlers } from './domains/transform/index.js';
+export declare class DomainInstanceRegistry {
+    private _collector?;
+    private _pageController?;
+    private _domInspector?;
+    private _scriptManager?;
+    private _debuggerManager?;
+    private _runtimeInspector?;
+    private _consoleMonitor?;
+    private _llm?;
+    private _deobfuscator?;
+    private _advancedDeobfuscator?;
+    private _astOptimizer?;
+    private _obfuscationDetector?;
+    private _analyzer?;
+    private _cryptoDetector?;
+    private _hookManager?;
+    private _browserHandlers?;
+    private _debuggerHandlers?;
+    private _advancedHandlers?;
+    private _aiHookHandlers?;
+    private _hookPresetHandlers?;
+    private _coreAnalysisHandlers?;
+    private _coreMaintenanceHandlers?;
+    private _extensionManagementHandlers?;
+    private _processHandlers?;
+    private _workflowHandlers?;
+    private _wasmHandlers?;
+    private _streamingHandlers?;
+    private _encodingHandlers?;
+    private _antidebugHandlers?;
+    private _graphqlHandlers?;
+    private _platformHandlers?;
+    private _sourcemapHandlers?;
+    private _transformHandlers?;
+    get collector(): CodeCollector | undefined;
+    set collector(value: CodeCollector | undefined);
+    get pageController(): PageController | undefined;
+    set pageController(value: PageController | undefined);
+    get domInspector(): DOMInspector | undefined;
+    set domInspector(value: DOMInspector | undefined);
+    get scriptManager(): ScriptManager | undefined;
+    set scriptManager(value: ScriptManager | undefined);
+    get debuggerManager(): DebuggerManager | undefined;
+    set debuggerManager(value: DebuggerManager | undefined);
+    get runtimeInspector(): RuntimeInspector | undefined;
+    set runtimeInspector(value: RuntimeInspector | undefined);
+    get consoleMonitor(): ConsoleMonitor | undefined;
+    set consoleMonitor(value: ConsoleMonitor | undefined);
+    get llm(): LLMService | undefined;
+    set llm(value: LLMService | undefined);
+    get deobfuscator(): Deobfuscator | undefined;
+    set deobfuscator(value: Deobfuscator | undefined);
+    get advancedDeobfuscator(): AdvancedDeobfuscator | undefined;
+    set advancedDeobfuscator(value: AdvancedDeobfuscator | undefined);
+    get astOptimizer(): ASTOptimizer | undefined;
+    set astOptimizer(value: ASTOptimizer | undefined);
+    get obfuscationDetector(): ObfuscationDetector | undefined;
+    set obfuscationDetector(value: ObfuscationDetector | undefined);
+    get analyzer(): CodeAnalyzer | undefined;
+    set analyzer(value: CodeAnalyzer | undefined);
+    get cryptoDetector(): CryptoDetector | undefined;
+    set cryptoDetector(value: CryptoDetector | undefined);
+    get hookManager(): HookManager | undefined;
+    set hookManager(value: HookManager | undefined);
+    get browserHandlers(): BrowserToolHandlers | undefined;
+    set browserHandlers(value: BrowserToolHandlers | undefined);
+    get debuggerHandlers(): DebuggerToolHandlers | undefined;
+    set debuggerHandlers(value: DebuggerToolHandlers | undefined);
+    get advancedHandlers(): AdvancedToolHandlers | undefined;
+    set advancedHandlers(value: AdvancedToolHandlers | undefined);
+    get aiHookHandlers(): AIHookToolHandlers | undefined;
+    set aiHookHandlers(value: AIHookToolHandlers | undefined);
+    get hookPresetHandlers(): HookPresetToolHandlers | undefined;
+    set hookPresetHandlers(value: HookPresetToolHandlers | undefined);
+    get coreAnalysisHandlers(): CoreAnalysisHandlers | undefined;
+    set coreAnalysisHandlers(value: CoreAnalysisHandlers | undefined);
+    get coreMaintenanceHandlers(): CoreMaintenanceHandlers | undefined;
+    set coreMaintenanceHandlers(value: CoreMaintenanceHandlers | undefined);
+    get extensionManagementHandlers(): ExtensionManagementHandlers | undefined;
+    set extensionManagementHandlers(value: ExtensionManagementHandlers | undefined);
+    get processHandlers(): ProcessToolHandlers | undefined;
+    set processHandlers(value: ProcessToolHandlers | undefined);
+    get workflowHandlers(): WorkflowHandlers | undefined;
+    set workflowHandlers(value: WorkflowHandlers | undefined);
+    get wasmHandlers(): WasmToolHandlers | undefined;
+    set wasmHandlers(value: WasmToolHandlers | undefined);
+    get streamingHandlers(): StreamingToolHandlers | undefined;
+    set streamingHandlers(value: StreamingToolHandlers | undefined);
+    get encodingHandlers(): EncodingToolHandlers | undefined;
+    set encodingHandlers(value: EncodingToolHandlers | undefined);
+    get antidebugHandlers(): AntiDebugToolHandlers | undefined;
+    set antidebugHandlers(value: AntiDebugToolHandlers | undefined);
+    get graphqlHandlers(): GraphQLToolHandlers | undefined;
+    set graphqlHandlers(value: GraphQLToolHandlers | undefined);
+    get platformHandlers(): PlatformToolHandlers | undefined;
+    set platformHandlers(value: PlatformToolHandlers | undefined);
+    get sourcemapHandlers(): SourcemapToolHandlers | undefined;
+    set sourcemapHandlers(value: SourcemapToolHandlers | undefined);
+    get transformHandlers(): TransformToolHandlers | undefined;
+    set transformHandlers(value: TransformToolHandlers | undefined);
+}