@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/activation/ActivationController.js

@@ -1,191 +0,0 @@
-import { handleActivateDomain } from '../MCPServer.search.handlers.domain.js';
-import { CompoundConditionEngine } from './CompoundConditionEngine.js';
-import { PredictiveBooster } from './PredictiveBooster.js';
-import { AutoPruner } from './AutoPruner.js';
-import { getToolDomain, getProfileDomains } from '../ToolCatalog.js';
-import { logger } from '../../utils/logger.js';
-const DEFAULT_BOOST_RULES = [
-    {
-        eventPattern: 'debugger:breakpoint_hit',
-        targetDomains: ['debugger'],
-        threshold: 1,
-        windowMs: 60_000,
-        priority: 10,
-    },
-    {
-        eventPattern: 'browser:navigated',
-        targetDomains: ['browser'],
-        threshold: 1,
-        windowMs: 60_000,
-        priority: 10,
-    },
-    {
-        eventPattern: 'memory:scan_completed',
-        targetDomains: ['memory'],
-        threshold: 1,
-        windowMs: 60_000,
-        priority: 10,
-    },
-];
-const WIN32_ONLY_TOOL_PREFIXES = [
-    'pe_',
-    'anticheat_',
-    'speedhack_',
-    'hw_breakpoint_',
-    'inject_',
-];
-export function getPlatformFilteredTools(tools) {
-    const platform = process.platform;
-    if (platform === 'win32') {
-        return tools;
-    }
-    return tools.filter((tool) => {
-        return !WIN32_ONLY_TOOL_PREFIXES.some((prefix) => tool.name.startsWith(prefix));
-    });
-}
-export class ActivationController {
-    eventBus;
-    ctx;
-    cooldownMs;
-    boostRules;
-    unsubscribers = [];
-    lastBoostTime = new Map();
-    lastActivity = new Map();
-    eventHistory = [];
-    maxEventHistory = 200;
-    toolCallCount = 0;
-    compoundEngine;
-    predictiveBooster;
-    autoPruner;
-    disposed = false;
-    constructor(eventBus, ctx, options = {}) {
-        this.eventBus = eventBus;
-        this.ctx = ctx;
-        this.cooldownMs = options.cooldownMs ?? 30_000;
-        const customRules = options.boostRules ?? [];
-        this.boostRules = [...DEFAULT_BOOST_RULES, ...customRules].toSorted((a, b) => b.priority - a.priority);
-        this.compoundEngine = new CompoundConditionEngine();
-        this.predictiveBooster = new PredictiveBooster();
-        const baseDomains = new Set(getProfileDomains(ctx.baseTier));
-        this.autoPruner = new AutoPruner(eventBus, baseDomains, (domain) => {
-            logger.info(`[ActivationController] Auto-pruning domain "${domain}"`);
-        });
-        this.subscribe();
-        logger.info(`[ActivationController] Initialized with ${this.boostRules.length} boost rules, ` +
-            `cooldown=${this.cooldownMs}ms, platform=${process.platform}, ` +
-            `${this.compoundEngine.conditionCount} compound conditions`);
-    }
-    subscribe() {
-        this.unsubscribers.push(this.eventBus.on('tool:called', (payload) => {
-            this.recordEvent('tool:called', payload);
-            if (payload.domain) {
-                this.lastActivity.set(payload.domain, Date.now());
-                this.autoPruner.recordActivity(payload.domain);
-            }
-            this.predictiveBooster.recordCall(payload.toolName);
-            const predictedDomains = this.predictiveBooster.predictNextDomains(payload.toolName, (name) => getToolDomain(name) ?? null);
-            for (const domain of predictedDomains) {
-                void this.attemptBoost(domain, `predictive: ${payload.toolName} → ${domain}`);
-            }
-            this.toolCallCount++;
-            if (this.toolCallCount % 5 === 0) {
-                this.evaluateCompoundConditions();
-            }
-        }));
-        this.unsubscribers.push(this.eventBus.on('debugger:breakpoint_hit', (payload) => {
-            this.recordEvent('debugger:breakpoint_hit', payload);
-            return this.evaluateBoostRules('debugger:breakpoint_hit');
-        }));
-        this.unsubscribers.push(this.eventBus.on('browser:navigated', (payload) => {
-            this.recordEvent('browser:navigated', payload);
-            return this.evaluateBoostRules('browser:navigated');
-        }));
-        this.unsubscribers.push(this.eventBus.on('memory:scan_completed', (payload) => {
-            this.recordEvent('memory:scan_completed', payload);
-            return this.evaluateBoostRules('memory:scan_completed');
-        }));
-    }
-    recordEvent(event, payload) {
-        this.eventHistory.push({ event, timestamp: Date.now(), payload });
-        if (this.eventHistory.length > this.maxEventHistory) {
-            this.eventHistory.splice(0, this.eventHistory.length - this.maxEventHistory);
-        }
-    }
-    async evaluateBoostRules(eventName) {
-        const now = Date.now();
-        for (const rule of this.boostRules) {
-            if (!eventName.startsWith(rule.eventPattern))
-                continue;
-            const windowStart = now - rule.windowMs;
-            const matchCount = this.eventHistory.filter((e) => e.event.startsWith(rule.eventPattern) && e.timestamp >= windowStart).length;
-            if (matchCount >= rule.threshold) {
-                await Promise.all(rule.targetDomains.map((domain) => this.attemptBoost(domain, `rule:${rule.eventPattern} (${matchCount} events)`)));
-            }
-        }
-    }
-    async attemptBoost(domain, reason) {
-        if (this.disposed)
-            return;
-        const now = Date.now();
-        const lastBoost = this.lastBoostTime.get(domain) ?? 0;
-        if (now - lastBoost < this.cooldownMs) {
-            return;
-        }
-        if (this.ctx.enabledDomains.has(domain)) {
-            return;
-        }
-        this.lastBoostTime.set(domain, now);
-        logger.info(`[ActivationController] Boosting domain "${domain}" — reason: ${reason}`);
-        await handleActivateDomain(this.ctx, {
-            domain,
-            ttlMinutes: 30,
-        });
-        await this.eventBus.emit('activation:domain_boosted', {
-            domain,
-            reason,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    evaluateCompoundConditions() {
-        const state = {
-            platform: process.platform,
-            activeDomains: this.ctx.enabledDomains,
-            eventHistory: this.eventHistory,
-            recentToolCalls: this.eventHistory
-                .filter((e) => e.event === 'tool:called')
-                .map((e) => e.payload?.toolName ?? ''),
-        };
-        const domainsToBoost = this.compoundEngine.evaluate(state);
-        for (const domain of domainsToBoost) {
-            void this.attemptBoost(domain, `compound condition`);
-        }
-    }
-    getLastActivity(domain) {
-        return this.lastActivity.get(domain);
-    }
-    getEventHistory() {
-        return this.eventHistory;
-    }
-    getLastBoostTime(domain) {
-        return this.lastBoostTime.get(domain);
-    }
-    getPredictiveBooster() {
-        return this.predictiveBooster;
-    }
-    getAutoPruner() {
-        return this.autoPruner;
-    }
-    dispose() {
-        this.disposed = true;
-        for (const unsub of this.unsubscribers) {
-            unsub();
-        }
-        this.unsubscribers.length = 0;
-        this.lastBoostTime.clear();
-        this.lastActivity.clear();
-        this.eventHistory.length = 0;
-        this.autoPruner.dispose();
-        this.predictiveBooster.reset();
-        logger.info('[ActivationController] Disposed');
-    }
-}

package/dist/src/server/activation/AutoPruner.d.ts

@@ -1,25 +0,0 @@
-import type { EventBus, ServerEventMap } from '../EventBus.js';
-export interface AutoPruneConfig {
-    autoActivatedInactivityMs?: number;
-    manualActivatedInactivityMs?: number;
-    checkIntervalMs?: number;
-}
-export declare class AutoPruner {
-    private readonly lastActivity;
-    private readonly baseDomains;
-    private readonly autoActivatedDomains;
-    private readonly autoInactivityMs;
-    private readonly manualInactivityMs;
-    private readonly checkIntervalMs;
-    private checkTimer;
-    private readonly eventBus;
-    private readonly onPrune;
-    constructor(eventBus: EventBus<ServerEventMap>, baseDomains: Set<string>, onPrune: (domain: string) => void, config?: AutoPruneConfig);
-    recordActivity(domain: string): void;
-    markAutoActivated(domain: string): void;
-    private startCheckTimer;
-    private checkAndPrune;
-    getLastActivity(domain: string): number | undefined;
-    isAutoActivated(domain: string): boolean;
-    dispose(): void;
-}

package/dist/src/server/activation/AutoPruner.js

@@ -1,73 +0,0 @@
-import { logger } from '../../utils/logger.js';
-export class AutoPruner {
-    lastActivity = new Map();
-    baseDomains;
-    autoActivatedDomains = new Set();
-    autoInactivityMs;
-    manualInactivityMs;
-    checkIntervalMs;
-    checkTimer = null;
-    eventBus;
-    onPrune;
-    constructor(eventBus, baseDomains, onPrune, config = {}) {
-        this.eventBus = eventBus;
-        this.baseDomains = baseDomains;
-        this.onPrune = onPrune;
-        this.autoInactivityMs = config.autoActivatedInactivityMs ?? 5 * 60_000;
-        this.manualInactivityMs = config.manualActivatedInactivityMs ?? 15 * 60_000;
-        this.checkIntervalMs = config.checkIntervalMs ?? 60_000;
-        this.startCheckTimer();
-    }
-    recordActivity(domain) {
-        this.lastActivity.set(domain, Date.now());
-    }
-    markAutoActivated(domain) {
-        this.autoActivatedDomains.add(domain);
-        this.lastActivity.set(domain, Date.now());
-    }
-    startCheckTimer() {
-        this.checkTimer = setInterval(() => {
-            this.checkAndPrune();
-        }, this.checkIntervalMs);
-        if (this.checkTimer.unref) {
-            this.checkTimer.unref();
-        }
-    }
-    checkAndPrune() {
-        const now = Date.now();
-        for (const [domain, lastTime] of this.lastActivity.entries()) {
-            if (this.baseDomains.has(domain))
-                continue;
-            const inactivityMs = now - lastTime;
-            const threshold = this.autoActivatedDomains.has(domain)
-                ? this.autoInactivityMs
-                : this.manualInactivityMs;
-            if (inactivityMs >= threshold) {
-                logger.info(`[AutoPruner] Pruning domain "${domain}" — inactive for ${Math.round(inactivityMs / 1000)}s ` +
-                    `(threshold: ${Math.round(threshold / 1000)}s)`);
-                this.onPrune(domain);
-                this.lastActivity.delete(domain);
-                this.autoActivatedDomains.delete(domain);
-                void this.eventBus.emit('activation:domain_pruned', {
-                    domain,
-                    reason: `inactivity (${Math.round(inactivityMs / 1000)}s)`,
-                    timestamp: new Date().toISOString(),
-                });
-            }
-        }
-    }
-    getLastActivity(domain) {
-        return this.lastActivity.get(domain);
-    }
-    isAutoActivated(domain) {
-        return this.autoActivatedDomains.has(domain);
-    }
-    dispose() {
-        if (this.checkTimer) {
-            clearInterval(this.checkTimer);
-            this.checkTimer = null;
-        }
-        this.lastActivity.clear();
-        this.autoActivatedDomains.clear();
-    }
-}

package/dist/src/server/activation/CompoundConditionEngine.d.ts

@@ -1,38 +0,0 @@
-import type { EventRecord } from './types.js';
-export type ConditionPredicate = {
-    type: 'platform';
-    value: NodeJS.Platform;
-} | {
-    type: 'domain_active';
-    domain: string;
-} | {
-    type: 'event_count';
-    event: string;
-    minCount: number;
-    windowMs: number;
-} | {
-    type: 'tool_called_recently';
-    toolName: string;
-    withinMs: number;
-};
-export interface CompoundCondition {
-    id: string;
-    name: string;
-    conditions: ConditionPredicate[];
-    boostDomains: string[];
-    priority: number;
-}
-export interface ConditionState {
-    platform: NodeJS.Platform;
-    activeDomains: Set<string>;
-    eventHistory: readonly EventRecord[];
-    recentToolCalls: readonly string[];
-}
-export declare class CompoundConditionEngine {
-    private readonly conditions;
-    constructor(customConditions?: CompoundCondition[]);
-    evaluate(state: ConditionState): string[];
-    private allConditionsMet;
-    private evaluatePredicate;
-    get conditionCount(): number;
-}

package/dist/src/server/activation/CompoundConditionEngine.js

@@ -1,78 +0,0 @@
-const DEFAULT_COMPOUND_CONDITIONS = [
-    {
-        id: 'wasm-chrome-macos',
-        name: 'WASM inside Chrome on macOS',
-        conditions: [
-            { type: 'platform', value: 'darwin' },
-            { type: 'domain_active', domain: 'browser' },
-            { type: 'event_count', event: 'tool:called', minCount: 2, windowMs: 120_000 },
-        ],
-        boostDomains: ['wasm', 'transform'],
-        priority: 20,
-    },
-    {
-        id: 'debug-memory',
-        name: 'Debug + Memory inspection',
-        conditions: [
-            { type: 'domain_active', domain: 'debugger' },
-            { type: 'event_count', event: 'debugger:breakpoint_hit', minCount: 1, windowMs: 120_000 },
-        ],
-        boostDomains: ['memory'],
-        priority: 15,
-    },
-    {
-        id: 'network-intercept-flow',
-        name: 'Network interception workflow',
-        conditions: [
-            { type: 'domain_active', domain: 'network' },
-            { type: 'domain_active', domain: 'browser' },
-        ],
-        boostDomains: ['hooks'],
-        priority: 10,
-    },
-];
-export class CompoundConditionEngine {
-    conditions;
-    constructor(customConditions = []) {
-        this.conditions = [...DEFAULT_COMPOUND_CONDITIONS, ...customConditions].toSorted((a, b) => b.priority - a.priority);
-    }
-    evaluate(state) {
-        const domainsToBoost = new Set();
-        for (const condition of this.conditions) {
-            if (this.allConditionsMet(condition, state)) {
-                for (const domain of condition.boostDomains) {
-                    domainsToBoost.add(domain);
-                }
-            }
-        }
-        return [...domainsToBoost];
-    }
-    allConditionsMet(compound, state) {
-        return compound.conditions.every((predicate) => this.evaluatePredicate(predicate, state));
-    }
-    evaluatePredicate(predicate, state) {
-        const now = Date.now();
-        switch (predicate.type) {
-            case 'platform':
-                return state.platform === predicate.value;
-            case 'domain_active':
-                return state.activeDomains.has(predicate.domain);
-            case 'event_count': {
-                const windowStart = now - predicate.windowMs;
-                const count = state.eventHistory.filter((e) => e.event.startsWith(predicate.event) && e.timestamp >= windowStart).length;
-                return count >= predicate.minCount;
-            }
-            case 'tool_called_recently': {
-                const windowStart = now - predicate.withinMs;
-                return state.eventHistory.some((e) => e.event === 'tool:called' &&
-                    e.timestamp >= windowStart &&
-                    e.payload?.toolName === predicate.toolName);
-            }
-            default:
-                return false;
-        }
-    }
-    get conditionCount() {
-        return this.conditions.length;
-    }
-}

package/dist/src/server/activation/PredictiveBooster.d.ts

@@ -1,13 +0,0 @@
-export declare class PredictiveBooster {
-    private readonly callHistory;
-    private readonly maxHistory;
-    private readonly confidenceThreshold;
-    private readonly transitions;
-    constructor(maxHistory?: number, confidenceThreshold?: number);
-    recordCall(toolName: string): void;
-    predictNext(currentTool: string): string[];
-    predictNextDomains(currentTool: string, getToolDomain: (name: string) => string | null): string[];
-    get historyLength(): number;
-    get transitionCount(): number;
-    reset(): void;
-}

package/dist/src/server/activation/PredictiveBooster.js

@@ -1,66 +0,0 @@
-export class PredictiveBooster {
-    callHistory = [];
-    maxHistory;
-    confidenceThreshold;
-    transitions = new Map();
-    constructor(maxHistory = 50, confidenceThreshold = 0.3) {
-        this.maxHistory = maxHistory;
-        this.confidenceThreshold = confidenceThreshold;
-    }
-    recordCall(toolName) {
-        const previous = this.callHistory.length > 0 ? this.callHistory[this.callHistory.length - 1] : null;
-        this.callHistory.push(toolName);
-        if (this.callHistory.length > this.maxHistory) {
-            this.callHistory.splice(0, this.callHistory.length - this.maxHistory);
-        }
-        if (previous) {
-            let targets = this.transitions.get(previous);
-            if (!targets) {
-                targets = new Map();
-                this.transitions.set(previous, targets);
-            }
-            targets.set(toolName, (targets.get(toolName) ?? 0) + 1);
-        }
-    }
-    predictNext(currentTool) {
-        const targets = this.transitions.get(currentTool);
-        if (!targets)
-            return [];
-        let total = 0;
-        for (const count of targets.values()) {
-            total += count;
-        }
-        if (total === 0)
-            return [];
-        const predictions = [];
-        for (const [tool, count] of targets.entries()) {
-            const confidence = count / total;
-            if (confidence >= this.confidenceThreshold) {
-                predictions.push({ tool, confidence });
-            }
-        }
-        predictions.sort((a, b) => b.confidence - a.confidence);
-        return predictions.map((p) => p.tool);
-    }
-    predictNextDomains(currentTool, getToolDomain) {
-        const predictedTools = this.predictNext(currentTool);
-        const domains = new Set();
-        for (const tool of predictedTools) {
-            const domain = getToolDomain(tool);
-            if (domain) {
-                domains.add(domain);
-            }
-        }
-        return [...domains];
-    }
-    get historyLength() {
-        return this.callHistory.length;
-    }
-    get transitionCount() {
-        return this.transitions.size;
-    }
-    reset() {
-        this.callHistory.length = 0;
-        this.transitions.clear();
-    }
-}

package/dist/src/server/activation/types.d.ts

@@ -1,22 +0,0 @@
-export interface BoostRule {
-    eventPattern: string;
-    targetDomains: string[];
-    threshold: number;
-    windowMs: number;
-    priority: number;
-}
-export interface PruneRule {
-    domain: string;
-    inactivityMs: number;
-}
-export interface ActivationControllerOptions {
-    cooldownMs?: number;
-    platformFilter?: boolean;
-    boostRules?: BoostRule[];
-    pruneRules?: PruneRule[];
-}
-export interface EventRecord {
-    event: string;
-    timestamp: number;
-    payload?: unknown;
-}

package/dist/src/server/activation/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/server/domains/analysis/definitions.d.ts

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

package/dist/src/server/domains/analysis/definitions.js

@@ -1,160 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-const webcrackMappingsSchema = {
-    type: 'array',
-    description: 'Remapping rules for unpacked bundle module paths',
-    items: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'New module path when matched' },
-            pattern: { type: 'string', description: 'Match text or regex' },
-            matchType: {
-                type: 'string',
-                enum: ['includes', 'regex', 'exact'],
-                description: 'How to interpret pattern',
-                default: 'includes',
-            },
-            target: {
-                type: 'string',
-                enum: ['code', 'path'],
-                description: 'Match against source code or module path',
-                default: 'code',
-            },
-        },
-        required: ['path', 'pattern'],
-    },
-};
-function withWebcrackOpts(b) {
-    return b
-        .boolean('unpack', 'Unpack webpack/browserify bundles', { default: true })
-        .boolean('unminify', 'Reformat and unminify code', { default: true })
-        .boolean('jsx', 'Decompile React.createElement to JSX', { default: true })
-        .boolean('mangle', 'Rename obfuscated identifiers', { default: false })
-        .string('outputDir', 'Directory to save deobfuscated artifacts')
-        .boolean('forceOutput', 'Remove outputDir before saving', { default: false })
-        .boolean('includeModuleCode', 'Include module source in bundle output', { default: false })
-        .number('maxBundleModules', 'Maximum bundle modules to return', { default: 100 })
-        .prop('mappings', webcrackMappingsSchema);
-}
-export const coreTools = [
-    tool('collect_code')
-        .desc('Collect JavaScript from a target website in summary, priority, incremental, or full mode')
-        .string('url', 'Target website URL')
-        .boolean('includeInline', 'Include inline scripts', { default: true })
-        .boolean('includeExternal', 'Include external scripts', { default: true })
-        .boolean('includeDynamic', 'Include dynamically loaded scripts', { default: false })
-        .enum('smartMode', ['summary', 'priority', 'incremental', 'full'], 'Collection mode', {
-        default: 'full',
-    })
-        .boolean('compress', 'Enable compression', { default: false })
-        .number('maxTotalSize', 'Maximum total size in bytes', { default: 2097152 })
-        .number('maxFileSize', 'Maximum single file size in KB', { default: 500 })
-        .array('priorities', { type: 'string' }, 'Preferred URL patterns for priority mode')
-        .boolean('returnSummaryOnly', 'Return summary only', { default: false })
-        .required('url')
-        .openWorld()
-        .build(),
-    tool('search_in_scripts')
-        .desc('Search collected scripts by keyword or regex pattern')
-        .string('keyword', 'Search keyword or regex pattern')
-        .boolean('isRegex', 'Treat keyword as regex', { default: false })
-        .boolean('caseSensitive', 'Case-sensitive search', { default: false })
-        .number('contextLines', 'Context lines around each match', { default: 3 })
-        .number('maxMatches', 'Maximum matches', { default: 100 })
-        .boolean('returnSummary', 'Return summary instead of full payload', { default: false })
-        .number('maxContextSize', 'Max response size before summary fallback', { default: 50000 })
-        .required('keyword')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('extract_function_tree')
-        .desc('Extract a function and its dependency tree from collected scripts')
-        .string('scriptId', 'Script identifier')
-        .string('functionName', 'Function name to extract')
-        .number('maxDepth', 'Maximum dependency traversal depth', { default: 3 })
-        .number('maxSize', 'Maximum output size in KB', { default: 500 })
-        .boolean('includeComments', 'Include comments in extracted source', { default: true })
-        .required('scriptId', 'functionName')
-        .build(),
-    withWebcrackOpts(tool('deobfuscate')
-        .desc('Run webcrack-powered JavaScript deobfuscation with bundle unpacking')
-        .string('code', 'Obfuscated JavaScript source')
-        .enum('llm', ['gpt-4', 'claude'], 'Preferred LLM for analysis', { default: 'gpt-4' })
-        .boolean('aggressive', 'Aggressive deobfuscation strategy', { default: false }))
-        .required('code')
-        .build(),
-    tool('understand_code')
-        .desc('Run semantic code analysis for structure, behavior, and risks')
-        .string('code', 'Source code to analyze')
-        .prop('context', { type: 'object', description: 'Additional contextual data' })
-        .enum('focus', ['structure', 'business', 'security', 'all'], 'Analysis focus', {
-        default: 'all',
-    })
-        .required('code')
-        .build(),
-    tool('detect_crypto')
-        .desc('Detect cryptographic algorithms and usage patterns in source code')
-        .string('code', 'Source code for crypto analysis')
-        .required('code')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('manage_hooks')
-        .desc('Create, inspect, and clear JavaScript runtime hooks')
-        .enum('action', ['create', 'list', 'records', 'clear'], 'Hook management operation')
-        .string('target', 'Hook target identifier')
-        .enum('type', ['function', 'xhr', 'fetch', 'websocket', 'localstorage', 'cookie'], 'Hook target type')
-        .enum('hookAction', ['log', 'block', 'modify'], 'Hook behavior', { default: 'log' })
-        .string('customCode', 'Custom JavaScript hook payload')
-        .string('hookId', 'Hook identifier')
-        .required('action')
-        .openWorld()
-        .build(),
-    tool('detect_obfuscation')
-        .desc('Detect obfuscation techniques in JavaScript source')
-        .string('code', 'Source code to inspect')
-        .boolean('generateReport', 'Include human-readable report', { default: true })
-        .required('code')
-        .readOnly()
-        .idempotent()
-        .build(),
-    withWebcrackOpts(tool('advanced_deobfuscate')
-        .desc('Advanced deobfuscation with webcrack backend')
-        .string('code', 'Obfuscated JavaScript source')
-        .boolean('detectOnly', 'Detect only without transformation', { default: false })
-        .boolean('aggressiveVM', 'Aggressive VM deobfuscation', { default: false })
-        .boolean('useASTOptimization', 'Apply AST optimization after transformation', {
-        default: true,
-    })
-        .number('timeout', 'Operation timeout in ms', { default: 60000 }))
-        .required('code')
-        .build(),
-    withWebcrackOpts(tool('webcrack_unpack')
-        .desc('Run webcrack bundle unpacking and return extracted module graph')
-        .string('code', 'Bundled or obfuscated JavaScript source'))
-        .required('code')
-        .build(),
-    tool('clear_collected_data')
-        .desc('Clear collected script data, caches, and in-memory indexes')
-        .destructive()
-        .build(),
-    tool('get_collection_stats')
-        .desc('Get collection, cache, and compression statistics')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('webpack_enumerate')
-        .desc('Enumerate webpack modules in current page and search for keywords')
-        .string('searchKeyword', 'Keyword to search across module exports')
-        .boolean('forceRequireAll', 'Force-require every module', { default: false })
-        .number('maxResults', 'Maximum matching modules', { default: 20 })
-        .openWorld()
-        .build(),
-    tool('source_map_extract')
-        .desc('Find and parse JavaScript source maps to recover original source code')
-        .boolean('includeContent', 'Include full source file content', { default: false })
-        .string('filterPath', 'Filter by path substring')
-        .number('maxFiles', 'Maximum source files', { default: 50 })
-        .readOnly()
-        .idempotent()
-        .build(),
-];

package/dist/src/server/domains/analysis/handlers.d.ts

@@ -1 +0,0 @@
-export { CoreAnalysisHandlers } from '../../domains/analysis/handlers.impl.js';