@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/modules/collector/PageController.js

@@ -1,301 +0,0 @@
-import { logger } from '../../utils/logger.js';
-export class PageController {
-    collector;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    async navigate(url, options) {
-        const page = await this.collector.getActivePage();
-        const startTime = Date.now();
-        await page.goto(url, {
-            waitUntil: options?.waitUntil || 'networkidle2',
-            timeout: options?.timeout || 30000,
-        });
-        const loadTime = Date.now() - startTime;
-        const title = await page.title();
-        const currentUrl = page.url();
-        logger.info(`Navigated to: ${url}`);
-        return {
-            url: currentUrl,
-            title,
-            loadTime,
-        };
-    }
-    async reload(options) {
-        const page = await this.collector.getActivePage();
-        await page.reload({
-            waitUntil: options?.waitUntil || 'networkidle2',
-            timeout: options?.timeout || 30000,
-        });
-        logger.info('Page reloaded');
-    }
-    async goBack() {
-        const page = await this.collector.getActivePage();
-        await page.goBack();
-        logger.info('Navigated back');
-    }
-    async goForward() {
-        const page = await this.collector.getActivePage();
-        await page.goForward();
-        logger.info('Navigated forward');
-    }
-    async click(selector, options) {
-        const page = await this.collector.getActivePage();
-        await page.click(selector, {
-            button: options?.button || 'left',
-            clickCount: options?.clickCount || 1,
-            delay: options?.delay,
-        });
-        logger.info(`Clicked: ${selector}`);
-    }
-    async type(selector, text, options) {
-        const page = await this.collector.getActivePage();
-        await page.type(selector, text, {
-            delay: options?.delay,
-        });
-        logger.info(`Typed into ${selector}: ${text.substring(0, 20)}...`);
-    }
-    async select(selector, ...values) {
-        const page = await this.collector.getActivePage();
-        await page.select(selector, ...values);
-        logger.info(`Selected in ${selector}: ${values.join(', ')}`);
-    }
-    async hover(selector) {
-        const page = await this.collector.getActivePage();
-        await page.hover(selector);
-        logger.info(`Hovered: ${selector}`);
-    }
-    async scroll(options) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((opts) => {
-            window.scrollTo(opts.x || 0, opts.y || 0);
-        }, options);
-        logger.info(`Scrolled to: x=${options.x || 0}, y=${options.y || 0}`);
-    }
-    async waitForSelector(selector, timeout) {
-        try {
-            const page = await this.collector.getActivePage();
-            await page.waitForSelector(selector, {
-                timeout: timeout || 30000,
-            });
-            const element = await page.evaluate((sel) => {
-                const el = document.querySelector(sel);
-                if (!el)
-                    return null;
-                return {
-                    tagName: el.tagName.toLowerCase(),
-                    id: el.id || undefined,
-                    className: el.className || undefined,
-                    textContent: el.textContent?.trim().substring(0, 100) || undefined,
-                    attributes: Array.from(el.attributes).reduce((acc, attr) => {
-                        acc[attr.name] = attr.value;
-                        return acc;
-                    }, {}),
-                };
-            }, selector);
-            logger.info(`Selector appeared: ${selector}`);
-            return {
-                success: true,
-                element,
-                message: `Selector appeared: ${selector}`,
-            };
-        }
-        catch (error) {
-            logger.error(`waitForSelector timeout for ${selector}:`, error);
-            return {
-                success: false,
-                message: `Timeout waiting for selector: ${selector}`,
-            };
-        }
-    }
-    async waitForNavigation(timeout) {
-        const page = await this.collector.getActivePage();
-        await page.waitForNavigation({
-            waitUntil: 'networkidle2',
-            timeout: timeout || 30000,
-        });
-        logger.info('Navigation completed');
-    }
-    async evaluate(code) {
-        const page = await this.collector.getActivePage();
-        const result = await page.evaluate(code);
-        logger.info('JavaScript executed');
-        return result;
-    }
-    async getURL() {
-        const page = await this.collector.getActivePage();
-        return page.url();
-    }
-    async getTitle() {
-        const page = await this.collector.getActivePage();
-        return await page.title();
-    }
-    async getContent() {
-        const page = await this.collector.getActivePage();
-        return await page.content();
-    }
-    async screenshot(options) {
-        const page = await this.collector.getActivePage();
-        const buffer = await page.screenshot({
-            path: options?.path,
-            type: options?.type || 'png',
-            quality: options?.quality,
-            fullPage: options?.fullPage || false,
-        });
-        logger.info(`Screenshot taken${options?.path ? `: ${options.path}` : ''}`);
-        return buffer;
-    }
-    async getPerformanceMetrics() {
-        const page = await this.collector.getActivePage();
-        const metrics = await page.evaluate(() => {
-            const perf = performance.getEntriesByType('navigation')[0];
-            return {
-                domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
-                loadComplete: perf.loadEventEnd - perf.loadEventStart,
-                dns: perf.domainLookupEnd - perf.domainLookupStart,
-                tcp: perf.connectEnd - perf.connectStart,
-                request: perf.responseStart - perf.requestStart,
-                response: perf.responseEnd - perf.responseStart,
-                total: perf.loadEventEnd - perf.fetchStart,
-                resources: performance.getEntriesByType('resource').length,
-            };
-        });
-        logger.info('Performance metrics retrieved');
-        return metrics;
-    }
-    async injectScript(scriptContent) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((script) => {
-            const scriptElement = document.createElement('script');
-            scriptElement.textContent = script;
-            document.head.appendChild(scriptElement);
-        }, scriptContent);
-        logger.info('Script injected into page');
-    }
-    async setCookies(cookies) {
-        const page = await this.collector.getActivePage();
-        await page.setCookie(...cookies);
-        logger.info(`Set ${cookies.length} cookies`);
-    }
-    async getCookies() {
-        const page = await this.collector.getActivePage();
-        const cookies = await page.cookies();
-        logger.info(`Retrieved ${cookies.length} cookies`);
-        return cookies;
-    }
-    async clearCookies() {
-        const page = await this.collector.getActivePage();
-        const cookies = await page.cookies();
-        await page.deleteCookie(...cookies);
-        logger.info('All cookies cleared');
-    }
-    async setViewport(width, height) {
-        const page = await this.collector.getActivePage();
-        await page.setViewport({ width, height });
-        logger.info(`Viewport set to ${width}x${height}`);
-    }
-    async emulateDevice(deviceName) {
-        const page = await this.collector.getActivePage();
-        const devices = {
-            iPhone: {
-                viewport: { width: 375, height: 812, isMobile: true },
-                userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
-            },
-            iPad: {
-                viewport: { width: 768, height: 1024, isMobile: true },
-                userAgent: 'Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
-            },
-            Android: {
-                viewport: { width: 360, height: 640, isMobile: true },
-                userAgent: 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 Chrome/91.0.4472.120',
-            },
-        };
-        const normalized = String(deviceName || '').trim().toLowerCase();
-        let resolvedDevice = null;
-        if (normalized.includes('iphone')) {
-            resolvedDevice = 'iPhone';
-        }
-        else if (normalized.includes('ipad')) {
-            resolvedDevice = 'iPad';
-        }
-        else if (normalized.includes('android') || normalized.includes('pixel')) {
-            resolvedDevice = 'Android';
-        }
-        if (!resolvedDevice) {
-            throw new Error(`Unsupported device "${deviceName}". Supported values include: iPhone, iPad, Android (aliases like "iPhone 13" are accepted).`);
-        }
-        const device = devices[resolvedDevice];
-        await page.setViewport(device.viewport);
-        await page.setUserAgent(device.userAgent);
-        logger.info(`Emulating ${resolvedDevice} (input: ${deviceName})`);
-        return resolvedDevice;
-    }
-    async waitForNetworkIdle(timeout = 30000) {
-        const page = await this.collector.getActivePage();
-        await page.waitForNetworkIdle({ timeout });
-        logger.info('Network is idle');
-    }
-    async getLocalStorage() {
-        const page = await this.collector.getActivePage();
-        const storage = await page.evaluate(() => {
-            const items = {};
-            for (let i = 0; i < localStorage.length; i++) {
-                const key = localStorage.key(i);
-                if (key) {
-                    items[key] = localStorage.getItem(key) || '';
-                }
-            }
-            return items;
-        });
-        logger.info(`Retrieved ${Object.keys(storage).length} localStorage items`);
-        return storage;
-    }
-    async setLocalStorage(key, value) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((k, v) => {
-            localStorage.setItem(k, v);
-        }, key, value);
-        logger.info(`Set localStorage: ${key}`);
-    }
-    async clearLocalStorage() {
-        const page = await this.collector.getActivePage();
-        await page.evaluate(() => {
-            localStorage.clear();
-        });
-        logger.info('LocalStorage cleared');
-    }
-    async pressKey(key) {
-        const page = await this.collector.getActivePage();
-        await page.keyboard.press(key);
-        logger.info(`Pressed key: ${key}`);
-    }
-    async uploadFile(selector, filePath) {
-        const page = await this.collector.getActivePage();
-        const input = await page.$(selector);
-        if (!input) {
-            throw new Error(`File input not found: ${selector}`);
-        }
-        await input.uploadFile(filePath);
-        logger.info(`File uploaded: ${filePath}`);
-    }
-    async getAllLinks() {
-        const page = await this.collector.getActivePage();
-        const links = await page.evaluate(() => {
-            const anchors = document.querySelectorAll('a[href]');
-            const result = [];
-            for (let i = 0; i < anchors.length; i++) {
-                const anchor = anchors[i];
-                result.push({
-                    text: anchor.textContent?.trim() || '',
-                    href: anchor.href,
-                });
-            }
-            return result;
-        });
-        logger.info(`Found ${links.length} links`);
-        return links;
-    }
-    async getPage() {
-        return await this.collector.getActivePage();
-    }
-}

package/dist/modules/deobfuscator/AdvancedDeobfuscator.d.ts

@@ -1,43 +0,0 @@
-import { LLMService } from '../../services/LLMService.js';
-export interface AdvancedDeobfuscateOptions {
-    code: string;
-    detectOnly?: boolean;
-    aggressiveVM?: boolean;
-    useASTOptimization?: boolean;
-    timeout?: number;
-}
-export interface AdvancedDeobfuscateResult {
-    code: string;
-    detectedTechniques: string[];
-    confidence: number;
-    warnings: string[];
-    astOptimized?: boolean;
-    vmDetected?: {
-        type: string;
-        instructions: number;
-        deobfuscated: boolean;
-    };
-}
-export declare class AdvancedDeobfuscator {
-    private llm?;
-    private vmDeobfuscator;
-    constructor(llm?: LLMService);
-    deobfuscate(options: AdvancedDeobfuscateOptions): Promise<AdvancedDeobfuscateResult>;
-    private detectInvisibleUnicode;
-    private decodeInvisibleUnicode;
-    private detectControlFlowFlattening;
-    private unflattenControlFlow;
-    private detectStringArrayRotation;
-    private derotateStringArray;
-    private detectDeadCodeInjection;
-    private removeDeadCode;
-    private detectOpaquePredicates;
-    private removeOpaquePredicates;
-    private llmCleanup;
-    private normalizeCode;
-    private detectStringEncoding;
-    private decodeStrings;
-    private applyASTOptimizations;
-    private calculateConfidence;
-    private estimateCodeComplexity;
-}

package/dist/modules/deobfuscator/AdvancedDeobfuscator.js

@@ -1,252 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { ADV_DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
-import { generateCodeCleanupMessages, generateControlFlowUnflatteningMessages, } from '../../services/prompts/deobfuscation.js';
-import { VMDeobfuscator } from '../deobfuscator/VMDeobfuscator.js';
-import { applyASTOptimizations as applyASTOptimizationsUtil, decodeStrings as decodeStringsUtil, derotateStringArray as derotateStringArrayUtil, estimateCodeComplexity as estimateCodeComplexityUtil, removeDeadCode as removeDeadCodeUtil, removeOpaquePredicates as removeOpaquePredicatesUtil, } from '../deobfuscator/AdvancedDeobfuscator.ast.js';
-export class AdvancedDeobfuscator {
-    llm;
-    vmDeobfuscator;
-    constructor(llm) {
-        this.llm = llm;
-        this.vmDeobfuscator = new VMDeobfuscator(llm);
-    }
-    async deobfuscate(options) {
-        logger.info('Starting advanced deobfuscation...');
-        const startTime = Date.now();
-        let code = options.code;
-        const detectedTechniques = [];
-        const warnings = [];
-        let vmDetected;
-        let astOptimized = false;
-        try {
-            code = this.normalizeCode(code);
-            if (this.detectInvisibleUnicode(code)) {
-                detectedTechniques.push('invisible-unicode');
-                logger.info('Detected: Invisible Unicode Obfuscation');
-                code = this.decodeInvisibleUnicode(code);
-            }
-            if (this.detectStringEncoding(code)) {
-                detectedTechniques.push('string-encoding');
-                logger.info('Detected: String Encoding');
-                code = this.decodeStrings(code);
-            }
-            const vmInfo = this.vmDeobfuscator.detectVMProtection(code);
-            if (vmInfo.detected) {
-                detectedTechniques.push('vm-protection');
-                logger.info(`Detected: VM Protection (${vmInfo.type})`);
-                vmDetected = {
-                    type: vmInfo.type,
-                    instructions: vmInfo.instructionCount,
-                    deobfuscated: false,
-                };
-                if (options.aggressiveVM) {
-                    const vmResult = await this.vmDeobfuscator.deobfuscateVM(code, vmInfo);
-                    if (vmResult.success) {
-                        code = vmResult.code;
-                        vmDetected.deobfuscated = true;
-                    }
-                    else {
-                        warnings.push('VM deobfuscation failed, code may be incomplete');
-                    }
-                }
-            }
-            if (this.detectControlFlowFlattening(code)) {
-                detectedTechniques.push('control-flow-flattening');
-                logger.info('Detected: Control Flow Flattening');
-                code = await this.unflattenControlFlow(code);
-            }
-            if (this.detectStringArrayRotation(code)) {
-                detectedTechniques.push('string-array-rotation');
-                logger.info('Detected: String Array Rotation');
-                code = this.derotateStringArray(code);
-            }
-            if (this.detectDeadCodeInjection(code)) {
-                detectedTechniques.push('dead-code-injection');
-                logger.info('Detected: Dead Code Injection');
-                code = this.removeDeadCode(code);
-            }
-            if (this.detectOpaquePredicates(code)) {
-                detectedTechniques.push('opaque-predicates');
-                logger.info('Detected: Opaque Predicates');
-                code = this.removeOpaquePredicates(code);
-            }
-            if (options.useASTOptimization !== false) {
-                logger.info('Applying AST optimizations...');
-                const optimized = this.applyASTOptimizations(code);
-                if (optimized !== code) {
-                    code = optimized;
-                    astOptimized = true;
-                    detectedTechniques.push('ast-optimized');
-                }
-            }
-            if (this.llm && detectedTechniques.length > 0) {
-                logger.info('Using LLM for final cleanup...');
-                const llmResult = await this.llmCleanup(code, detectedTechniques);
-                if (llmResult) {
-                    code = llmResult;
-                }
-            }
-            const duration = Date.now() - startTime;
-            const confidence = this.calculateConfidence(detectedTechniques, warnings, code);
-            logger.success(`Advanced deobfuscation completed in ${duration}ms`);
-            return {
-                code,
-                detectedTechniques,
-                confidence,
-                warnings,
-                vmDetected,
-                astOptimized,
-            };
-        }
-        catch (error) {
-            logger.error('Advanced deobfuscation failed', error);
-            throw error;
-        }
-    }
-    detectInvisibleUnicode(code) {
-        const invisibleChars = ['\u200B', '\u200C', '\u200D', '\u2060', '\uFEFF'];
-        return invisibleChars.some((char) => code.includes(char));
-    }
-    decodeInvisibleUnicode(code) {
-        logger.info('Decoding invisible unicode...');
-        const charToBit = {
-            '\u200B': '0',
-            '\u200C': '1',
-            '\u200D': '00',
-            '\u2060': '01',
-            '\uFEFF': '10',
-        };
-        let decoded = code;
-        const invisiblePattern = /[\u200B\u200C\u200D\u2060\uFEFF]+/g;
-        const matches = code.match(invisiblePattern);
-        if (matches) {
-            matches.forEach((match) => {
-                let binary = '';
-                for (const char of match) {
-                    binary += charToBit[char] || '';
-                }
-                if (binary.length % 8 === 0) {
-                    let text = '';
-                    for (let i = 0; i < binary.length; i += 8) {
-                        const byte = binary.substring(i, i + 8);
-                        text += String.fromCharCode(parseInt(byte, 2));
-                    }
-                    decoded = decoded.replace(match, text);
-                }
-            });
-        }
-        return decoded;
-    }
-    detectControlFlowFlattening(code) {
-        const pattern = /while\s*\(\s*!!\s*\[\s*\]\s*\)\s*\{[\s\S]*?switch\s*\(/i;
-        return pattern.test(code);
-    }
-    async unflattenControlFlow(code) {
-        logger.info('Unflattening control flow...');
-        if (this.llm) {
-            try {
-                const codeSnippet = code.length > 2000 ? code.slice(0, 2000) + '\n...(truncated)' : code;
-                const response = await this.llm.chat(generateControlFlowUnflatteningMessages(codeSnippet), {
-                    temperature: 0.1,
-                    maxTokens: ADV_DEOBF_LLM_MAX_TOKENS,
-                });
-                return this.vmDeobfuscator.extractCodeFromLLMResponse(response.content);
-            }
-            catch (error) {
-                logger.warn('LLM control flow unflattening failed', error);
-            }
-        }
-        return code;
-    }
-    detectStringArrayRotation(code) {
-        return /\w+\s*=\s*\w+\s*\+\s*0x[0-9a-f]+/.test(code);
-    }
-    derotateStringArray(code) {
-        return derotateStringArrayUtil(code);
-    }
-    detectDeadCodeInjection(code) {
-        return /if\s*\(\s*false\s*\)|if\s*\(\s*!!\s*\[\s*\]\s*\)/.test(code);
-    }
-    removeDeadCode(code) {
-        return removeDeadCodeUtil(code);
-    }
-    detectOpaquePredicates(code) {
-        return /if\s*\(\s*\d+\s*[<>!=]+\s*\d+\s*\)/.test(code);
-    }
-    removeOpaquePredicates(code) {
-        return removeOpaquePredicatesUtil(code);
-    }
-    async llmCleanup(code, techniques) {
-        if (!this.llm)
-            return null;
-        try {
-            const response = await this.llm.chat(generateCodeCleanupMessages(code, techniques), {
-                temperature: 0.15,
-                maxTokens: 3000,
-            });
-            const cleanedCode = this.vmDeobfuscator.extractCodeFromLLMResponse(response.content);
-            if (this.vmDeobfuscator.isValidJavaScript(cleanedCode)) {
-                logger.success('LLM cleanup succeeded');
-                return cleanedCode;
-            }
-            else {
-                logger.warn('LLM cleanup produced invalid JavaScript');
-                return null;
-            }
-        }
-        catch (error) {
-            logger.warn('LLM cleanup failed', error);
-            return null;
-        }
-    }
-    normalizeCode(code) {
-        code = code.replace(/\s+/g, ' ');
-        code = code.replace(/\/\*[\s\S]*?\*\//g, '');
-        code = code.replace(/\/\/.*/g, '');
-        return code.trim();
-    }
-    detectStringEncoding(code) {
-        const patterns = [/\\x[0-9a-f]{2}/i, /\\u[0-9a-f]{4}/i, /String\.fromCharCode/i, /atob\(/i];
-        return patterns.some((p) => p.test(code));
-    }
-    decodeStrings(code) {
-        return decodeStringsUtil(code);
-    }
-    applyASTOptimizations(code) {
-        return applyASTOptimizationsUtil(code);
-    }
-    calculateConfidence(techniques, warnings, code) {
-        let confidence = 0.3;
-        const techniqueBonus = Math.min(techniques.length * 0.12, 0.5);
-        confidence += techniqueBonus;
-        const warningPenalty = warnings.length * 0.08;
-        confidence -= warningPenalty;
-        const highConfidenceTechniques = [
-            'invisible-unicode',
-            'string-array-rotation',
-            'dead-code-injection',
-            'opaque-predicates',
-            'string-encoding',
-            'ast-optimized',
-        ];
-        const highConfidenceCount = techniques.filter((t) => highConfidenceTechniques.some((ht) => t.includes(ht))).length;
-        confidence += highConfidenceCount * 0.05;
-        if (techniques.some((t) => t.includes('vm-protection'))) {
-            confidence -= 0.15;
-        }
-        if (techniques.some((t) => t.includes('control-flow-flattening'))) {
-            confidence -= 0.05;
-        }
-        const complexity = this.estimateCodeComplexity(code);
-        if (complexity < 10) {
-            confidence += 0.1;
-        }
-        else if (complexity > 100) {
-            confidence -= 0.1;
-        }
-        return Math.max(0.1, Math.min(0.95, confidence));
-    }
-    estimateCodeComplexity(code) {
-        return estimateCodeComplexityUtil(code);
-    }
-}

package/dist/modules/deobfuscator/Deobfuscator.d.ts

@@ -1,22 +0,0 @@
-import type { DeobfuscateOptions, DeobfuscateResult } from '../../types/index.js';
-import { LLMService } from '../../services/LLMService.js';
-export declare class Deobfuscator {
-    private llm?;
-    private stringArrays;
-    private resultCache;
-    private maxCacheSize;
-    constructor(llm?: LLMService);
-    private generateCacheKey;
-    deobfuscate(options: DeobfuscateOptions): Promise<DeobfuscateResult>;
-    private detectObfuscationType;
-    private basicTransform;
-    private decodeStrings;
-    private llmAnalysis;
-    private calculateConfidence;
-    private extractStringArrays;
-    private decryptArrays;
-    private unflattenControlFlow;
-    private simplifyExpressions;
-    private renameVariables;
-    private calculateReadabilityScore;
-}