@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/modules/analyzer/CodeAnalyzerDataFlow.js

@@ -1,10 +1,9 @@
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-import { generateTaintAnalysisPrompt } from '../../services/prompts/taint.js';
 import { logger } from '../../utils/logger.js';
 import { checkSanitizer } from '../analyzer/SecurityCodeAnalyzer.js';
-export async function analyzeDataFlowWithTaint(code, llm) {
+export async function analyzeDataFlowWithTaint(code) {
     const graph = { nodes: [], edges: [] };
     const sources = [];
     const sinks = [];
@@ -331,14 +330,6 @@ export async function analyzeDataFlowWithTaint(code, llm) {
     catch (error) {
         logger.warn('Data flow analysis failed', error);
     }
-    if (taintPaths.length > 0 && llm) {
-        try {
-            await enhanceTaintAnalysisWithLLM(llm, code, sources, sinks, taintPaths);
-        }
-        catch (error) {
-            logger.warn('LLM-enhanced taint analysis failed', error);
-        }
-    }
     return {
         graph,
         sources,
@@ -346,41 +337,6 @@ export async function analyzeDataFlowWithTaint(code, llm) {
         taintPaths,
     };
 }
-async function enhanceTaintAnalysisWithLLM(llm, code, sources, sinks, taintPaths) {
-    if (taintPaths.length === 0)
-        return;
-    try {
-        const sourcesList = sources.map((s) => `${s.type} at line ${s.location.line}`);
-        const sinksList = sinks.map((s) => `${s.type} at line ${s.location.line}`);
-        const messages = generateTaintAnalysisPrompt(code.length > 4000 ? code.substring(0, 4000) : code, sourcesList, sinksList);
-        const response = await llm.chat(messages, {
-            temperature: 0.2,
-            maxTokens: 2000,
-        });
-        const jsonMatch = response.content.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            const llmResult = JSON.parse(jsonMatch[0]);
-            if (Array.isArray(llmResult.taintPaths)) {
-                logger.info(`LLM identified ${llmResult.taintPaths.length} additional taint paths`);
-                llmResult.taintPaths.forEach((rawPath) => {
-                    const path = rawPath;
-                    const exists = taintPaths.some((p) => p.source.location.line === path.source?.location?.line &&
-                        p.sink.location.line === path.sink?.location?.line);
-                    if (!exists && path.source && path.sink) {
-                        taintPaths.push({
-                            source: path.source,
-                            sink: path.sink,
-                            path: path.path || [],
-                        });
-                    }
-                });
-            }
-        }
-    }
-    catch (error) {
-        logger.debug('LLM taint analysis enhancement failed', error);
-    }
-}
 function checkTaintedArguments(args, taintMap, taintPaths, _funcName, line) {
     args.forEach((arg) => {
         if (t.isIdentifier(arg) && taintMap.has(arg.name)) {

package/dist/src/modules/analyzer/IntelligentAnalyzer.d.ts

@@ -1,6 +1,5 @@
 import type { NetworkRequest, NetworkResponse } from '../monitor/ConsoleMonitor.js';
 import type { ConsoleMessage, ExceptionInfo } from '../monitor/ConsoleMonitor.js';
-import type { LLMService } from '../../services/LLMService.js';
 export interface AnalysisResult {
     criticalRequests: NetworkRequest[];
     criticalResponses: NetworkResponse[];
@@ -45,8 +44,7 @@ export interface AntiDebugPattern {
     code: string;
 }
 export declare class IntelligentAnalyzer {
-    private llmService?;
-    constructor(llmService?: LLMService);
+    constructor(legacyDependency?: unknown);
     analyze(data: {
         requests: NetworkRequest[];
         responses: NetworkResponse[];
@@ -55,40 +53,6 @@ export declare class IntelligentAnalyzer {
     }): AnalysisResult;
     aggregateSimilarRequests(requests: NetworkRequest[]): Map<string, NetworkRequest[]>;
     generateAIFriendlySummary(result: AnalysisResult): string;
-    analyzeCriticalRequestsWithLLM(requests: NetworkRequest[]): Promise<{
-        encryption: EncryptionPattern[];
-        signature: SignaturePattern[];
-        token: TokenPattern[];
-        customPatterns: Array<{
-            type: string;
-            description: string;
-            location: string;
-            confidence: number;
-        }>;
-    }>;
-    analyzeCriticalLogsWithLLM(logs: ConsoleMessage[]): Promise<{
-        keyFunctions: Array<{
-            name: string;
-            purpose: string;
-            confidence: number;
-        }>;
-        dataFlow: string;
-        suspiciousPatterns: Array<{
-            type: string;
-            description: string;
-            location: string;
-        }>;
-    }>;
-    expandKeywordsWithLLM(context: {
-        domain: string;
-        requests: NetworkRequest[];
-        logs: ConsoleMessage[];
-    }): Promise<{
-        apiKeywords: string[];
-        cryptoKeywords: string[];
-        frameworkKeywords: string[];
-        businessKeywords: string[];
-    }>;
     analyzeWithLLM(data: {
         requests: NetworkRequest[];
         responses: NetworkResponse[];

package/dist/src/modules/analyzer/IntelligentAnalyzer.js

@@ -1,16 +1,8 @@
 import { logger } from '../../utils/logger.js';
-import { generateRequestAnalysisMessages, generateLogAnalysisMessages, generateKeywordExpansionMessages, } from '../../services/prompts/intelligence.js';
 import { filterCriticalRequests, filterCriticalResponses, filterCriticalLogs, detectEncryptionPatterns, detectSignaturePatterns, detectTokenPatterns, detectAntiDebugPatterns, extractSuspiciousAPIs, extractKeyFunctions, } from '../analyzer/PatternDetector.js';
 export class IntelligentAnalyzer {
-    llmService;
-    constructor(llmService) {
-        this.llmService = llmService;
-        if (llmService) {
-            logger.info('IntelligentAnalyzer initialized with LLM support');
-        }
-        else {
-            logger.warn('IntelligentAnalyzer initialized without LLM (using rule-based analysis only)');
-        }
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
     analyze(data) {
         logger.info('Starting intelligent analysis...', {
@@ -89,7 +81,9 @@ export class IntelligentAnalyzer {
             result.patterns.encryption.slice(0, 5).forEach((pattern) => {
                 const evidence = Array.isArray(pattern.evidence)
                     ? pattern.evidence.join(', ')
-                    : String(pattern.evidence ?? '');
+                    : pattern.evidence
+                        ? String(pattern.evidence)
+                        : '';
                 lines.push(`  - ${pattern.type} (confidence: ${(pattern.confidence * 100).toFixed(0)}%)`);
                 lines.push(`    location: ${pattern.location}`);
                 lines.push(`    evidence: ${evidence}`);
@@ -101,7 +95,9 @@ export class IntelligentAnalyzer {
             result.patterns.signature.slice(0, 5).forEach((pattern) => {
                 const parameters = Array.isArray(pattern.parameters)
                     ? pattern.parameters.join(', ')
-                    : String(pattern.parameters ?? '');
+                    : pattern.parameters
+                        ? String(pattern.parameters)
+                        : '';
                 lines.push(`  - ${pattern.type}`);
                 lines.push(`    parameters: ${parameters}`);
             });
@@ -122,136 +118,7 @@ export class IntelligentAnalyzer {
         lines.push('=== Analysis Summary ===');
         return lines.join('\n');
     }
-    async analyzeCriticalRequestsWithLLM(requests) {
-        if (!this.llmService) {
-            logger.warn('LLM service not available, skipping LLM analysis');
-            return { encryption: [], signature: [], token: [], customPatterns: [] };
-        }
-        logger.info('Starting LLM-enhanced request analysis...');
-        const requestSummary = requests.slice(0, 20).map((req) => {
-            const urlObj = new URL(req.url, 'http://localhost');
-            const params = Object.fromEntries(urlObj.searchParams.entries());
-            return {
-                url: req.url,
-                method: req.method,
-                urlParams: params,
-                headers: req.headers,
-                postData: req.postData?.substring(0, 500),
-            };
-        });
-        try {
-            const response = await this.llmService.chat(generateRequestAnalysisMessages(requestSummary), {
-                temperature: 0.2,
-                maxTokens: 3000,
-            });
-            const result = JSON.parse(response.content);
-            logger.success('LLM request analysis completed', {
-                encryption: result.encryption?.length || 0,
-                signature: result.signature?.length || 0,
-                token: result.token?.length || 0,
-                custom: result.customPatterns?.length || 0,
-            });
-            return result;
-        }
-        catch (error) {
-            logger.error('LLM request analysis failed:', error);
-            return { encryption: [], signature: [], token: [], customPatterns: [] };
-        }
-    }
-    async analyzeCriticalLogsWithLLM(logs) {
-        if (!this.llmService) {
-            logger.warn('LLM service not available, skipping LLM log analysis');
-            return { keyFunctions: [], dataFlow: '', suspiciousPatterns: [] };
-        }
-        logger.info('Starting LLM-enhanced log analysis...');
-        const logSummary = logs.slice(0, 50).map((log, index) => ({
-            index,
-            type: log.type,
-            text: log.text.substring(0, 300),
-            url: log.url,
-            lineNumber: log.lineNumber,
-            stackTrace: log.stackTrace?.slice(0, 3),
-        }));
-        try {
-            const response = await this.llmService.chat(generateLogAnalysisMessages(logSummary), {
-                temperature: 0.2,
-                maxTokens: 2500,
-            });
-            const result = JSON.parse(response.content);
-            logger.success('LLM log analysis completed', {
-                keyFunctions: result.keyFunctions?.length || 0,
-                suspiciousPatterns: result.suspiciousPatterns?.length || 0,
-            });
-            return result;
-        }
-        catch (error) {
-            logger.error('LLM log analysis failed:', error);
-            return { keyFunctions: [], dataFlow: '', suspiciousPatterns: [] };
-        }
-    }
-    async expandKeywordsWithLLM(context) {
-        if (!this.llmService) {
-            return { apiKeywords: [], cryptoKeywords: [], frameworkKeywords: [], businessKeywords: [] };
-        }
-        logger.info('Expanding keywords with LLM...');
-        const urlPatterns = context.requests.slice(0, 15).map((r) => {
-            try {
-                const url = new URL(r.url);
-                return {
-                    path: url.pathname,
-                    params: Array.from(url.searchParams.keys()),
-                    method: r.method,
-                };
-            }
-            catch {
-                return { path: r.url, params: [], method: r.method };
-            }
-        });
-        const logKeywords = context.logs.slice(0, 20).map((l) => l.text.substring(0, 150));
-        try {
-            const response = await this.llmService.chat(generateKeywordExpansionMessages(context.domain, urlPatterns, logKeywords), { temperature: 0.4, maxTokens: 800 });
-            const result = JSON.parse(response.content);
-            logger.success('Keywords expanded', {
-                api: result.apiKeywords?.length || 0,
-                crypto: result.cryptoKeywords?.length || 0,
-                framework: result.frameworkKeywords?.length || 0,
-            });
-            return result;
-        }
-        catch (error) {
-            logger.error('Keyword expansion failed:', error);
-            return { apiKeywords: [], cryptoKeywords: [], frameworkKeywords: [], businessKeywords: [] };
-        }
-    }
     async analyzeWithLLM(data) {
-        logger.info('Starting hybrid analysis (rules + LLM)...');
-        const ruleBasedResult = this.analyze(data);
-        if (this.llmService) {
-            try {
-                const llmRequestAnalysis = await this.analyzeCriticalRequestsWithLLM(ruleBasedResult.criticalRequests);
-                const llmLogAnalysis = await this.analyzeCriticalLogsWithLLM(ruleBasedResult.criticalLogs);
-                ruleBasedResult.patterns.encryption = [
-                    ...(ruleBasedResult.patterns.encryption || []),
-                    ...llmRequestAnalysis.encryption,
-                ];
-                ruleBasedResult.patterns.signature = [
-                    ...(ruleBasedResult.patterns.signature || []),
-                    ...llmRequestAnalysis.signature,
-                ];
-                ruleBasedResult.patterns.token = [
-                    ...(ruleBasedResult.patterns.token || []),
-                    ...llmRequestAnalysis.token,
-                ];
-                ruleBasedResult.summary.keyFunctions = [
-                    ...ruleBasedResult.summary.keyFunctions,
-                    ...llmLogAnalysis.keyFunctions.map((f) => f.name),
-                ];
-                logger.success('Hybrid analysis completed with LLM enhancement');
-            }
-            catch (error) {
-                logger.error('LLM enhancement failed, using rule-based results only:', error);
-            }
-        }
-        return ruleBasedResult;
+        return this.analyze(data);
     }
 }

package/dist/src/modules/analyzer/PatternDetector.js

@@ -76,7 +76,7 @@ export function filterCriticalRequests(requests) {
             return true;
         return false;
     })
-        .sort((a, b) => {
+        .toSorted((a, b) => {
         const scoreA = calculateRequestPriority(a);
         const scoreB = calculateRequestPriority(b);
         return scoreB - scoreA;
@@ -97,7 +97,7 @@ export function filterCriticalResponses(responses) {
             return true;
         return false;
     })
-        .sort((a, b) => b.timestamp - a.timestamp);
+        .toSorted((a, b) => b.timestamp - a.timestamp);
 }
 export function calculateLogPriority(log) {
     let score = 0;
@@ -124,7 +124,7 @@ export function filterCriticalLogs(logs) {
             return true;
         return false;
     })
-        .sort((a, b) => {
+        .toSorted((a, b) => {
         const scoreA = calculateLogPriority(a);
         const scoreB = calculateLogPriority(b);
         return scoreB - scoreA;

package/dist/src/modules/analyzer/PatternDetectorAuthPatterns.js

@@ -155,7 +155,7 @@ export function detectTokenPatternsInternal(requests) {
                             confidence: 0.9,
                         });
                     }
-                    else if (headerValue.length > 20 && /^[A-Za-z0-9_\-+=\/]+$/.test(headerValue)) {
+                    else if (headerValue.length > 20 && /^[A-Za-z0-9_\-+=/]+$/.test(headerValue)) {
                         patterns.push({
                             type: 'Custom',
                             location: `${req.url} (header: ${headerName})`,

package/dist/src/modules/browser/BrowserDiscovery.js

@@ -233,7 +233,7 @@ export class BrowserDiscovery {
             }
             return null;
         }
-        catch (_error) {
+        catch {
             return null;
         }
     }
@@ -259,7 +259,7 @@ export class BrowserDiscovery {
             }
             return false;
         }
-        catch (_error) {
+        catch {
             return false;
         }
     }

package/dist/src/modules/browser/BrowserModeManager.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'fs';
-import puppeteer, {} from 'rebrowser-puppeteer-core';
+import { launch } from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
 import { findBrowserExecutable } from '../../utils/browserExecutable.js';
 import { CaptchaDetector } from '../captcha/CaptchaDetector.js';
@@ -69,7 +69,7 @@ export class BrowserModeManager {
         if (executablePath) {
             options.executablePath = executablePath;
         }
-        const browser = await puppeteer.launch(options);
+        const browser = await launch(options);
         const pid = browser.process()?.pid ?? null;
         if (this.isClosing) {
             await browser.close().catch((error) => {
@@ -278,15 +278,16 @@ export class BrowserModeManager {
             }
             if (this.sessionData.localStorage || this.sessionData.sessionStorage) {
                 await page.evaluate((data) => {
-                    const restoreStorage = (storage, items) => {
-                        if (items) {
-                            for (const [key, value] of Object.entries(items)) {
-                                storage.setItem(key, value);
-                            }
+                    if (data.local) {
+                        for (const [key, value] of Object.entries(data.local)) {
+                            localStorage.setItem(key, value);
                         }
-                    };
-                    restoreStorage(localStorage, data.local);
-                    restoreStorage(sessionStorage, data.session);
+                    }
+                    if (data.session) {
+                        for (const [key, value] of Object.entries(data.session)) {
+                            sessionStorage.setItem(key, value);
+                        }
+                    }
                 }, {
                     local: this.sessionData.localStorage,
                     session: this.sessionData.sessionStorage,

package/dist/src/modules/browser/BrowserPool.d.ts

@@ -0,0 +1,49 @@
+import type { Page as PuppeteerPage } from 'rebrowser-puppeteer-core';
+import { UnifiedBrowserManager, type UnifiedBrowserConfig } from './UnifiedBrowserManager.js';
+export interface BrowserProfile {
+    name: string;
+    config?: UnifiedBrowserConfig;
+    idleTimeout?: number;
+    maxTabs?: number;
+}
+export interface BrowserPoolStats {
+    totalEntries: number;
+    inUseCount: number;
+    idleCount: number;
+    totalPages: number;
+    entries: Array<{
+        profile: string;
+        inUse: boolean;
+        pageCount: number;
+        lastAccess: Date;
+        disposed: boolean;
+    }>;
+}
+export declare class BrowserPool {
+    private entries;
+    private defaultIdleTimeout;
+    private defaultMaxTabs;
+    private isDisposed;
+    private cleanupInterval?;
+    constructor(options?: {
+        defaultIdleTimeout?: number;
+        defaultMaxTabs?: number;
+        cleanupInterval?: number;
+    });
+    acquire(profile: BrowserProfile): Promise<UnifiedBrowserManager>;
+    release(instance: UnifiedBrowserManager): Promise<void>;
+    createTab(instance: UnifiedBrowserManager): Promise<PuppeteerPage>;
+    closeTab(instance: UnifiedBrowserManager, page: PuppeteerPage): Promise<void>;
+    getTabs(instance: UnifiedBrowserManager): PuppeteerPage[];
+    switchTab(instance: UnifiedBrowserManager, index: number): PuppeteerPage;
+    getStats(): BrowserPoolStats;
+    dispose(): Promise<void>;
+    disposeProfile(profileName: string): Promise<boolean>;
+    private findEntryByInstance;
+    private startIdleTimer;
+    private clearIdleTimer;
+    private disposeEntry;
+    private cleanupIdle;
+    private getMaxTabsForEntry;
+    private getMaxIdleTimeoutForEntry;
+}