@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -103,13 +103,26 @@ export declare class PageController {
 export declare function evaluateWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: (...args: Args) => Result, ...args: Args): Promise<Awaited<Result>>;
 export declare function evaluateWithTimeout(page: Page, pageFunction: string, ...args: readonly unknown[]): Promise<unknown>;
 export declare function evaluateOnNewDocumentWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: string | ((...args: never[]) => Result), ...args: Args): Promise<unknown>;
-export declare function coverageStartJSWithTimeout(page: any, options?: {
+interface CoveragePage {
+    coverage: {
+        startJSCoverage(options?: {
+            resetOnNavigation?: boolean;
+            reportAnonymousScripts?: boolean;
+        }): Promise<void>;
+        stopJSCoverage(): Promise<unknown>;
+        startCSSCoverage(options?: {
+            resetOnNavigation?: boolean;
+        }): Promise<void>;
+        stopCSSCoverage(): Promise<unknown>;
+    };
+}
+export declare function coverageStartJSWithTimeout(page: CoveragePage, options?: {
     resetOnNavigation?: boolean;
     reportAnonymousScripts?: boolean;
 }): Promise<void>;
-export declare function coverageStartCSSWithTimeout(page: any, options?: {
+export declare function coverageStartCSSWithTimeout(page: CoveragePage, options?: {
     resetOnNavigation?: boolean;
 }): Promise<void>;
-export declare function coverageStopJSWithTimeout(page: any): Promise<unknown>;
-export declare function coverageStopCSSWithTimeout(page: any): Promise<unknown>;
+export declare function coverageStopJSWithTimeout(page: CoveragePage): Promise<unknown>;
+export declare function coverageStopCSSWithTimeout(page: CoveragePage): Promise<unknown>;
 export {};

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

@@ -313,10 +313,7 @@ async function checkPageCDPHealth(page, timeoutMs = 500) {
         throw new Error('cdp_unreachable');
     });
     try {
-        const cdp = await Promise.race([
-            page.createCDPSession(),
-            timer,
-        ]);
+        const cdp = await Promise.race([page.createCDPSession(), timer]);
         await Promise.race([
             cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
             timer,
@@ -326,7 +323,7 @@ async function checkPageCDPHealth(page, timeoutMs = 500) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg === 'cdp_unreachable') {
             throw new Error('CDP session unresponsive — the debugger may be blocking page evaluation. ' +
-                'Call debugger_disable() before this tool, or run it before debugger_enable().');
+                'Call debugger_disable() before this tool, or run it before debugger_enable().', { cause: err });
         }
         throw err;
     }

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

@@ -28,7 +28,7 @@ export async function setupWebWorkerTracking(page) {
     });
 }
 export async function collectInlineScripts(page, maxSingleSize, maxFilesPerCollect) {
-    const scripts = await page.evaluate((maxSingleSize) => {
+    const scripts = await page.evaluate((limit) => {
         const scriptElements = Array.from(document.querySelectorAll('script'));
         return scriptElements
             .filter((script) => !script.src && script.textContent)
@@ -36,8 +36,8 @@ export async function collectInlineScripts(page, maxSingleSize, maxFilesPerColle
             let content = script.textContent || '';
             const originalSize = content.length;
             let truncated = false;
-            if (content.length > maxSingleSize) {
-                content = content.substring(0, maxSingleSize);
+            if (content.length > limit) {
+                content = content.substring(0, limit);
                 truncated = true;
             }
             return {

package/dist/src/modules/crypto/CryptoDetector.d.ts

@@ -1,5 +1,4 @@
 import type { DetectCryptoOptions, DetectCryptoResult } from '../../types/index.js';
-import { LLMService } from '../../services/LLMService.js';
 import { CryptoRulesManager } from '../crypto/CryptoRules.js';
 export interface SecurityIssue {
     severity: 'critical' | 'high' | 'medium' | 'low';
@@ -22,9 +21,8 @@ export interface CryptoStrength {
     };
 }
 export declare class CryptoDetector {
-    private llm;
     private rulesManager;
-    constructor(llm: LLMService, customRules?: CryptoRulesManager);
+    constructor(_llm?: any, customRules?: CryptoRulesManager);
     loadCustomRules(json: string): void;
     exportRules(): string;
     detect(options: DetectCryptoOptions): Promise<DetectCryptoResult & {
@@ -33,7 +31,6 @@ export declare class CryptoDetector {
     }>;
     private detectByKeywords;
     private escapeRegex;
-    private detectByAI;
     private detectLibraries;
     private detectByAST;
     private mergeParameters;

package/dist/src/modules/crypto/CryptoDetector.js

@@ -1,16 +1,11 @@
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-import { LLMService } from '../../services/LLMService.js';
-import { generateCryptoDetectionPrompt } from '../../services/prompts/crypto.js';
 import { logger } from '../../utils/logger.js';
-import { CRYPTO_DETECT_LLM_MAX_TOKENS } from '../../constants.js';
 import { CryptoRulesManager } from '../crypto/CryptoRules.js';
 export class CryptoDetector {
-    llm;
     rulesManager;
-    constructor(llm, customRules) {
-        this.llm = llm;
+    constructor(_llm, customRules) {
         this.rulesManager = customRules || new CryptoRulesManager();
     }
     loadCustomRules(json) {
@@ -36,11 +31,6 @@ export class CryptoDetector {
             if (astResults.parameters) {
                 this.mergeParameters(algorithms, astResults.parameters);
             }
-            const useAI = options.useAI !== false;
-            if (useAI) {
-                const aiResults = await this.detectByAI(code);
-                algorithms.push(...aiResults);
-            }
             const mergedAlgorithms = this.mergeResults(algorithms);
             const securityResults = this.evaluateSecurity(mergedAlgorithms, code);
             securityIssues.push(...securityResults);
@@ -82,36 +72,6 @@ export class CryptoDetector {
     escapeRegex(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
-    async detectByAI(code) {
-        try {
-            const messages = generateCryptoDetectionPrompt(code);
-            const response = await this.llm.chat(messages, {
-                temperature: 0.2,
-                maxTokens: CRYPTO_DETECT_LLM_MAX_TOKENS,
-            });
-            const jsonMatch = response.content.match(/\{[\s\S]*\}/);
-            if (!jsonMatch)
-                return [];
-            const result = JSON.parse(jsonMatch[0]);
-            if (!Array.isArray(result.algorithms))
-                return [];
-            return result.algorithms.map((algo) => {
-                const a = algo;
-                return {
-                    name: a.name || 'Unknown',
-                    type: a.type || 'other',
-                    confidence: a.confidence || 0.5,
-                    location: { file: 'current', line: 0 },
-                    parameters: a.parameters,
-                    usage: a.usage || '',
-                };
-            });
-        }
-        catch (error) {
-            logger.warn('AI crypto detection failed', error);
-            return [];
-        }
-    }
     detectLibraries(code) {
         const libraries = [];
         const libraryRules = this.rulesManager.getLibraryRules();
@@ -308,7 +268,7 @@ export class CryptoDetector {
                 merged.set(key, algo);
             }
         });
-        return Array.from(merged.values()).sort((a, b) => b.confidence - a.confidence);
+        return Array.from(merged.values()).toSorted((a, b) => b.confidence - a.confidence);
     }
     findLineNumber(code, keyword) {
         const lines = code.split('\n');

package/dist/src/modules/crypto/CryptoRules.js

@@ -288,7 +288,7 @@ export class CryptoRulesManager {
             }
         }
         catch (error) {
-            throw new Error(`Failed to load rules from JSON: ${error}`);
+            throw new Error(`Failed to load rules from JSON: ${error}`, { cause: error });
         }
     }
     exportToJSON() {

package/dist/src/modules/debugger/BlackboxManager.js

@@ -31,7 +31,7 @@ export class BlackboxManager {
             return escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
         }
         try {
-            new RegExp(input);
+            void new RegExp(input);
             return input;
         }
         catch {

package/dist/src/modules/debugger/DebuggerManager.impl.core.scope.js

@@ -138,7 +138,7 @@ export async function getObjectPropertiesByIdCore(ctx, objectId) {
         const message = toErrorMessage(error);
         if (message.includes('Could not find object with given id') ||
             message.includes('Invalid remote object id')) {
-            throw new Error('Object handle is expired or invalid. Pause execution again and reacquire objectId from get_scope_variables_enhanced.');
+            throw new Error('Object handle is expired or invalid. Pause execution again and reacquire objectId from get_scope_variables_enhanced.', { cause: error });
         }
         throw error;
     }

package/dist/src/modules/debugger/ScriptManager.impl.extract-function-tree.js

@@ -14,7 +14,7 @@ const resolveCallableExport = (moduleValue, namedExport) => {
 export async function extractFunctionTreeCore(ctx, scriptId, functionName, options = {}) {
     const { maxDepth = 3, maxSize = 500, includeComments = true } = options;
     const script = await ctx.getScriptSource(scriptId);
-    if (!script || !script.source) {
+    if (!script?.source) {
         throw new Error(`Script not found: ${scriptId}`);
     }
     let parser;
@@ -38,7 +38,7 @@ export async function extractFunctionTreeCore(ctx, scriptId, functionName, optio
         t = await import('@babel/types');
     }
     catch (error) {
-        throw new Error(`Failed to load Babel dependencies. Please install: npm install @babel/parser @babel/traverse @babel/generator @babel/types\nError: ${getErrorMessage(error)}`);
+        throw new Error(`Failed to load Babel dependencies. Please install: npm install @babel/parser @babel/traverse @babel/generator @babel/types\nError: ${getErrorMessage(error)}`, { cause: error });
     }
     let ast;
     try {
@@ -48,7 +48,9 @@ export async function extractFunctionTreeCore(ctx, scriptId, functionName, optio
         });
     }
     catch (error) {
-        throw new Error(`Failed to parse script ${scriptId}: ${getErrorMessage(error)}`);
+        throw new Error(`Failed to parse script ${scriptId}: ${getErrorMessage(error)}`, {
+            cause: error,
+        });
     }
     const allFunctions = new Map();
     const callGraph = {};

package/dist/src/modules/debugger/WatchExpressionManager.js

@@ -101,7 +101,7 @@ export class WatchExpressionManager {
     deepEqual(a, b) {
         if (a === b)
             return true;
-        if (a == null || b == null)
+        if (a === null || a === undefined || b === null || b === undefined)
             return false;
         if (!this.isRecord(a) || !this.isRecord(b))
             return false;

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

@@ -1,15 +1,12 @@
 import type { DeobfuscateOptions, DeobfuscateResult } from '../../types/index.js';
-import { LLMService } from '../../services/LLMService.js';
 export declare class Deobfuscator {
-    private llm?;
     private resultCache;
     private maxCacheSize;
-    constructor(llm?: LLMService);
+    constructor(legacyDependency?: unknown);
     private generateCacheKey;
     deobfuscate(options: DeobfuscateOptions): Promise<DeobfuscateResult>;
     private detectObfuscationType;
     private calculateReadabilityScore;
     private calculateConfidence;
     private buildAnalysis;
-    private llmAnalysis;
 }

package/dist/src/modules/deobfuscator/Deobfuscator.js

@@ -1,16 +1,12 @@
 import crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
-import { DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
-import { LLMService } from '../../services/LLMService.js';
-import { generateDeobfuscationPrompt } from '../../services/prompts/deobfuscation.js';
 import { calculateReadabilityScore as calculateReadabilityScoreUtil, detectObfuscationType as detectObfuscationTypeUtil, } from '../deobfuscator/Deobfuscator.utils.js';
 import { runWebcrack } from '../deobfuscator/webcrack.js';
 export class Deobfuscator {
-    llm;
     resultCache = new Map();
     maxCacheSize = 100;
-    constructor(llm) {
-        this.llm = llm;
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
     generateCacheKey(options) {
         const key = JSON.stringify({
@@ -18,7 +14,7 @@ export class Deobfuscator {
             forceOutput: options.forceOutput,
             includeModuleCode: options.includeModuleCode,
             jsx: options.jsx,
-            llm: options.llm,
+            llm: false,
             mangle: options.mangle ?? options.renameVariables,
             mappings: options.mappings,
             maxBundleModules: options.maxBundleModules,
@@ -64,13 +60,7 @@ export class Deobfuscator {
             logger.error(`webcrack deobfuscation failed: ${reason}`);
             throw new Error(reason);
         }
-        let analysis = this.buildAnalysis(webcrackResult, obfuscationType);
-        if (this.llm && options.llm) {
-            const llmResult = await this.llmAnalysis(webcrackResult.code);
-            if (llmResult) {
-                analysis = llmResult;
-            }
-        }
+        const analysis = this.buildAnalysis(webcrackResult, obfuscationType);
         const transformations = [
             {
                 type: 'webcrack',
@@ -95,15 +85,6 @@ export class Deobfuscator {
                     },
                 ]
                 : []),
-            ...(this.llm && options.llm
-                ? [
-                    {
-                        type: 'llm-analysis',
-                        description: 'AI-assisted analysis completed after webcrack deobfuscation',
-                        success: true,
-                    },
-                ]
-                : []),
         ];
         const readabilityScore = this.calculateReadabilityScore(webcrackResult.code);
         const confidence = this.calculateConfidence(webcrackResult, readabilityScore);
@@ -161,20 +142,4 @@ export class Deobfuscator {
         }
         return parts.join(' ');
     }
-    async llmAnalysis(code) {
-        if (!this.llm)
-            return null;
-        try {
-            const messages = generateDeobfuscationPrompt(code);
-            const response = await this.llm.chat(messages, {
-                temperature: 0.3,
-                maxTokens: DEOBF_LLM_MAX_TOKENS,
-            });
-            return response.content;
-        }
-        catch (error) {
-            logger.warn('LLM analysis failed after webcrack deobfuscation', error);
-            return null;
-        }
-    }
 }

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.d.ts

@@ -1,9 +1,6 @@
 import type { JSVMPDeobfuscatorOptions, JSVMPDeobfuscatorResult } from '../../types/index.js';
-import type { LLMService } from '../../services/LLMService.js';
 export declare class JSVMPDeobfuscator {
-    private llm?;
     private readonly sandbox;
-    constructor(llm?: LLMService);
     deobfuscate(options: JSVMPDeobfuscatorOptions): Promise<JSVMPDeobfuscatorResult>;
     private detectJSVMP;
     private detectJSVMPWithRegex;

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.js

@@ -7,11 +7,7 @@ import { JSVMP_DEOBFUSCATE_TIMEOUT_MS, JSVMP_MAX_ITERATIONS } from '../../consta
 import { ExecutionSandbox } from '../security/ExecutionSandbox.js';
 import { restoreCustomVMBasic, restoreJSVMPCode, } from '../deobfuscator/JSVMPDeobfuscator.restore.js';
 export class JSVMPDeobfuscator {
-    llm;
     sandbox = new ExecutionSandbox();
-    constructor(llm) {
-        this.llm = llm;
-    }
     async deobfuscate(options) {
         const startTime = Date.now();
         const { code, aggressive = false, extractInstructions = false, timeout = JSVMP_DEOBFUSCATE_TIMEOUT_MS, maxIterations = JSVMP_MAX_ITERATIONS, } = options;
@@ -205,9 +201,8 @@ export class JSVMPDeobfuscator {
                 sourceType: 'unambiguous',
                 plugins: ['jsx', 'typescript'],
             });
-            const self = this;
             traverse(ast, {
-                SwitchStatement(path) {
+                SwitchStatement: (path) => {
                     if (path.node.cases.length === features.instructionCount) {
                         path.node.cases.forEach((caseNode, index) => {
                             const opcode = caseNode.test
@@ -217,7 +212,7 @@ export class JSVMPDeobfuscator {
                                         ? caseNode.test.value
                                         : index
                                 : index;
-                            const type = self.inferInstructionType(caseNode);
+                            const type = this.inferInstructionType(caseNode);
                             instructions.push({
                                 opcode,
                                 name: `INST_${opcode}`,
@@ -289,7 +284,6 @@ export class JSVMPDeobfuscator {
     async restoreCode(code, _features, vmType, aggressive, _timeout, _maxIterations) {
         void this.restoreCustomVMBasic;
         return restoreJSVMPCode({
-            llm: this.llm,
             sandbox: this.sandbox,
         }, code, vmType, aggressive);
     }

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.restore.d.ts

@@ -1,6 +1,5 @@
-import type { LLMService } from '../../services/LLMService.js';
 import type { UnresolvedPart, VMType } from '../../types/index.js';
-import { ExecutionSandbox } from '../security/ExecutionSandbox.js';
+import { type ExecutionSandbox } from '../security/ExecutionSandbox.js';
 type RestoreResult = {
     code: string;
     confidence: number;
@@ -8,7 +7,7 @@ type RestoreResult = {
     unresolvedParts?: UnresolvedPart[];
 };
 type RestoreContext = {
-    llm?: LLMService;
+    llm?: any;
     sandbox: ExecutionSandbox;
 };
 export declare function restoreJSVMPCode(context: RestoreContext, code: string, vmType: VMType, aggressive: boolean): Promise<RestoreResult>;

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.restore.js

@@ -1,6 +1,5 @@
-import { generateVMAnalysisMessages } from '../../services/prompts/deobfuscation.js';
 import { logger } from '../../utils/logger.js';
-import { ExecutionSandbox } from '../security/ExecutionSandbox.js';
+import {} from '../security/ExecutionSandbox.js';
 export async function restoreJSVMPCode(context, code, vmType, aggressive) {
     const warnings = [];
     const unresolvedParts = [];
@@ -138,7 +137,7 @@ async function restoreJJEncode(context, code, warnings) {
         try {
             const lines = code.split('\n').filter((line) => line.trim());
             const lastLine = lines.length > 0 ? lines[lines.length - 1] : '';
-            if (lastLine && lastLine.includes('$$$$')) {
+            if (lastLine?.includes('$$$$')) {
                 const sandboxResult = await context.sandbox.execute({
                     code: `${code}; return $$$$()`,
                     timeoutMs: 5000,
@@ -184,60 +183,9 @@ async function restoreJJEncode(context, code, warnings) {
         };
     }
 }
-async function restoreCustomVM(context, code, aggressive, warnings, unresolvedParts) {
-    if (!context.llm) {
-        warnings.push('LLM service unavailable, using fallback');
-        warnings.push('Configure DeepSeek/OpenAI API key for AI-assisted deobfuscation');
-        return restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts);
-    }
-    try {
-        logger.info(' LLMVM...');
-        const response = await context.llm.chat(generateVMAnalysisMessages(code));
-        const analysisText = response.content;
-        logger.info(' LLM');
-        logger.info(`: ${analysisText.substring(0, 200)}...`);
-        let vmAnalysis;
-        try {
-            const jsonMatch = analysisText.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const parsed = JSON.parse(jsonMatch[0]);
-                if (parsed && typeof parsed === 'object') {
-                    vmAnalysis = parsed;
-                }
-            }
-        }
-        catch {
-            warnings.push('LLM analysis failed, using fallback');
-            return restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts);
-        }
-        if (vmAnalysis) {
-            warnings.push(`LLMVM: ${typeof vmAnalysis.vmType === 'string' ? vmAnalysis.vmType : 'Unknown'}`);
-            const vmWarnings = vmAnalysis.warnings;
-            if (Array.isArray(vmWarnings)) {
-                warnings.push(...vmWarnings);
-            }
-            const restorationSteps = vmAnalysis.restorationSteps;
-            if (Array.isArray(restorationSteps)) {
-                unresolvedParts.push({
-                    location: 'VM Restoration',
-                    reason: 'LLM',
-                    suggestion: restorationSteps.join('\n'),
-                });
-            }
-            return {
-                code,
-                confidence: 0.6,
-                warnings,
-                unresolvedParts: unresolvedParts.length > 0 ? unresolvedParts : undefined,
-            };
-        }
-        return restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts);
-    }
-    catch (error) {
-        logger.error('LLM', error);
-        warnings.push(`LLM: ${error}`);
-        return restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts);
-    }
+async function restoreCustomVM(_context, code, aggressive, warnings, unresolvedParts) {
+    warnings.push('AI-assisted deobfuscation removed, using fallback directly.');
+    return restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts);
 }
 export function restoreCustomVMBasic(code, aggressive, warnings, unresolvedParts) {
     let restored = code;

package/dist/src/modules/deobfuscator/JScramblerDeobfuscator.js

@@ -144,12 +144,11 @@ export class JScramberDeobfuscator {
     }
     restoreControlFlow(ast) {
         let count = 0;
-        const self = this;
         traverse(ast, {
-            WhileStatement(path) {
-                if (self.isControlFlowFlatteningPattern(path.node)) {
+            WhileStatement: (path) => {
+                if (this.isControlFlowFlatteningPattern(path.node)) {
                     try {
-                        self.unflattenControlFlowPattern(path);
+                        this.unflattenControlFlowPattern(path);
                         count++;
                     }
                     catch { }

package/dist/src/modules/deobfuscator/PackerDeobfuscator.js

@@ -44,7 +44,7 @@ export class PackerDeobfuscator {
     }
     async unpack(code) {
         const match = code.match(/eval\s*\(\s*function\s*\(\s*p\s*,\s*a\s*,\s*c\s*,\s*k\s*,\s*e\s*,\s*[dr]\s*\)\s*{([\s\S]*?)}\s*\((.*?)\)\s*\)/);
-        if (!match || !match[2]) {
+        if (!match?.[2]) {
             return code;
         }
         const args = match[2];

package/dist/src/modules/deobfuscator/VMDeobfuscator.d.ts

@@ -1,4 +1,3 @@
-import { LLMService } from '../../services/LLMService.js';
 type VMStructure = {
     hasInterpreter: boolean;
     instructionTypes: string[];
@@ -11,15 +10,14 @@ type VMComponents = {
     interpreterFunction?: string;
 };
 export declare class VMDeobfuscator {
-    private llm?;
-    constructor(llm?: LLMService);
+    constructor(legacyDependency?: unknown);
     detectVMProtection(code: string): {
         detected: boolean;
         type: string;
         instructionCount: number;
     };
     countVMInstructions(code: string): number;
-    deobfuscateVM(code: string, vmInfo: {
+    deobfuscateVM(code: string, _vmInfo: {
         type: string;
         instructionCount: number;
     }): Promise<{
@@ -28,12 +26,6 @@ export declare class VMDeobfuscator {
     }>;
     analyzeVMStructure(code: string): VMStructure;
     extractVMComponents(code: string): VMComponents;
-    buildVMDeobfuscationPrompt(code: string, vmInfo: {
-        type: string;
-        instructionCount: number;
-    }, vmStructure: VMStructure, vmComponents: VMComponents): string;
     simplifyVMCode(code: string, vmComponents: VMComponents): string;
-    extractCodeFromLLMResponse(response: string): string;
-    isValidJavaScript(code: string): boolean;
 }
 export {};