@jshookmcp/jshook 0.2.5 → 0.2.6

package/README.md

@@ -1,7 +1,7 @@
 # @jshookmcp/jshook
 
 [![License: AGPLv3](https://img.shields.io/badge/License-AGPLv3-red.svg)](LICENSE)
-[![Node.js >= 20](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org/)
+[![Node.js 20.19+ or 22.12+](https://img.shields.io/badge/node-20.19%2B%20%7C%2022.12%2B-brightgreen.svg)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6.svg)](https://www.typescriptlang.org/)
 [![MCP](https://img.shields.io/badge/MCP-current-8A2BE2.svg)](https://modelcontextprotocol.io/)
 [![pnpm](https://img.shields.io/badge/pnpm-10.x-F69220.svg)](https://pnpm.io/)
@@ -50,10 +50,10 @@ Provides a comprehensive suite of tools for AI-assisted JavaScript analysis, bro
 The built-in surface below is generated from the runtime registry and checked in CI.
 
 <!-- metadata-sync:start -->
-- Package version: `0.2.5`
-- Built-in domains: `23`
-- Built-in tools: `327`
-- Domains: `antidebug`, `browser`, `coordination`, `core`, `debugger`, `encoding`, `evidence`, `graphql`, `hooks`, `instrumentation`, `macro`, `maintenance`, `memory`, `network`, `platform`, `process`, `sandbox`, `sourcemap`, `streaming`, `trace`, `transform`, `wasm`, `workflow`
+- Package version: `0.2.6`
+- Built-in domains: `24`
+- Built-in tools: `337`
+- Domains: `antidebug`, `browser`, `coordination`, `core`, `debugger`, `encoding`, `evidence`, `graphql`, `hooks`, `instrumentation`, `macro`, `maintenance`, `memory`, `network`, `platform`, `process`, `sandbox`, `shared-state-board`, `sourcemap`, `streaming`, `trace`, `transform`, `wasm`, `workflow`
 - Note: this snapshot is generated from the runtime registry; do not edit the counts by hand.
 <!-- metadata-sync:end -->
 

package/README.zh.md

@@ -1,7 +1,7 @@
 # @jshookmcp/jshook
 
 [![License: AGPLv3](https://img.shields.io/badge/License-AGPLv3-red.svg)](LICENSE)
-[![Node.js >= 20](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org/)
+[![Node.js 20.19+ or 22.12+](https://img.shields.io/badge/node-20.19%2B%20%7C%2022.12%2B-brightgreen.svg)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6.svg)](https://www.typescriptlang.org/)
 [![MCP](https://img.shields.io/badge/MCP-current-8A2BE2.svg)](https://modelcontextprotocol.io/)
 [![pnpm](https://img.shields.io/badge/pnpm-10.x-F69220.svg)](https://pnpm.io/)
@@ -50,10 +50,10 @@
 下面的内置能力快照由运行时 registry 动态生成，并在 CI 中校验。
 
 <!-- metadata-sync:start -->
-- 包版本：`0.2.5`
-- 内置工具域：`23`
-- 内置工具数：`327`
-- 域列表：`antidebug`, `browser`, `coordination`, `core`, `debugger`, `encoding`, `evidence`, `graphql`, `hooks`, `instrumentation`, `macro`, `maintenance`, `memory`, `network`, `platform`, `process`, `sandbox`, `sourcemap`, `streaming`, `trace`, `transform`, `wasm`, `workflow`
+- 包版本：`0.2.6`
+- 内置工具域：`24`
+- 内置工具数：`337`
+- 域列表：`antidebug`, `browser`, `coordination`, `core`, `debugger`, `encoding`, `evidence`, `graphql`, `hooks`, `instrumentation`, `macro`, `maintenance`, `memory`, `network`, `platform`, `process`, `sandbox`, `shared-state-board`, `sourcemap`, `streaming`, `trace`, `transform`, `wasm`, `workflow`
 - 说明：以上数据由运行时 registry 动态生成，不要手改计数。
 <!-- metadata-sync:end -->
 

package/dist/packages/extension-sdk/src/workflow.d.ts

@@ -3,7 +3,7 @@ export interface RetryPolicy {
     backoffMs: number;
     multiplier?: number;
 }
-export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch';
+export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch' | 'fallback';
 export interface ToolNode {
     readonly kind: 'tool';
     readonly id: string;
@@ -32,7 +32,13 @@ export interface BranchNode {
     readonly whenTrue: WorkflowNode;
     readonly whenFalse?: WorkflowNode;
 }
-export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
+export interface FallbackNode {
+    readonly kind: 'fallback';
+    readonly id: string;
+    readonly primary: WorkflowNode;
+    readonly fallback: WorkflowNode;
+}
+export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode | FallbackNode;
 export interface ToolNodeOptions {
     input?: Record<string, unknown>;
     retry?: RetryPolicy;
@@ -102,6 +108,7 @@ declare abstract class CompositeNodeBuilder<T extends WorkflowNode> extends Work
     sequence(id: string, config?: (b: SequenceNodeBuilder) => void): this;
     parallel(id: string, config?: (b: ParallelNodeBuilder) => void): this;
     branch(id: string, predicateId: string, config?: (b: BranchNodeBuilder) => void): this;
+    fallback(id: string, config?: (b: FallbackNodeBuilder) => void): this;
 }
 export declare class SequenceNodeBuilder extends CompositeNodeBuilder<SequenceNode> {
     build(): SequenceNode;
@@ -124,6 +131,13 @@ export declare class BranchNodeBuilder extends WorkflowNodeBuilder<BranchNode> {
     whenFalse(nodeBuilder: AnyWorkflowNodeBuilder): this;
     build(): BranchNode;
 }
+export declare class FallbackNodeBuilder extends WorkflowNodeBuilder<FallbackNode> {
+    private _primary?;
+    private _fallback?;
+    primary(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    fallback(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    build(): FallbackNode;
+}
 export declare class WorkflowBuilder {
     private _id;
     private _displayName;
@@ -153,4 +167,5 @@ export declare function toolNode(id: string, toolName: string): ToolNodeBuilder;
 export declare function sequenceNode(id: string): SequenceNodeBuilder;
 export declare function parallelNode(id: string): ParallelNodeBuilder;
 export declare function branchNode(id: string, predicateId: string): BranchNodeBuilder;
+export declare function fallbackNode(id: string): FallbackNodeBuilder;
 export {};

package/dist/packages/extension-sdk/src/workflow.js

@@ -81,6 +81,13 @@ class CompositeNodeBuilder extends WorkflowNodeBuilder {
         this._steps.push(builder);
         return this;
     }
+    fallback(id, config) {
+        const builder = new FallbackNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
 }
 export class SequenceNodeBuilder extends CompositeNodeBuilder {
     build() {
@@ -147,6 +154,32 @@ export class BranchNodeBuilder extends WorkflowNodeBuilder {
         };
     }
 }
+export class FallbackNodeBuilder extends WorkflowNodeBuilder {
+    _primary;
+    _fallback;
+    primary(nodeBuilder) {
+        this._primary = nodeBuilder;
+        return this;
+    }
+    fallback(nodeBuilder) {
+        this._fallback = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._primary) {
+            throw new Error(`FallbackNode '${this.id}' requires a primary step`);
+        }
+        if (!this._fallback) {
+            throw new Error(`FallbackNode '${this.id}' requires a fallback step`);
+        }
+        return {
+            kind: 'fallback',
+            id: this.id,
+            primary: this._primary.build(),
+            fallback: this._fallback.build(),
+        };
+    }
+}
 export class WorkflowBuilder {
     _id;
     _displayName;
@@ -234,3 +267,6 @@ export function parallelNode(id) {
 export function branchNode(id, predicateId) {
     return new BranchNodeBuilder(id, predicateId);
 }
+export function fallbackNode(id) {
+    return new FallbackNodeBuilder(id);
+}

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;
+}

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

@@ -0,0 +1,288 @@
+import { logger } from '../../utils/logger.js';
+import { UnifiedBrowserManager } from './UnifiedBrowserManager.js';
+const DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_MAX_TABS = 10;
+export class BrowserPool {
+    entries = new Map();
+    defaultIdleTimeout;
+    defaultMaxTabs;
+    isDisposed = false;
+    cleanupInterval;
+    constructor(options) {
+        this.defaultIdleTimeout = options?.defaultIdleTimeout ?? DEFAULT_IDLE_TIMEOUT_MS;
+        this.defaultMaxTabs = options?.defaultMaxTabs ?? DEFAULT_MAX_TABS;
+        const interval = options?.cleanupInterval ?? 60 * 1000;
+        this.cleanupInterval = setInterval(() => this.cleanupIdle(), interval);
+    }
+    async acquire(profile) {
+        if (this.isDisposed) {
+            throw new Error('BrowserPool has been disposed');
+        }
+        const existing = this.entries.get(profile.name);
+        if (existing && !existing.disposed) {
+            logger.debug(`[BrowserPool] Reusing browser for profile "${profile.name}"`);
+            existing.inUse = true;
+            existing.lastAccess = Date.now();
+            this.clearIdleTimer(existing);
+            return existing.manager;
+        }
+        if (existing) {
+            this.entries.delete(profile.name);
+        }
+        logger.info(`[BrowserPool] Creating new browser for profile "${profile.name}"`);
+        const config = {
+            driver: profile.config?.driver ?? 'chrome',
+            headless: profile.config?.headless,
+            args: profile.config?.args,
+            executablePath: profile.config?.executablePath,
+            debugPort: profile.config?.debugPort,
+            proxy: profile.config?.proxy,
+            os: profile.config?.os,
+            geoip: profile.config?.geoip,
+        };
+        const manager = new UnifiedBrowserManager(config);
+        await manager.launch();
+        const browser = manager.getBrowser();
+        const entry = {
+            profile: profile.name,
+            manager,
+            browser,
+            pages: [],
+            lastAccess: Date.now(),
+            inUse: true,
+            disposed: false,
+            profileConfig: profile,
+        };
+        this.entries.set(profile.name, entry);
+        logger.debug(`[BrowserPool] Browser acquired for profile "${profile.name}"`);
+        return manager;
+    }
+    async release(instance) {
+        if (this.isDisposed) {
+            logger.warn('[BrowserPool] Cannot release: pool is disposed');
+            return;
+        }
+        const entry = this.findEntryByInstance(instance);
+        if (!entry) {
+            logger.warn('[BrowserPool] Instance not found in pool, skipping release');
+            return;
+        }
+        if (!entry.inUse) {
+            logger.warn(`[BrowserPool] Profile "${entry.profile}" was not in use`);
+            return;
+        }
+        entry.inUse = false;
+        entry.lastAccess = Date.now();
+        this.startIdleTimer(entry);
+        logger.debug(`[BrowserPool] Released browser for profile "${entry.profile}"`);
+    }
+    async createTab(instance) {
+        const entry = this.findEntryByInstance(instance);
+        if (!entry) {
+            throw new Error('Browser instance not found in pool');
+        }
+        if (entry.disposed) {
+            throw new Error(`Browser for profile "${entry.profile}" has been disposed`);
+        }
+        if (entry.browser === null) {
+            throw new Error(`Browser for profile "${entry.profile}" has no browser instance`);
+        }
+        const maxTabs = this.getMaxTabsForEntry(entry);
+        if (entry.pages.length >= maxTabs) {
+            throw new Error(`Maximum tabs (${maxTabs}) reached for profile "${entry.profile}". Close some tabs first.`);
+        }
+        const page = await entry.browser.newPage();
+        entry.pages.push(page);
+        entry.lastAccess = Date.now();
+        logger.debug(`[BrowserPool] Created new tab in profile "${entry.profile}" (total: ${entry.pages.length})`);
+        page.on('close', () => {
+            const index = entry.pages.indexOf(page);
+            if (index !== -1) {
+                entry.pages.splice(index, 1);
+                logger.debug(`[BrowserPool] Tab closed in profile "${entry.profile}" (remaining: ${entry.pages.length})`);
+            }
+        });
+        return page;
+    }
+    async closeTab(instance, page) {
+        const entry = this.findEntryByInstance(instance);
+        if (!entry) {
+            throw new Error('Browser instance not found in pool');
+        }
+        if (entry.browser === null) {
+            throw new Error(`Browser for profile "${entry.profile}" has no browser instance`);
+        }
+        const index = entry.pages.indexOf(page);
+        if (index === -1) {
+            throw new Error('Page not found in this browser instance');
+        }
+        await page.close();
+        entry.lastAccess = Date.now();
+        logger.debug(`[BrowserPool] Closed tab in profile "${entry.profile}"`);
+    }
+    getTabs(instance) {
+        const entry = this.findEntryByInstance(instance);
+        if (!entry) {
+            throw new Error('Browser instance not found in pool');
+        }
+        return [...entry.pages];
+    }
+    switchTab(instance, index) {
+        const tabs = this.getTabs(instance);
+        if (index < 0 || index >= tabs.length) {
+            throw new Error(`Invalid tab index ${index}. Available tabs: 0-${tabs.length - 1} (total: ${tabs.length})`);
+        }
+        return tabs[index];
+    }
+    getStats() {
+        const entries = [];
+        let inUseCount = 0;
+        let idleCount = 0;
+        let totalPages = 0;
+        for (const [, entry] of this.entries) {
+            if (entry.inUse) {
+                inUseCount++;
+            }
+            else {
+                idleCount++;
+            }
+            totalPages += entry.pages.length;
+            entries.push({
+                profile: entry.profile,
+                inUse: entry.inUse,
+                pageCount: entry.pages.length,
+                lastAccess: new Date(entry.lastAccess),
+                disposed: entry.disposed,
+            });
+        }
+        return {
+            totalEntries: this.entries.size,
+            inUseCount,
+            idleCount,
+            totalPages,
+            entries,
+        };
+    }
+    async dispose() {
+        logger.info('[BrowserPool] Disposing pool...');
+        this.isDisposed = true;
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        const closePromises = [];
+        for (const [, entry] of this.entries) {
+            closePromises.push(this.disposeEntry(entry));
+        }
+        await Promise.all(closePromises);
+        this.entries.clear();
+        logger.info('[BrowserPool] Pool disposed successfully');
+    }
+    async disposeProfile(profileName) {
+        const entry = this.entries.get(profileName);
+        if (!entry) {
+            return false;
+        }
+        await this.disposeEntry(entry);
+        this.entries.delete(profileName);
+        return true;
+    }
+    findEntryByInstance(instance) {
+        for (const [, entry] of this.entries) {
+            if (entry.manager === instance) {
+                return entry;
+            }
+        }
+        return null;
+    }
+    startIdleTimer(entry) {
+        this.clearIdleTimer(entry);
+        const timeout = this.getMaxIdleTimeoutForEntry(entry);
+        entry.idleTimer = setTimeout(() => {
+            if (!entry.inUse && !entry.disposed) {
+                logger.info(`[BrowserPool] Auto-disposing idle browser for profile "${entry.profile}" (idle > ${timeout}ms)`);
+                this.disposeEntry(entry).catch((error) => {
+                    logger.error(`[BrowserPool] Failed to dispose idle entry: ${String(error)}`);
+                });
+                this.entries.delete(entry.profile);
+            }
+        }, timeout);
+    }
+    clearIdleTimer(entry) {
+        if (entry.idleTimer) {
+            clearTimeout(entry.idleTimer);
+            entry.idleTimer = undefined;
+        }
+    }
+    async disposeEntry(entry) {
+        if (entry.disposed) {
+            return;
+        }
+        entry.disposed = true;
+        this.clearIdleTimer(entry);
+        try {
+            const closePages = entry.pages.map(async (page) => {
+                try {
+                    if (!page.isClosed()) {
+                        await page.close();
+                    }
+                }
+                catch (error) {
+                    logger.warn(`[BrowserPool] Failed to close page: ${String(error)}`);
+                }
+            });
+            await Promise.all(closePages);
+            entry.pages = [];
+            await entry.manager.close();
+        }
+        catch (error) {
+            logger.error(`[BrowserPool] Failed to dispose entry "${entry.profile}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    cleanupIdle() {
+        if (this.isDisposed) {
+            return;
+        }
+        const now = Date.now();
+        const toDispose = [];
+        for (const [profile, entry] of this.entries) {
+            if (!entry.inUse && !entry.disposed) {
+                const timeout = this.getMaxIdleTimeoutForEntry(entry);
+                if (now - entry.lastAccess > timeout) {
+                    toDispose.push(profile);
+                }
+            }
+        }
+        for (const profile of toDispose) {
+            const entry = this.entries.get(profile);
+            if (entry) {
+                logger.debug(`[BrowserPool] Cleanup: disposing idle profile "${profile}" (last accessed ${new Date(entry.lastAccess).toISOString()})`);
+                this.disposeEntry(entry).catch((error) => {
+                    logger.error(`[BrowserPool] Cleanup failed for "${profile}": ${String(error)}`);
+                });
+                this.entries.delete(profile);
+            }
+        }
+        if (toDispose.length > 0) {
+            logger.info(`[BrowserPool] Cleanup: disposed ${toDispose.length} idle profiles`);
+        }
+    }
+    getMaxTabsForEntry(entry) {
+        const managerWithTabLimit = entry.manager;
+        const managerLimit = typeof managerWithTabLimit.getMaxTabs === 'function'
+            ? managerWithTabLimit.getMaxTabs()
+            : undefined;
+        return typeof managerLimit === 'number'
+            ? managerLimit
+            : (entry.profileConfig.maxTabs ?? this.defaultMaxTabs);
+    }
+    getMaxIdleTimeoutForEntry(entry) {
+        const managerWithIdleTimeout = entry.manager;
+        const managerTimeout = typeof managerWithIdleTimeout.getIdleTimeout === 'function'
+            ? managerWithIdleTimeout.getIdleTimeout()
+            : undefined;
+        return typeof managerTimeout === 'number'
+            ? managerTimeout
+            : (entry.profileConfig.idleTimeout ?? this.defaultIdleTimeout);
+    }
+}

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

@@ -20,6 +20,7 @@ export interface AdvancedDeobfuscateResult {
     detectedTechniques: string[];
     confidence: number;
     warnings: string[];
+    cached?: boolean;
     astOptimized?: boolean;
     bundle?: DeobfuscateBundleSummary;
     savedTo?: string;
@@ -33,6 +34,10 @@ export interface AdvancedDeobfuscateResult {
     };
 }
 export declare class AdvancedDeobfuscator {
+    private resultCache;
+    private maxCacheSize;
+    private generateCacheKey;
     deobfuscate(options: AdvancedDeobfuscateOptions): Promise<AdvancedDeobfuscateResult>;
+    private storeCacheEntry;
     private calculateConfidence;
 }

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

@@ -1,8 +1,36 @@
 import { logger } from '../../utils/logger.js';
 import { runWebcrack } from '../deobfuscator/webcrack.js';
 import { detectObfuscationType as detectObfuscationTypeUtil } from '../deobfuscator/Deobfuscator.utils.js';
+import crypto from 'crypto';
 export class AdvancedDeobfuscator {
+    resultCache = new Map();
+    maxCacheSize = 100;
+    generateCacheKey(options) {
+        const key = JSON.stringify({
+            aggressiveVM: options.aggressiveVM,
+            code: options.code.substring(0, 2000),
+            detectOnly: options.detectOnly,
+            forceOutput: options.forceOutput,
+            includeModuleCode: options.includeModuleCode,
+            jsx: options.jsx,
+            mangle: options.mangle,
+            mappings: options.mappings,
+            maxBundleModules: options.maxBundleModules,
+            outputDir: options.outputDir,
+            timeout: options.timeout,
+            unpack: options.unpack,
+            unminify: options.unminify,
+            useASTOptimization: options.useASTOptimization,
+        });
+        return crypto.createHash('md5').update(key).digest('hex');
+    }
     async deobfuscate(options) {
+        const cacheKey = this.generateCacheKey(options);
+        const cached = this.resultCache.get(cacheKey);
+        if (cached) {
+            logger.debug('Advanced deobfuscation result from cache');
+            return { ...cached, cached: true };
+        }
         logger.info('Starting advanced webcrack deobfuscation...');
         const detectedTechniques = detectObfuscationTypeUtil(options.code);
         const warnings = [];
@@ -16,7 +44,7 @@ export class AdvancedDeobfuscator {
             warnings.push('timeout is currently ignored; webcrack controls its own execution flow.');
         }
         if (options.detectOnly) {
-            return {
+            const result = {
                 code: options.code,
                 detectedTechniques,
                 confidence: Math.min(0.6 + detectedTechniques.length * 0.05, 0.9),
@@ -28,6 +56,8 @@ export class AdvancedDeobfuscator {
                 engine: 'webcrack',
                 webcrackApplied: false,
             };
+            this.storeCacheEntry(cacheKey, result);
+            return { ...result, cached: false };
         }
         const webcrackResult = await runWebcrack(options.code, {
             unpack: options.unpack,
@@ -58,7 +88,7 @@ export class AdvancedDeobfuscator {
             detectedTechniques.push('mangle');
         }
         detectedTechniques.push('webcrack');
-        return {
+        const result = {
             code: webcrackResult.code,
             detectedTechniques: Array.from(new Set(detectedTechniques)),
             confidence: this.calculateConfidence(webcrackResult, detectedTechniques),
@@ -70,6 +100,17 @@ export class AdvancedDeobfuscator {
             engine: 'webcrack',
             webcrackApplied: true,
         };
+        this.storeCacheEntry(cacheKey, result);
+        return { ...result, cached: false };
+    }
+    storeCacheEntry(cacheKey, result) {
+        if (this.resultCache.size >= this.maxCacheSize) {
+            const firstKey = this.resultCache.keys().next().value;
+            if (firstKey) {
+                this.resultCache.delete(firstKey);
+            }
+        }
+        this.resultCache.set(cacheKey, result);
     }
     calculateConfidence(webcrackResult, detectedTechniques) {
         let confidence = 0.72 + detectedTechniques.length * 0.03;

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

@@ -10,15 +10,18 @@ export class Deobfuscator {
     }
     generateCacheKey(options) {
         const key = JSON.stringify({
+            aggressive: options.aggressive,
             code: options.code.substring(0, 2000),
             forceOutput: options.forceOutput,
             includeModuleCode: options.includeModuleCode,
+            inlineFunctions: options.inlineFunctions,
             jsx: options.jsx,
             llm: false,
             mangle: options.mangle ?? options.renameVariables,
             mappings: options.mappings,
             maxBundleModules: options.maxBundleModules,
             outputDir: options.outputDir,
+            preserveLogic: options.preserveLogic,
             unpack: options.unpack,
             unminify: options.unminify,
         });
@@ -29,6 +32,7 @@ export class Deobfuscator {
         const cached = this.resultCache.get(cacheKey);
         if (cached) {
             logger.debug('Deobfuscation result from cache');
+            cached.cached = true;
             return cached;
         }
         logger.info('Starting webcrack deobfuscation...');
@@ -110,6 +114,7 @@ export class Deobfuscator {
                 this.resultCache.delete(firstKey);
             }
         }
+        result.cached = false;
         this.resultCache.set(cacheKey, result);
         return result;
     }

package/dist/src/modules/external/ExternalToolRunner.js

@@ -158,7 +158,7 @@ export class ExternalToolRunner {
         const resolved = resolve(requestedCwd);
         const projectRoot = getProjectRoot();
         const rel = relative(projectRoot, resolved);
-        if (rel && !rel.startsWith('..') && !isAbsolute(rel) && !resolve(rel).startsWith(sep)) {
+        if (rel && !rel.startsWith('..') && !isAbsolute(rel)) {
             return resolved;
         }
         const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);

package/dist/src/server/MCPServer.context.d.ts

@@ -91,6 +91,7 @@ export interface DomainInstances {
     traceHandlers?: import('./domains/trace/index.js').TraceToolHandlers;
     evidenceHandlers?: import('./domains/evidence/index.js').EvidenceHandlers;
     instrumentationHandlers?: import('./domains/instrumentation/index.js').InstrumentationHandlers | undefined;
+    sharedStateBoardHandlers?: import('./domains/shared-state-board/index.js').SharedStateBoardHandlers;
 }
 export interface ServerMethods {
     registerCaches(): Promise<void>;

package/dist/src/server/domains/browser/handlers/stealth-injection.d.ts

@@ -5,6 +5,7 @@ interface StealthInjectionHandlersDeps {
     pageController: PageController;
     getActiveDriver: () => 'chrome' | 'camoufox';
 }
+export declare function _resetFingerprintCacheForTesting(): void;
 export declare class StealthInjectionHandlers {
     private deps;
     constructor(deps: StealthInjectionHandlersDeps);

package/dist/src/server/domains/browser/handlers/stealth-injection.js

@@ -17,6 +17,9 @@ async function getFingerprintManager() {
         return null;
     }
 }
+export function _resetFingerprintCacheForTesting() {
+    fingerprintManagerInstance = null;
+}
 export class StealthInjectionHandlers {
     deps;
     constructor(deps) {

package/dist/src/server/domains/shared-state-board/definitions.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const sharedStateBoardTools: Tool[];