@ai-jshook/mcp 0.1.1 → 0.1.3

package/dist/server/MCPServer.js

@@ -1,6 +1,6 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as z from 'zod';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from '../utils/logger.js';
 import { CacheManager } from '../utils/cache.js';
 import { CodeCollector } from '../modules/collector/CodeCollector.js';
@@ -14,6 +14,11 @@ import { BrowserToolHandlers } from './BrowserToolHandlers.js';
 import { DebuggerToolHandlers } from './DebuggerToolHandlers.js';
 import { AdvancedToolHandlers } from './AdvancedToolHandlers.js';
 import { AIHookToolHandlers } from './AIHookToolHandlers.js';
+import { browserTools } from './BrowserToolDefinitions.js';
+import { debuggerTools } from './DebuggerToolDefinitions.js';
+import { advancedTools } from './AdvancedToolDefinitions.js';
+import { aiHookTools } from './AIHookToolDefinitions.js';
+import { tokenBudgetTools } from './TokenBudgetToolDefinitions.js';
 import { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
 import { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
 import { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
@@ -24,6 +29,7 @@ import { CryptoDetector } from '../modules/crypto/CryptoDetector.js';
 import { HookManager } from '../modules/hook/HookManager.js';
 import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
 import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
+import { cacheTools } from './CacheToolDefinitions.js';
 export class MCPServer {
     server;
     cache;
@@ -73,11 +79,15 @@ export class MCPServer {
         logger.info('TokenBudgetManager initialized');
         this.unifiedCache = UnifiedCacheManager.getInstance();
         logger.info('UnifiedCacheManager initialized');
-        this.server = new McpServer({
+        this.server = new Server({
             name: config.mcp.name,
             version: config.mcp.version,
+        }, {
+            capabilities: {
+                tools: {},
+            },
         });
-        this.registerTools();
+        this.setupHandlers();
         logger.info('MCP Server initialized with tools');
     }
     async registerCaches() {
@@ -107,711 +117,728 @@ export class MCPServer {
             logger.warn('Continuing without cache registration');
         }
     }
-    registerTools() {
-        this.registerCoreTools();
-        this.registerBrowserTools();
-        this.registerDebuggerTools();
-        this.registerAdvancedTools();
-        this.registerAIHookTools();
-        this.registerTokenBudgetTools();
-        this.registerCacheTools();
-        logger.info('All MCP tools registered');
-    }
-    registerCoreTools() {
-        const server = this.server;
-        server.registerTool('collect_code', {
-            title: 'Collect Code',
-            description: 'Collect JavaScript code from a target website',
-            inputSchema: {
-                url: z.string().describe('Target website URL'),
-                includeInline: z.boolean().optional().default(true),
-                includeExternal: z.boolean().optional().default(true),
-                includeDynamic: z.boolean().optional().default(false),
-                smartMode: z.enum(['summary', 'priority', 'incremental', 'full']).optional().default('full'),
-                compress: z.boolean().optional().default(false),
-                maxTotalSize: z.number().optional().default(2097152),
-                maxFileSize: z.number().optional().default(500),
-                priorities: z.array(z.string()).optional(),
-            },
-            outputSchema: {
-                files: z.array(z.object({
-                    url: z.string(),
-                    type: z.string(),
-                    size: z.number(),
-                    content: z.string(),
-                })),
-                totalSize: z.number(),
-                collectTime: z.number(),
-            },
-        }, async (args) => {
-            const result = await this.collector.collect({
-                url: args.url,
-                includeInline: args.includeInline,
-                includeExternal: args.includeExternal,
-                includeDynamic: args.includeDynamic,
-                smartMode: args.smartMode,
-                compress: args.compress,
-                maxTotalSize: args.maxTotalSize,
-                maxFileSize: args.maxFileSize ? args.maxFileSize * 1024 : undefined,
-                priorities: args.priorities,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('search_in_scripts', {
-            title: 'Search in Scripts',
-            description: 'Search for keywords in collected scripts',
-            inputSchema: {
-                keyword: z.string().describe('Keyword to search for'),
-                isRegex: z.boolean().optional().default(false),
-                caseSensitive: z.boolean().optional().default(false),
-                contextLines: z.number().optional().default(3),
-                maxMatches: z.number().optional().default(100),
-                returnSummary: z.boolean().optional().default(false),
-                maxContextSize: z.number().optional().default(50000),
-            },
-        }, async (args) => {
-            const result = await this.handleSearchInScripts(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('extract_function_tree', {
-            title: 'Extract Function Tree',
-            description: 'Extract a function and its dependencies',
-            inputSchema: {
-                scriptId: z.string().describe('Script ID'),
-                functionName: z.string().describe('Name of the function to extract'),
-                maxDepth: z.number().optional().default(3),
-                maxSize: z.number().optional().default(500),
-                includeComments: z.boolean().optional().default(true),
-            },
-        }, async (args) => {
-            const result = await this.handleExtractFunctionTree(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('deobfuscate', {
-            title: 'Deobfuscate',
-            description: 'Deobfuscate JavaScript code',
-            inputSchema: {
-                code: z.string().describe('Obfuscated code to deobfuscate'),
-                aggressive: z.boolean().optional().default(false),
-            },
-        }, async (args) => {
-            const result = await this.handleDeobfuscate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('understand_code', {
-            title: 'Understand Code',
-            description: 'Analyze and understand code structure',
-            inputSchema: {
-                code: z.string().describe('Code to analyze'),
-                context: z.record(z.string(), z.unknown()).optional(),
-                focus: z.enum(['structure', 'business', 'security', 'all']).optional().default('all'),
-            },
-        }, async (args) => {
-            const result = await this.handleUnderstandCode(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('detect_crypto', {
-            title: 'Detect Crypto',
-            description: 'Detect encryption algorithms in code',
-            inputSchema: {
-                code: z.string().describe('Code to analyze'),
-            },
-        }, async (args) => {
-            const result = await this.handleDetectCrypto(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('manage_hooks', {
-            title: 'Manage Hooks',
-            description: 'Manage JavaScript hooks',
-            inputSchema: {
-                action: z.enum(['create', 'list', 'records', 'clear']).describe('Action'),
-                target: z.string().optional(),
-                type: z.enum(['function', 'xhr', 'fetch', 'websocket', 'localstorage', 'cookie']).optional(),
-                hookAction: z.enum(['log', 'block', 'modify']).optional().default('log'),
-                customCode: z.string().optional(),
-                hookId: z.string().optional(),
-            },
-        }, async (args) => {
-            const result = await this.handleManageHooks(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('detect_obfuscation', {
-            title: 'Detect Obfuscation',
-            description: 'Detect obfuscation types in code',
-            inputSchema: {
-                code: z.string().describe('Code to analyze'),
-                generateReport: z.boolean().optional().default(true),
-            },
-        }, async (args) => {
-            const result = await this.handleDetectObfuscation(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('advanced_deobfuscate', {
-            title: 'Advanced Deobfuscate',
-            description: 'Advanced deobfuscation with VM support',
-            inputSchema: {
-                code: z.string().describe('Code to deobfuscate'),
-                detectOnly: z.boolean().optional().default(false),
-                aggressiveVM: z.boolean().optional().default(false),
-                useASTOptimization: z.boolean().optional().default(true),
-                timeout: z.number().optional().default(60000),
-            },
-        }, async (args) => {
-            const result = await this.handleAdvancedDeobfuscate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('clear_collected_data', {
-            title: 'Clear Collected Data',
-            description: 'Clear all collected data',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleClearCollectedData({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const tools = this.getTools();
+            logger.info(`Returning ${tools.length} tools`);
+            return {
+                tools,
+            };
         });
-        server.registerTool('get_collection_stats', {
-            title: 'Get Collection Stats',
-            description: 'Get statistics about collected data',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleGetCollectionStats({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            logger.info(`Tool called: ${name}`);
+            try {
+                const toolArgs = args || {};
+                const response = await this.executeToolWithTracking(name, toolArgs);
+                return response;
+            }
+            catch (error) {
+                logger.error(`Tool execution failed: ${name}`, error);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${error.message}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
         });
     }
-    registerBrowserTools() {
-        const server = this.server;
-        server.registerTool('browser_launch', {
-            title: 'Browser Launch',
-            description: 'Launch a browser instance',
-            inputSchema: {
-                headless: z.boolean().optional().default(true),
-                stealth: z.boolean().optional().default(true),
-                userDataDir: z.string().optional(),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handleBrowserLaunch(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('browser_close', {
-            title: 'Browser Close',
-            description: 'Close the browser',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleBrowserClose({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('browser_status', {
-            title: 'Browser Status',
-            description: 'Get browser status',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleBrowserStatus({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_navigate', {
-            title: 'Page Navigate',
-            description: 'Navigate to a URL',
-            inputSchema: {
-                url: z.string().describe('URL to navigate to'),
-                waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle', 'commit']).optional().default('networkidle'),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handlePageNavigate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_reload', {
-            title: 'Page Reload',
-            description: 'Reload current page',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handlePageReload({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_screenshot', {
-            title: 'Page Screenshot',
-            description: 'Take a screenshot of the page',
-            inputSchema: {
-                fullPage: z.boolean().optional().default(false),
-                path: z.string().optional(),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handlePageScreenshot(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('dom_query_selector', {
-            title: 'DOM Query Selector',
-            description: 'Query a single element',
-            inputSchema: {
-                selector: z.string().describe('CSS selector'),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handleDOMQuerySelector(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('dom_query_all', {
-            title: 'DOM Query All',
-            description: 'Query multiple elements',
-            inputSchema: {
-                selector: z.string().describe('CSS selector'),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handleDOMQueryAll(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_evaluate', {
-            title: 'Page Evaluate',
-            description: 'Execute JavaScript in page context',
-            inputSchema: {
-                script: z.string().describe('JavaScript code to execute'),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handlePageEvaluate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_click', {
-            title: 'Page Click',
-            description: 'Click on an element',
-            inputSchema: {
-                selector: z.string().describe('CSS selector'),
-                delay: z.number().optional(),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handlePageClick(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('page_type', {
-            title: 'Page Type',
-            description: 'Type text into an input',
-            inputSchema: {
-                selector: z.string().describe('CSS selector'),
-                text: z.string().describe('Text to type'),
-                delay: z.number().optional(),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handlePageType(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('captcha_detect', {
-            title: 'CAPTCHA Detect',
-            description: 'Detect if page has CAPTCHA',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleCaptchaDetect({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('captcha_wait', {
-            title: 'CAPTCHA Wait',
-            description: 'Wait for CAPTCHA to be solved',
-            inputSchema: {
-                timeout: z.number().optional().default(300000),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handleCaptchaWait(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('stealth_inject', {
-            title: 'Stealth Inject',
-            description: 'Inject anti-detection scripts',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleStealthInject({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('console_enable', {
-            title: 'Console Enable',
-            description: 'Enable console monitoring',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleConsoleEnable({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('console_get_logs', {
-            title: 'Console Get Logs',
-            description: 'Get captured console logs',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleConsoleGetLogs({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('get_all_scripts', {
-            title: 'Get All Scripts',
-            description: 'Get all collected scripts',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.browserHandlers.handleGetAllScripts({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('get_script_source', {
-            title: 'Get Script Source',
-            description: 'Get source code of a script',
-            inputSchema: {
-                scriptId: z.string().describe('Script ID'),
-            },
-        }, async (args) => {
-            const result = await this.browserHandlers.handleGetScriptSource(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('network_enable', {
-            title: 'Network Enable',
-            description: 'Enable network monitoring',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.advancedHandlers.handleNetworkEnable({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('network_get_requests', {
-            title: 'Network Get Requests',
-            description: 'Get captured network requests',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.advancedHandlers.handleNetworkGetRequests({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
+    async executeToolWithTracking(name, args) {
+        try {
+            const response = await this.executeToolInternal(name, args);
+            this.tokenBudget.recordToolCall(name, args, response);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = {
+                content: [{ type: 'text', text: `Error: ${error.message}` }],
+                isError: true,
+            };
+            this.tokenBudget.recordToolCall(name, args, errorResponse);
+            throw error;
+        }
     }
-    registerDebuggerTools() {
-        const server = this.server;
-        const handlers = this.debuggerHandlers;
-        server.registerTool('debugger_enable', {
-            title: 'Debugger Enable',
-            description: 'Enable the debugger',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerEnable({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_disable', {
-            title: 'Debugger Disable',
-            description: 'Disable the debugger',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerDisable({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_pause', {
-            title: 'Debugger Pause',
-            description: 'Pause script execution',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerPause({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_resume', {
-            title: 'Debugger Resume',
-            description: 'Resume script execution',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerResume({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_step_into', {
-            title: 'Debugger Step Into',
-            description: 'Step into next function call',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerStepInto({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_step_over', {
-            title: 'Debugger Step Over',
-            description: 'Step over next function call',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerStepOver({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_step_out', {
-            title: 'Debugger Step Out',
-            description: 'Step out of current function',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleDebuggerStepOut({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('breakpoint_set', {
-            title: 'Breakpoint Set',
-            description: 'Set a breakpoint',
-            inputSchema: {
-                url: z.string().optional(),
-                scriptId: z.string().optional(),
-                lineNumber: z.number().describe('Line number'),
-                columnNumber: z.number().optional(),
-                condition: z.string().optional(),
-            },
-        }, async (args) => {
-            const result = await handlers.handleBreakpointSet(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('breakpoint_remove', {
-            title: 'Breakpoint Remove',
-            description: 'Remove a breakpoint',
-            inputSchema: {
-                breakpointId: z.string().describe('Breakpoint ID'),
+    async executeToolInternal(name, toolArgs) {
+        switch (name) {
+            case 'get_token_budget_stats':
+                return await this.handleGetTokenBudgetStats(toolArgs);
+            case 'manual_token_cleanup':
+                return await this.handleManualTokenCleanup(toolArgs);
+            case 'reset_token_budget':
+                return await this.handleResetTokenBudget(toolArgs);
+            case 'get_cache_stats':
+                return await this.handleGetCacheStats(toolArgs);
+            case 'smart_cache_cleanup':
+                return await this.handleSmartCacheCleanup(toolArgs);
+            case 'clear_all_caches':
+                return await this.handleClearAllCaches(toolArgs);
+            case 'collect_code':
+                return await this.handleCollectCode(toolArgs);
+            case 'search_in_scripts':
+                return await this.handleSearchInScripts(toolArgs);
+            case 'extract_function_tree':
+                return await this.handleExtractFunctionTree(toolArgs);
+            case 'deobfuscate':
+                return await this.handleDeobfuscate(toolArgs);
+            case 'understand_code':
+                return await this.handleUnderstandCode(toolArgs);
+            case 'detect_crypto':
+                return await this.handleDetectCrypto(toolArgs);
+            case 'manage_hooks':
+                return await this.handleManageHooks(toolArgs);
+            case 'detect_obfuscation':
+                return await this.handleDetectObfuscation(toolArgs);
+            case 'advanced_deobfuscate':
+                return await this.handleAdvancedDeobfuscate(toolArgs);
+            case 'clear_collected_data':
+                return await this.handleClearCollectedData(toolArgs);
+            case 'get_collection_stats':
+                return await this.handleGetCollectionStats(toolArgs);
+            case 'get_detailed_data':
+                return await this.browserHandlers.handleGetDetailedData(toolArgs);
+            case 'browser_launch':
+                return await this.browserHandlers.handleBrowserLaunch(toolArgs);
+            case 'browser_close':
+                return await this.browserHandlers.handleBrowserClose(toolArgs);
+            case 'browser_status':
+                return await this.browserHandlers.handleBrowserStatus(toolArgs);
+            case 'page_navigate':
+                return await this.browserHandlers.handlePageNavigate(toolArgs);
+            case 'page_reload':
+                return await this.browserHandlers.handlePageReload(toolArgs);
+            case 'page_back':
+                return await this.browserHandlers.handlePageBack(toolArgs);
+            case 'page_forward':
+                return await this.browserHandlers.handlePageForward(toolArgs);
+            case 'dom_query_selector':
+                return await this.browserHandlers.handleDOMQuerySelector(toolArgs);
+            case 'dom_query_all':
+                return await this.browserHandlers.handleDOMQueryAll(toolArgs);
+            case 'dom_get_structure':
+                return await this.browserHandlers.handleDOMGetStructure(toolArgs);
+            case 'dom_find_clickable':
+                return await this.browserHandlers.handleDOMFindClickable(toolArgs);
+            case 'page_click':
+                return await this.browserHandlers.handlePageClick(toolArgs);
+            case 'page_type':
+                return await this.browserHandlers.handlePageType(toolArgs);
+            case 'page_select':
+                return await this.browserHandlers.handlePageSelect(toolArgs);
+            case 'page_hover':
+                return await this.browserHandlers.handlePageHover(toolArgs);
+            case 'page_scroll':
+                return await this.browserHandlers.handlePageScroll(toolArgs);
+            case 'page_wait_for_selector':
+                return await this.browserHandlers.handlePageWaitForSelector(toolArgs);
+            case 'page_evaluate':
+                return await this.browserHandlers.handlePageEvaluate(toolArgs);
+            case 'page_screenshot':
+                return await this.browserHandlers.handlePageScreenshot(toolArgs);
+            case 'get_all_scripts':
+                return await this.browserHandlers.handleGetAllScripts(toolArgs);
+            case 'get_script_source':
+                return await this.browserHandlers.handleGetScriptSource(toolArgs);
+            case 'console_enable':
+                return await this.browserHandlers.handleConsoleEnable(toolArgs);
+            case 'console_get_logs':
+                return await this.browserHandlers.handleConsoleGetLogs(toolArgs);
+            case 'console_execute':
+                return await this.browserHandlers.handleConsoleExecute(toolArgs);
+            case 'dom_get_computed_style':
+                return await this.browserHandlers.handleDOMGetComputedStyle(toolArgs);
+            case 'dom_find_by_text':
+                return await this.browserHandlers.handleDOMFindByText(toolArgs);
+            case 'dom_get_xpath':
+                return await this.browserHandlers.handleDOMGetXPath(toolArgs);
+            case 'dom_is_in_viewport':
+                return await this.browserHandlers.handleDOMIsInViewport(toolArgs);
+            case 'page_get_performance':
+                return await this.browserHandlers.handlePageGetPerformance(toolArgs);
+            case 'page_inject_script':
+                return await this.browserHandlers.handlePageInjectScript(toolArgs);
+            case 'page_set_cookies':
+                return await this.browserHandlers.handlePageSetCookies(toolArgs);
+            case 'page_get_cookies':
+                return await this.browserHandlers.handlePageGetCookies(toolArgs);
+            case 'page_clear_cookies':
+                return await this.browserHandlers.handlePageClearCookies(toolArgs);
+            case 'page_set_viewport':
+                return await this.browserHandlers.handlePageSetViewport(toolArgs);
+            case 'page_emulate_device':
+                return await this.browserHandlers.handlePageEmulateDevice(toolArgs);
+            case 'page_get_local_storage':
+                return await this.browserHandlers.handlePageGetLocalStorage(toolArgs);
+            case 'page_set_local_storage':
+                return await this.browserHandlers.handlePageSetLocalStorage(toolArgs);
+            case 'page_press_key':
+                return await this.browserHandlers.handlePagePressKey(toolArgs);
+            case 'page_get_all_links':
+                return await this.browserHandlers.handlePageGetAllLinks(toolArgs);
+            case 'captcha_detect':
+                return await this.browserHandlers.handleCaptchaDetect(toolArgs);
+            case 'captcha_wait':
+                return await this.browserHandlers.handleCaptchaWait(toolArgs);
+            case 'captcha_config':
+                return await this.browserHandlers.handleCaptchaConfig(toolArgs);
+            case 'stealth_inject':
+                return await this.browserHandlers.handleStealthInject(toolArgs);
+            case 'stealth_set_user_agent':
+                return await this.browserHandlers.handleStealthSetUserAgent(toolArgs);
+            case 'ai_hook_generate':
+                return await this.aiHookHandlers.handleAIHookGenerate(toolArgs);
+            case 'ai_hook_inject':
+                return await this.aiHookHandlers.handleAIHookInject(toolArgs);
+            case 'ai_hook_get_data':
+                return await this.aiHookHandlers.handleAIHookGetData(toolArgs);
+            case 'ai_hook_list':
+                return await this.aiHookHandlers.handleAIHookList(toolArgs);
+            case 'ai_hook_clear':
+                return await this.aiHookHandlers.handleAIHookClear(toolArgs);
+            case 'ai_hook_toggle':
+                return await this.aiHookHandlers.handleAIHookToggle(toolArgs);
+            case 'ai_hook_export':
+                return await this.aiHookHandlers.handleAIHookExport(toolArgs);
+            case 'debugger_enable':
+                return await this.debuggerHandlers.handleDebuggerEnable(toolArgs);
+            case 'debugger_disable':
+                return await this.debuggerHandlers.handleDebuggerDisable(toolArgs);
+            case 'debugger_pause':
+                return await this.debuggerHandlers.handleDebuggerPause(toolArgs);
+            case 'debugger_resume':
+                return await this.debuggerHandlers.handleDebuggerResume(toolArgs);
+            case 'debugger_step_into':
+                return await this.debuggerHandlers.handleDebuggerStepInto(toolArgs);
+            case 'debugger_step_over':
+                return await this.debuggerHandlers.handleDebuggerStepOver(toolArgs);
+            case 'debugger_step_out':
+                return await this.debuggerHandlers.handleDebuggerStepOut(toolArgs);
+            case 'breakpoint_set':
+                return await this.debuggerHandlers.handleBreakpointSet(toolArgs);
+            case 'breakpoint_remove':
+                return await this.debuggerHandlers.handleBreakpointRemove(toolArgs);
+            case 'breakpoint_list':
+                return await this.debuggerHandlers.handleBreakpointList(toolArgs);
+            case 'get_call_stack':
+                return await this.debuggerHandlers.handleGetCallStack(toolArgs);
+            case 'debugger_evaluate':
+                return await this.debuggerHandlers.handleDebuggerEvaluate(toolArgs);
+            case 'debugger_evaluate_global':
+                return await this.debuggerHandlers.handleDebuggerEvaluateGlobal(toolArgs);
+            case 'debugger_wait_for_paused':
+                return await this.debuggerHandlers.handleDebuggerWaitForPaused(toolArgs);
+            case 'debugger_get_paused_state':
+                return await this.debuggerHandlers.handleDebuggerGetPausedState(toolArgs);
+            case 'breakpoint_set_on_exception':
+                return await this.debuggerHandlers.handleBreakpointSetOnException(toolArgs);
+            case 'get_object_properties':
+                return await this.debuggerHandlers.handleGetObjectProperties(toolArgs);
+            case 'get_scope_variables_enhanced':
+                return await this.debuggerHandlers.handleGetScopeVariablesEnhanced(toolArgs);
+            case 'debugger_save_session':
+                return await this.debuggerHandlers.handleSaveSession(toolArgs);
+            case 'debugger_load_session':
+                return await this.debuggerHandlers.handleLoadSession(toolArgs);
+            case 'debugger_export_session':
+                return await this.debuggerHandlers.handleExportSession(toolArgs);
+            case 'debugger_list_sessions':
+                return await this.debuggerHandlers.handleListSessions(toolArgs);
+            case 'watch_add':
+                return await this.debuggerHandlers.handleWatchAdd(toolArgs);
+            case 'watch_remove':
+                return await this.debuggerHandlers.handleWatchRemove(toolArgs);
+            case 'watch_list':
+                return await this.debuggerHandlers.handleWatchList(toolArgs);
+            case 'watch_evaluate_all':
+                return await this.debuggerHandlers.handleWatchEvaluateAll(toolArgs);
+            case 'watch_clear_all':
+                return await this.debuggerHandlers.handleWatchClearAll(toolArgs);
+            case 'xhr_breakpoint_set':
+                return await this.debuggerHandlers.handleXHRBreakpointSet(toolArgs);
+            case 'xhr_breakpoint_remove':
+                return await this.debuggerHandlers.handleXHRBreakpointRemove(toolArgs);
+            case 'xhr_breakpoint_list':
+                return await this.debuggerHandlers.handleXHRBreakpointList(toolArgs);
+            case 'event_breakpoint_set':
+                return await this.debuggerHandlers.handleEventBreakpointSet(toolArgs);
+            case 'event_breakpoint_set_category':
+                return await this.debuggerHandlers.handleEventBreakpointSetCategory(toolArgs);
+            case 'event_breakpoint_remove':
+                return await this.debuggerHandlers.handleEventBreakpointRemove(toolArgs);
+            case 'event_breakpoint_list':
+                return await this.debuggerHandlers.handleEventBreakpointList(toolArgs);
+            case 'blackbox_add':
+                return await this.debuggerHandlers.handleBlackboxAdd(toolArgs);
+            case 'blackbox_add_common':
+                return await this.debuggerHandlers.handleBlackboxAddCommon(toolArgs);
+            case 'blackbox_list':
+                return await this.debuggerHandlers.handleBlackboxList(toolArgs);
+            case 'network_enable':
+                return await this.advancedHandlers.handleNetworkEnable(toolArgs);
+            case 'network_disable':
+                return await this.advancedHandlers.handleNetworkDisable(toolArgs);
+            case 'network_get_status':
+                return await this.advancedHandlers.handleNetworkGetStatus(toolArgs);
+            case 'network_get_requests':
+                return await this.advancedHandlers.handleNetworkGetRequests(toolArgs);
+            case 'network_get_response_body':
+                return await this.advancedHandlers.handleNetworkGetResponseBody(toolArgs);
+            case 'network_get_stats':
+                return await this.advancedHandlers.handleNetworkGetStats(toolArgs);
+            case 'performance_get_metrics':
+                return await this.advancedHandlers.handlePerformanceGetMetrics(toolArgs);
+            case 'performance_start_coverage':
+                return await this.advancedHandlers.handlePerformanceStartCoverage(toolArgs);
+            case 'performance_stop_coverage':
+                return await this.advancedHandlers.handlePerformanceStopCoverage(toolArgs);
+            case 'performance_take_heap_snapshot':
+                return await this.advancedHandlers.handlePerformanceTakeHeapSnapshot(toolArgs);
+            case 'console_get_exceptions':
+                return await this.advancedHandlers.handleConsoleGetExceptions(toolArgs);
+            case 'console_inject_script_monitor':
+                return await this.advancedHandlers.handleConsoleInjectScriptMonitor(toolArgs);
+            case 'console_inject_xhr_interceptor':
+                return await this.advancedHandlers.handleConsoleInjectXhrInterceptor(toolArgs);
+            case 'console_inject_fetch_interceptor':
+                return await this.advancedHandlers.handleConsoleInjectFetchInterceptor(toolArgs);
+            case 'console_inject_function_tracer':
+                return await this.advancedHandlers.handleConsoleInjectFunctionTracer(toolArgs);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    getTools() {
+        return [
+            {
+                name: 'collect_code',
+                description: 'Collect JavaScript code from a target website. 🆕 Supports smart collection modes: summary (fast analysis), priority (key code first), full (complete). Use summary mode for large websites to avoid token overflow.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'Target website URL',
+                        },
+                        includeInline: {
+                            type: 'boolean',
+                            description: 'Include inline scripts',
+                            default: true,
+                        },
+                        includeExternal: {
+                            type: 'boolean',
+                            description: 'Include external scripts',
+                            default: true,
+                        },
+                        includeDynamic: {
+                            type: 'boolean',
+                            description: 'Include dynamically loaded scripts',
+                            default: false,
+                        },
+                        smartMode: {
+                            type: 'string',
+                            description: '🆕 Smart collection mode: "summary" (only metadata, fastest), "priority" (key code first), "incremental" (on-demand), "full" (all code, default)',
+                            enum: ['summary', 'priority', 'incremental', 'full'],
+                            default: 'full',
+                        },
+                        compress: {
+                            type: 'boolean',
+                            description: '🆕 Enable gzip compression (70-90% size reduction). Compression info saved in metadata.',
+                            default: false,
+                        },
+                        maxTotalSize: {
+                            type: 'number',
+                            description: '🆕 Maximum total size in bytes (default: 2MB). Used with priority/incremental modes.',
+                            default: 2097152,
+                        },
+                        maxFileSize: {
+                            type: 'number',
+                            description: 'Maximum single file size in KB (default: 500KB). Files larger than this will be truncated.',
+                            default: 500,
+                        },
+                        priorities: {
+                            type: 'array',
+                            description: '🆕 Priority URL patterns for priority mode (e.g., ["encrypt", "crypto", "sign"]). Files matching these patterns are collected first.',
+                            items: { type: 'string' },
+                        },
+                        returnSummaryOnly: {
+                            type: 'boolean',
+                            description: '⚠️ DEPRECATED: Use smartMode="summary" instead.',
+                            default: false,
+                        },
+                    },
+                    required: ['url'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleBreakpointRemove(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('breakpoint_list', {
-            title: 'Breakpoint List',
-            description: 'List all breakpoints',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleBreakpointList({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('get_call_stack', {
-            title: 'Get Call Stack',
-            description: 'Get current call stack',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleGetCallStack({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('debugger_evaluate', {
-            title: 'Debugger Evaluate',
-            description: 'Evaluate expression in paused context',
-            inputSchema: {
-                expression: z.string().describe('Expression to evaluate'),
+            {
+                name: 'search_in_scripts',
+                description: `🆕 Search for keywords in collected scripts. Auto-truncates large results to avoid context overflow.
+
+Use this tool when:
+- You need to find where a specific function/variable is defined
+- Looking for API endpoints or encryption algorithms
+- Searching for specific patterns in large codebases
+
+⚠️ IMPORTANT: Large results (>50KB) automatically return summary only. Use specific keywords to reduce matches.
+
+Example:
+search_in_scripts(keyword="a_bogus", contextLines=5, maxMatches=50)
+→ Returns all occurrences with surrounding code`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        keyword: {
+                            type: 'string',
+                            description: 'Keyword to search for (supports regex if isRegex=true)',
+                        },
+                        isRegex: {
+                            type: 'boolean',
+                            description: 'Whether the keyword is a regular expression',
+                            default: false,
+                        },
+                        caseSensitive: {
+                            type: 'boolean',
+                            description: 'Whether the search is case-sensitive',
+                            default: false,
+                        },
+                        contextLines: {
+                            type: 'number',
+                            description: 'Number of context lines to include before and after matches',
+                            default: 3,
+                        },
+                        maxMatches: {
+                            type: 'number',
+                            description: 'Maximum number of matches to return (default: 100). Reduce this if getting summary-only results.',
+                            default: 100,
+                        },
+                        returnSummary: {
+                            type: 'boolean',
+                            description: '🆕 Return summary only (match count, preview) instead of full results. Useful for large result sets.',
+                            default: false,
+                        },
+                        maxContextSize: {
+                            type: 'number',
+                            description: '🆕 Maximum result size in bytes (default: 50KB). Results larger than this return summary only.',
+                            default: 50000,
+                        },
+                    },
+                    required: ['keyword'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleDebuggerEvaluate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('watch_add', {
-            title: 'Watch Add',
-            description: 'Add a watch expression',
-            inputSchema: {
-                expression: z.string().describe('Expression to watch'),
+            {
+                name: 'extract_function_tree',
+                description: `Extract a function and all its dependencies from collected scripts.
+
+This tool solves the context overflow problem by extracting only relevant code instead of analyzing entire files.
+
+Use this tool when:
+- You want to analyze a specific function (e.g., "sign", "encrypt")
+- Need to understand function dependencies
+- Want to avoid context overflow with large files
+
+Example workflow:
+1. search_in_scripts(keyword="a_bogus") → Find which file contains it
+2. extract_function_tree(functionName="sign", maxDepth=3) → Extract sign() and its dependencies
+3. analyze_code_chunk(code=extractedCode) → Analyze the small extracted code
+
+Returns:
+- Complete code of the function and its dependencies
+- Call graph showing relationships
+- Total size (much smaller than original file)`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        scriptId: {
+                            type: 'string',
+                            description: 'Script ID from collect_code or search_in_scripts',
+                        },
+                        functionName: {
+                            type: 'string',
+                            description: 'Name of the function to extract',
+                        },
+                        maxDepth: {
+                            type: 'number',
+                            description: 'Maximum dependency depth to extract',
+                            default: 3,
+                        },
+                        maxSize: {
+                            type: 'number',
+                            description: 'Maximum total size in KB',
+                            default: 500,
+                        },
+                        includeComments: {
+                            type: 'boolean',
+                            description: 'Whether to include comments in extracted code',
+                            default: true,
+                        },
+                    },
+                    required: ['scriptId', 'functionName'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleWatchAdd(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('watch_list', {
-            title: 'Watch List',
-            description: 'List all watch expressions',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleWatchList({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('xhr_breakpoint_set', {
-            title: 'XHR Breakpoint Set',
-            description: 'Set XHR breakpoint',
-            inputSchema: {
-                urlPattern: z.string().optional(),
-                methods: z.array(z.string()).optional(),
+            {
+                name: 'deobfuscate',
+                description: 'AI-driven code deobfuscation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'Obfuscated code to deobfuscate',
+                        },
+                        llm: {
+                            type: 'string',
+                            enum: ['gpt-4', 'claude'],
+                            description: 'LLM to use for deobfuscation',
+                            default: 'gpt-4',
+                        },
+                        aggressive: {
+                            type: 'boolean',
+                            description: 'Use aggressive deobfuscation',
+                            default: false,
+                        },
+                    },
+                    required: ['code'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleXHRBreakpointSet(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('event_breakpoint_set', {
-            title: 'Event Breakpoint Set',
-            description: 'Set event breakpoint',
-            inputSchema: {
-                eventName: z.string().describe('Event name'),
+            {
+                name: 'understand_code',
+                description: 'AI-assisted code semantic understanding',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'Code to analyze',
+                        },
+                        context: {
+                            type: 'object',
+                            description: 'Additional context for analysis',
+                        },
+                        focus: {
+                            type: 'string',
+                            enum: ['structure', 'business', 'security', 'all'],
+                            description: 'Analysis focus',
+                            default: 'all',
+                        },
+                    },
+                    required: ['code'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleEventBreakpointSet(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('blackbox_add', {
-            title: 'Blackbox Add',
-            description: 'Add script to blackbox',
-            inputSchema: {
-                pattern: z.string().describe('URL pattern'),
+            {
+                name: 'detect_crypto',
+                description: 'Detect and analyze encryption algorithms',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'Code to analyze for crypto algorithms',
+                        },
+                    },
+                    required: ['code'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleBlackboxAdd(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-    }
-    registerAdvancedTools() {
-        const server = this.server;
-        const handlers = this.advancedHandlers;
-        server.registerTool('performance_get_metrics', {
-            title: 'Performance Get Metrics',
-            description: 'Get performance metrics',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handlePerformanceGetMetrics({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('performance_start_coverage', {
-            title: 'Performance Start Coverage',
-            description: 'Start code coverage recording',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handlePerformanceStartCoverage({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('performance_stop_coverage', {
-            title: 'Performance Stop Coverage',
-            description: 'Stop code coverage recording',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handlePerformanceStopCoverage({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('console_get_exceptions', {
-            title: 'Console Get Exceptions',
-            description: 'Get caught exceptions',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleConsoleGetExceptions({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('console_inject_xhr_interceptor', {
-            title: 'Console Inject XHR Interceptor',
-            description: 'Inject XHR interceptor',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleConsoleInjectXhrInterceptor({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('console_inject_fetch_interceptor', {
-            title: 'Console Inject Fetch Interceptor',
-            description: 'Inject fetch interceptor',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleConsoleInjectFetchInterceptor({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('network_get_stats', {
-            title: 'Network Get Stats',
-            description: 'Get network statistics',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleNetworkGetStats({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-    }
-    registerAIHookTools() {
-        const server = this.server;
-        const handlers = this.aiHookHandlers;
-        server.registerTool('ai_hook_generate', {
-            title: 'AI Hook Generate',
-            description: 'Generate hook code for a request pattern',
-            inputSchema: {
-                pattern: z.string().describe('Request pattern to hook'),
+            {
+                name: 'manage_hooks',
+                description: 'Manage JavaScript hooks for runtime interception',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['create', 'list', 'records', 'clear'],
+                            description: 'Hook management action',
+                        },
+                        target: {
+                            type: 'string',
+                            description: 'Hook target (function name, API, etc.)',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['function', 'xhr', 'fetch', 'websocket', 'localstorage', 'cookie'],
+                            description: 'Type of hook to create',
+                        },
+                        hookAction: {
+                            type: 'string',
+                            enum: ['log', 'block', 'modify'],
+                            description: 'What to do when hook is triggered',
+                            default: 'log',
+                        },
+                        customCode: {
+                            type: 'string',
+                            description: 'Custom JavaScript code to execute in hook',
+                        },
+                        hookId: {
+                            type: 'string',
+                            description: 'Hook ID for records/clear actions',
+                        },
+                    },
+                    required: ['action'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleAIHookGenerate(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_inject', {
-            title: 'AI Hook Inject',
-            description: 'Inject generated hook into page',
-            inputSchema: {
-                hookId: z.string().describe('Hook ID'),
+            {
+                name: 'detect_obfuscation',
+                description: 'Detect obfuscation types in JavaScript code (supports 2024-2025 latest techniques)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'Code to analyze for obfuscation',
+                        },
+                        generateReport: {
+                            type: 'boolean',
+                            description: 'Generate detailed report',
+                            default: true,
+                        },
+                    },
+                    required: ['code'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleAIHookInject(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_list', {
-            title: 'AI Hook List',
-            description: 'List all active hooks',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleAIHookList({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_get_data', {
-            title: 'AI Hook Get Data',
-            description: 'Get captured hook data',
-            inputSchema: {
-                hookId: z.string().describe('Hook ID'),
+            {
+                name: 'advanced_deobfuscate',
+                description: 'Advanced deobfuscation supporting VM protection, invisible unicode, control flow flattening, etc.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: {
+                            type: 'string',
+                            description: 'Obfuscated code to deobfuscate',
+                        },
+                        detectOnly: {
+                            type: 'boolean',
+                            description: 'Only detect obfuscation types without deobfuscating',
+                            default: false,
+                        },
+                        aggressiveVM: {
+                            type: 'boolean',
+                            description: 'Use aggressive VM deobfuscation (experimental)',
+                            default: false,
+                        },
+                        useASTOptimization: {
+                            type: 'boolean',
+                            description: 'Apply AST-based optimizations',
+                            default: true,
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds',
+                            default: 60000,
+                        },
+                    },
+                    required: ['code'],
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleAIHookGetData(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_clear', {
-            title: 'AI Hook Clear',
-            description: 'Clear all hooks',
-            inputSchema: {},
-        }, async () => {
-            const result = await handlers.handleAIHookClear({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_toggle', {
-            title: 'AI Hook Toggle',
-            description: 'Toggle hook on/off',
-            inputSchema: {
-                hookId: z.string().describe('Hook ID'),
-                enabled: z.boolean().describe('Enable or disable'),
+            {
+                name: 'clear_collected_data',
+                description: '🧹 Clear all collected data (file cache, compression cache, collected URLs). Use this when switching to a new website to avoid data interference.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleAIHookToggle(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('ai_hook_export', {
-            title: 'AI Hook Export',
-            description: 'Export hook data',
-            inputSchema: {
-                format: z.enum(['json', 'har']).optional().default('json'),
+            {
+                name: 'get_collection_stats',
+                description: '📊 Get statistics about collected data (cache stats, compression stats, collected URLs count).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
             },
-        }, async (args) => {
-            const result = await handlers.handleAIHookExport(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
+            ...browserTools,
+            ...debuggerTools,
+            ...advancedTools,
+            ...aiHookTools,
+            ...tokenBudgetTools,
+            ...cacheTools,
+        ];
     }
-    registerTokenBudgetTools() {
-        const server = this.server;
-        server.registerTool('get_token_budget_stats', {
-            title: 'Get Token Budget Stats',
-            description: 'Get token budget statistics',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleGetTokenBudgetStats({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('manual_token_cleanup', {
-            title: 'Manual Token Cleanup',
-            description: 'Manually clean up token usage',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleManualTokenCleanup({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('reset_token_budget', {
-            title: 'Reset Token Budget',
-            description: 'Reset token budget',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleResetTokenBudget({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-    }
-    registerCacheTools() {
-        const server = this.server;
-        server.registerTool('get_cache_stats', {
-            title: 'Get Cache Stats',
-            description: 'Get cache statistics',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleGetCacheStats({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('smart_cache_cleanup', {
-            title: 'Smart Cache Cleanup',
-            description: 'Smart cleanup of cache',
-            inputSchema: {
-                targetSize: z.number().optional(),
-            },
-        }, async (args) => {
-            const result = await this.handleSmartCacheCleanup(args);
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
-        server.registerTool('clear_all_caches', {
-            title: 'Clear All Caches',
-            description: 'Clear all caches',
-            inputSchema: {},
-        }, async () => {
-            const result = await this.handleClearAllCaches({});
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        });
+    async handleCollectCode(args) {
+        const returnSummaryOnly = args.returnSummaryOnly ?? false;
+        let smartMode = args.smartMode;
+        if (returnSummaryOnly && !smartMode) {
+            smartMode = 'summary';
+        }
+        const result = await this.collector.collect({
+            url: args.url,
+            includeInline: args.includeInline,
+            includeExternal: args.includeExternal,
+            includeDynamic: args.includeDynamic,
+            smartMode: smartMode,
+            compress: args.compress,
+            maxTotalSize: args.maxTotalSize,
+            maxFileSize: args.maxFileSize ? args.maxFileSize * 1024 : undefined,
+            priorities: args.priorities,
+        });
+        if (returnSummaryOnly) {
+            logger.info('📋 Returning summary only (user requested)');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            mode: 'summary',
+                            totalSize: result.totalSize,
+                            totalSizeKB: (result.totalSize / 1024).toFixed(2),
+                            filesCount: result.files.length,
+                            collectTime: result.collectTime,
+                            summary: result.files.map(f => ({
+                                url: f.url,
+                                type: f.type,
+                                size: f.size,
+                                sizeKB: (f.size / 1024).toFixed(2),
+                                truncated: f.metadata?.truncated || false,
+                                preview: f.content.substring(0, 200) + '...',
+                            })),
+                            hint: 'Use get_script_source tool to fetch specific files',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        const totalSize = result.totalSize;
+        const MAX_SAFE_SIZE = 1 * 1024 * 1024;
+        if (totalSize > MAX_SAFE_SIZE) {
+            logger.warn(`⚠️  Total code size (${(totalSize / 1024).toFixed(2)} KB) exceeds safe limit (${MAX_SAFE_SIZE / 1024} KB), auto-switching to summary mode`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            warning: '⚠️ Code size too large for full response - auto-switched to summary mode',
+                            totalSize,
+                            totalSizeKB: (totalSize / 1024).toFixed(2),
+                            filesCount: result.files.length,
+                            collectTime: result.collectTime,
+                            summary: result.files.map(f => ({
+                                url: f.url,
+                                type: f.type,
+                                size: f.size,
+                                sizeKB: (f.size / 1024).toFixed(2),
+                                truncated: f.metadata?.truncated || false,
+                                preview: f.content.substring(0, 200) + '...',
+                            })),
+                            recommendations: [
+                                '1. Use get_script_source to fetch specific files',
+                                '2. Filter files by URL pattern (e.g., files containing "encrypt" or "api")',
+                                '3. Use returnSummaryOnly=true parameter to explicitly request summary mode',
+                                '4. Enable caching to speed up repeated requests',
+                            ],
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
     }
     async handleSearchInScripts(args) {
         const { ScriptManager } = await import('../modules/debugger/ScriptManager.js');