@ai-jshook/mcp 0.1.1

package/dist/server/MCPServer.js

@@ -0,0 +1,1344 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod';
+import { logger } from '../utils/logger.js';
+import { CacheManager } from '../utils/cache.js';
+import { CodeCollector } from '../modules/collector/CodeCollector.js';
+import { PageController } from '../modules/collector/PageController.js';
+import { DOMInspector } from '../modules/collector/DOMInspector.js';
+import { ScriptManager } from '../modules/debugger/ScriptManager.js';
+import { DebuggerManager } from '../modules/debugger/DebuggerManager.js';
+import { RuntimeInspector } from '../modules/debugger/RuntimeInspector.js';
+import { ConsoleMonitor } from '../modules/monitor/ConsoleMonitor.js';
+import { BrowserToolHandlers } from './BrowserToolHandlers.js';
+import { DebuggerToolHandlers } from './DebuggerToolHandlers.js';
+import { AdvancedToolHandlers } from './AdvancedToolHandlers.js';
+import { AIHookToolHandlers } from './AIHookToolHandlers.js';
+import { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
+import { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
+import { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
+import { ObfuscationDetector } from '../modules/detector/ObfuscationDetector.js';
+import { LLMService } from '../services/LLMService.js';
+import { CodeAnalyzer } from '../modules/analyzer/CodeAnalyzer.js';
+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';
+export class MCPServer {
+    server;
+    cache;
+    collector;
+    pageController;
+    domInspector;
+    scriptManager;
+    debuggerManager;
+    runtimeInspector;
+    consoleMonitor;
+    browserHandlers;
+    debuggerHandlers;
+    tokenBudget;
+    unifiedCache;
+    advancedHandlers;
+    aiHookHandlers;
+    deobfuscator;
+    advancedDeobfuscator;
+    astOptimizer;
+    obfuscationDetector;
+    llm;
+    analyzer;
+    cryptoDetector;
+    hookManager;
+    constructor(config) {
+        this.cache = new CacheManager(config.cache);
+        this.collector = new CodeCollector(config.puppeteer);
+        this.pageController = new PageController(this.collector);
+        this.domInspector = new DOMInspector(this.collector);
+        this.scriptManager = new ScriptManager(this.collector);
+        this.debuggerManager = new DebuggerManager(this.collector);
+        this.consoleMonitor = new ConsoleMonitor(this.collector);
+        this.runtimeInspector = new RuntimeInspector(this.collector, this.debuggerManager);
+        this.llm = new LLMService(config.llm);
+        this.browserHandlers = new BrowserToolHandlers(this.collector, this.pageController, this.domInspector, this.scriptManager, this.consoleMonitor, this.llm);
+        this.debuggerHandlers = new DebuggerToolHandlers(this.debuggerManager, this.runtimeInspector);
+        this.advancedHandlers = new AdvancedToolHandlers(this.collector, this.consoleMonitor);
+        this.aiHookHandlers = new AIHookToolHandlers(this.pageController);
+        this.deobfuscator = new Deobfuscator(this.llm);
+        this.advancedDeobfuscator = new AdvancedDeobfuscator(this.llm);
+        this.astOptimizer = new ASTOptimizer();
+        this.obfuscationDetector = new ObfuscationDetector();
+        this.analyzer = new CodeAnalyzer(this.llm);
+        this.cryptoDetector = new CryptoDetector(this.llm);
+        this.hookManager = new HookManager();
+        this.tokenBudget = TokenBudgetManager.getInstance();
+        logger.info('TokenBudgetManager initialized');
+        this.unifiedCache = UnifiedCacheManager.getInstance();
+        logger.info('UnifiedCacheManager initialized');
+        this.server = new McpServer({
+            name: config.mcp.name,
+            version: config.mcp.version,
+        });
+        this.registerTools();
+        logger.info('MCP Server initialized with tools');
+    }
+    async registerCaches() {
+        try {
+            logger.info('Starting cache registration...');
+            const { DetailedDataManager } = await import('../utils/detailedDataManager.js');
+            const { createCacheAdapters } = await import('../utils/CacheAdapters.js');
+            const detailedDataManager = DetailedDataManager.getInstance();
+            let codeCache, codeCompressor;
+            try {
+                codeCache = this.collector.getCache();
+                codeCompressor = this.collector.getCompressor();
+            }
+            catch (error) {
+                logger.warn('Collector cache methods not available, using fallback');
+                codeCache = this.collector.cache;
+                codeCompressor = this.collector.compressor;
+            }
+            const adapters = createCacheAdapters(detailedDataManager, codeCache, codeCompressor);
+            for (const adapter of adapters) {
+                this.unifiedCache.registerCache(adapter);
+            }
+            logger.info(`All caches registered to UnifiedCacheManager (${adapters.length} adapters)`);
+        }
+        catch (error) {
+            logger.error('Failed to register caches:', error);
+            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) }] };
+        });
+        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) }] };
+        });
+    }
+    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) }] };
+        });
+    }
+    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 (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'),
+            },
+        }, 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'),
+            },
+        }, 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(),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, 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'),
+            },
+        }, async (args) => {
+            const result = await handlers.handleAIHookExport(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        });
+    }
+    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 handleSearchInScripts(args) {
+        const { ScriptManager } = await import('../modules/debugger/ScriptManager.js');
+        const scriptManager = new ScriptManager(this.collector);
+        await scriptManager.init();
+        const maxMatches = args.maxMatches ?? 100;
+        const returnSummary = args.returnSummary ?? false;
+        const maxContextSize = args.maxContextSize ?? 50000;
+        const result = await scriptManager.searchInScripts(args.keyword, {
+            isRegex: args.isRegex,
+            caseSensitive: args.caseSensitive,
+            contextLines: args.contextLines,
+            maxMatches: maxMatches,
+        });
+        const resultStr = JSON.stringify(result);
+        const resultSize = resultStr.length;
+        const isTooLarge = resultSize > maxContextSize;
+        if (returnSummary || isTooLarge) {
+            const summary = {
+                success: true,
+                keyword: args.keyword,
+                totalMatches: result.matches?.length || 0,
+                resultSize: resultSize,
+                resultSizeKB: (resultSize / 1024).toFixed(2),
+                truncated: isTooLarge,
+                reason: isTooLarge
+                    ? `Result too large (${(resultSize / 1024).toFixed(2)} KB > ${(maxContextSize / 1024).toFixed(2)} KB)`
+                    : 'Summary mode enabled',
+                matchesSummary: (result.matches || []).slice(0, 10).map((m) => ({
+                    scriptId: m.scriptId,
+                    url: m.url,
+                    line: m.line,
+                    preview: m.context?.substring(0, 100) + '...',
+                })),
+                tip: isTooLarge
+                    ? 'Reduce maxMatches parameter or use more specific keyword to get full results'
+                    : 'Set returnSummary=false to get full results',
+                recommendations: [
+                    '1. Use more specific keywords to reduce matches',
+                    '2. Reduce maxMatches parameter (current: ' + maxMatches + ')',
+                    '3. Use get_script_source to fetch specific files',
+                    '4. Filter by scriptId or URL pattern',
+                ],
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(summary, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleExtractFunctionTree(args) {
+        const { ScriptManager } = await import('../modules/debugger/ScriptManager.js');
+        const scriptManager = new ScriptManager(this.collector);
+        await scriptManager.init();
+        const result = await scriptManager.extractFunctionTree(args.scriptId, args.functionName, {
+            maxDepth: args.maxDepth,
+            maxSize: args.maxSize,
+            includeComments: args.includeComments,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleDeobfuscate(args) {
+        const result = await this.deobfuscator.deobfuscate({
+            code: args.code,
+            llm: args.llm,
+            aggressive: args.aggressive,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleUnderstandCode(args) {
+        const result = await this.analyzer.understand({
+            code: args.code,
+            context: args.context,
+            focus: args.focus || 'all',
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleDetectCrypto(args) {
+        const result = await this.cryptoDetector.detect({
+            code: args.code,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleManageHooks(args) {
+        const action = args.action;
+        switch (action) {
+            case 'create': {
+                const result = await this.hookManager.createHook({
+                    target: args.target,
+                    type: args.type,
+                    action: args.hookAction || 'log',
+                    customCode: args.customCode,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'list': {
+                const hooks = this.hookManager.getAllHooks();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ hooks }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'records': {
+                const hookId = args.hookId;
+                const records = this.hookManager.getHookRecords(hookId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ records }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'clear': {
+                this.hookManager.clearHookRecords(args.hookId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Hook records cleared',
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown hook action: ${action}`);
+        }
+    }
+    async handleDetectObfuscation(args) {
+        const code = args.code;
+        const generateReport = args.generateReport ?? true;
+        const result = this.obfuscationDetector.detect(code);
+        let text = JSON.stringify(result, null, 2);
+        if (generateReport) {
+            text += '\n\n' + this.obfuscationDetector.generateReport(result);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text,
+                },
+            ],
+        };
+    }
+    async handleAdvancedDeobfuscate(args) {
+        const code = args.code;
+        const detectOnly = args.detectOnly ?? false;
+        const aggressiveVM = args.aggressiveVM ?? false;
+        const useASTOptimization = args.useASTOptimization ?? true;
+        const timeout = args.timeout ?? 60000;
+        const result = await this.advancedDeobfuscator.deobfuscate({
+            code,
+            detectOnly,
+            aggressiveVM,
+            timeout,
+        });
+        let finalCode = result.code;
+        if (useASTOptimization && !detectOnly) {
+            logger.info('Applying AST optimizations...');
+            finalCode = this.astOptimizer.optimize(finalCode);
+        }
+        const response = {
+            ...result,
+            code: finalCode,
+            astOptimized: useASTOptimization && !detectOnly,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    async handleClearCollectedData(_args) {
+        try {
+            await this.collector.clearAllData();
+            this.scriptManager.clear();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: '✅ All collected data cleared successfully',
+                            cleared: {
+                                fileCache: true,
+                                compressionCache: true,
+                                collectedUrls: true,
+                                scriptManager: true,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to clear collected data:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleGetCollectionStats(_args) {
+        try {
+            const stats = await this.collector.getAllStats();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            stats,
+                            summary: {
+                                totalCachedFiles: stats.cache.memoryEntries + stats.cache.diskEntries,
+                                totalCacheSize: `${(stats.cache.totalSize / 1024).toFixed(2)} KB`,
+                                compressionRatio: `${stats.compression.averageRatio.toFixed(1)}%`,
+                                cacheHitRate: stats.compression.cacheHits > 0
+                                    ? `${((stats.compression.cacheHits / (stats.compression.cacheHits + stats.compression.cacheMisses)) * 100).toFixed(1)}%`
+                                    : '0%',
+                                collectedUrls: stats.collector.collectedUrls,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get collection stats:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleGetTokenBudgetStats(_args) {
+        try {
+            const stats = this.tokenBudget.getStats();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ...stats,
+                            sessionDuration: `${Math.round((Date.now() - stats.sessionStartTime) / 1000)}s`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get token budget stats:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleManualTokenCleanup(_args) {
+        try {
+            const beforeStats = this.tokenBudget.getStats();
+            this.tokenBudget.manualCleanup();
+            const afterStats = this.tokenBudget.getStats();
+            const freed = beforeStats.currentUsage - afterStats.currentUsage;
+            const freedPercentage = Math.round((freed / beforeStats.maxTokens) * 100);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Manual cleanup completed',
+                            before: {
+                                usage: beforeStats.currentUsage,
+                                percentage: beforeStats.usagePercentage,
+                            },
+                            after: {
+                                usage: afterStats.currentUsage,
+                                percentage: afterStats.usagePercentage,
+                            },
+                            freed: {
+                                tokens: freed,
+                                percentage: freedPercentage,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to perform manual cleanup:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleResetTokenBudget(_args) {
+        try {
+            this.tokenBudget.reset();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Token budget reset successfully',
+                            currentUsage: 0,
+                            maxTokens: 200000,
+                            usagePercentage: 0,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to reset token budget:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleGetCacheStats(_args) {
+        try {
+            const stats = await this.unifiedCache.getGlobalStats();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ...stats,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get cache stats:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleSmartCacheCleanup(args) {
+        try {
+            const targetSize = args.targetSize;
+            const result = await this.unifiedCache.smartCleanup(targetSize);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ...result,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to cleanup cache:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleClearAllCaches(_args) {
+        try {
+            await this.unifiedCache.clearAll();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'All caches cleared',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error('Failed to clear all caches:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async start() {
+        logger.info('Starting MCP server...');
+        try {
+            await this.registerCaches();
+            await this.cache.init();
+            logger.info('Cache initialized');
+            const transport = new StdioServerTransport();
+            logger.info('Transport created');
+            await this.server.connect(transport);
+            logger.success('MCP server connected to transport');
+            logger.success('MCP server started successfully');
+        }
+        catch (error) {
+            logger.error('Failed to start MCP server:', error);
+            throw error;
+        }
+    }
+    async close() {
+        logger.info('Closing MCP server...');
+        await this.collector.close();
+        await this.server.close();
+        logger.success('MCP server closed');
+    }
+}
+//# sourceMappingURL=MCPServer.js.map