@jshookmcp/jshook 0.2.1 → 0.2.3

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

@@ -0,0 +1,78 @@
+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].sort((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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,22 @@
+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/domains/analysis/definitions.js

@@ -58,6 +58,12 @@ export const coreTools = [
             },
             required: ['url'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'search_in_scripts',
@@ -102,6 +108,12 @@ export const coreTools = [
             },
             required: ['keyword'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'extract_function_tree',
@@ -135,6 +147,12 @@ export const coreTools = [
             },
             required: ['scriptId', 'functionName'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'deobfuscate',
@@ -229,6 +247,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'understand_code',
@@ -253,6 +277,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'detect_crypto',
@@ -267,6 +297,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'manage_hooks',
@@ -305,6 +341,12 @@ export const coreTools = [
             },
             required: ['action'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'detect_obfuscation',
@@ -324,6 +366,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'advanced_deobfuscate',
@@ -427,6 +475,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'webcrack_unpack',
@@ -510,6 +564,12 @@ export const coreTools = [
             },
             required: ['code'],
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'clear_collected_data',
@@ -518,6 +578,12 @@ export const coreTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
     },
     {
         name: 'get_collection_stats',
@@ -526,6 +592,12 @@ export const coreTools = [
             type: 'object',
             properties: {},
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
     {
         name: 'webpack_enumerate',
@@ -549,6 +621,12 @@ export const coreTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
     },
     {
         name: 'source_map_extract',
@@ -572,5 +650,11 @@ export const coreTools = [
                 },
             },
         },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
     },
 ];

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

@@ -1,12 +1,12 @@
 import type { ToolArgs, ToolResponse } from '../../types.js';
-import { CodeCollector } from '../../domains/shared/modules.js';
-import { ScriptManager } from '../../domains/shared/modules.js';
-import { Deobfuscator } from '../../domains/shared/modules.js';
-import { AdvancedDeobfuscator } from '../../domains/shared/modules.js';
-import { ObfuscationDetector } from '../../domains/shared/modules.js';
-import { CodeAnalyzer } from '../../domains/shared/modules.js';
-import { CryptoDetector } from '../../domains/shared/modules.js';
-import { HookManager } from '../../domains/shared/modules.js';
+import { type CodeCollector } from '../../domains/shared/modules.js';
+import { type ScriptManager } from '../../domains/shared/modules.js';
+import { type Deobfuscator } from '../../domains/shared/modules.js';
+import { type AdvancedDeobfuscator } from '../../domains/shared/modules.js';
+import { type ObfuscationDetector } from '../../domains/shared/modules.js';
+import { type CodeAnalyzer } from '../../domains/shared/modules.js';
+import { type CryptoDetector } from '../../domains/shared/modules.js';
+import { type HookManager } from '../../domains/shared/modules.js';
 interface CoreAnalysisHandlerDeps {
     collector: CodeCollector;
     scriptManager: ScriptManager;

package/dist/src/server/domains/analysis/handlers.impl.js

@@ -1,11 +1,27 @@
 import { logger } from '../../../utils/logger.js';
 import { asJsonResponse, asTextResponse, serializeError } from '../../domains/shared/response.js';
-import { argString, argBool, argNumber, argStringRequired, argObject, argEnum } from '../../domains/shared/parse-args.js';
+import { argString, argBool, argNumber, argStringRequired, argObject, argEnum, } from '../../domains/shared/parse-args.js';
+import { ANALYSIS_MAX_SUMMARY_FILES, ANALYSIS_MAX_SAFE_COLLECTED_BYTES, ANALYSIS_MAX_SAFE_RESPONSE_BYTES, } from '../../../constants.js';
 const SMART_MODES = new Set(['summary', 'priority', 'incremental', 'full']);
 const FOCUS_MODES = new Set(['structure', 'business', 'security', 'all']);
-const HOOK_TYPES = new Set(['function', 'xhr', 'fetch', 'websocket', 'localstorage', 'cookie']);
+const HOOK_TYPES = new Set([
+    'function',
+    'xhr',
+    'fetch',
+    'websocket',
+    'localstorage',
+    'cookie',
+]);
 const HOOK_ACTIONS = new Set(['log', 'block', 'modify']);
-import { runSourceMapExtract, runWebpackEnumerate } from '../../domains/analysis/handlers.web-tools.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import {} from '../../domains/shared/modules.js';
+import { runSourceMapExtract, runWebpackEnumerate, } from '../../domains/analysis/handlers.web-tools.js';
 import { runWebcrack } from '../../../modules/deobfuscator/webcrack.js';
 export class CoreAnalysisHandlers {
     collector;
@@ -64,7 +80,7 @@ export class CoreAnalysisHandlers {
     async handleCollectCode(args) {
         const returnSummaryOnly = argBool(args, 'returnSummaryOnly', false);
         let smartMode = argEnum(args, 'smartMode', SMART_MODES);
-        const maxSummaryFiles = 40;
+        const maxSummaryFiles = ANALYSIS_MAX_SUMMARY_FILES;
         const summarizeFiles = (files) => files.slice(0, maxSummaryFiles).map((file) => ({
             url: file.url,
             type: file.type,
@@ -100,8 +116,8 @@ export class CoreAnalysisHandlers {
                 hint: 'Use get_script_source for specific files.',
             });
         }
-        const maxSafeCollectedSize = 256 * 1024;
-        const maxSafeResponseSize = 220 * 1024;
+        const maxSafeCollectedSize = ANALYSIS_MAX_SAFE_COLLECTED_BYTES;
+        const maxSafeResponseSize = ANALYSIS_MAX_SAFE_RESPONSE_BYTES;
         const estimatedResponseSize = Buffer.byteLength(JSON.stringify(result), 'utf8');
         if (result.totalSize > maxSafeCollectedSize || estimatedResponseSize > maxSafeResponseSize) {
             logger.warn(`Collected code is too large (collected=${(result.totalSize / 1024).toFixed(2)}KB, response=${(estimatedResponseSize / 1024).toFixed(2)}KB), returning summary mode.`);
@@ -188,9 +204,9 @@ export class CoreAnalysisHandlers {
         }
         await this.scriptManager.init();
         const scripts = await this.scriptManager.getAllScripts();
-        const scriptExists = scripts.some(s => String(s.scriptId) === String(scriptId));
+        const scriptExists = scripts.some((s) => String(s.scriptId) === String(scriptId));
         if (!scriptExists) {
-            const availableScripts = scripts.slice(0, 10).map(s => ({
+            const availableScripts = scripts.slice(0, 10).map((s) => ({
                 scriptId: s.scriptId,
                 url: s.url?.substring(0, 80),
             }));
@@ -198,7 +214,9 @@ export class CoreAnalysisHandlers {
                 success: false,
                 error: `Script not found: ${scriptId}`,
                 hint: 'The specified scriptId does not exist. Use get_all_scripts() to list available scripts.',
-                availableScripts: availableScripts.length > 0 ? availableScripts : 'No scripts loaded. Navigate to a page first.',
+                availableScripts: availableScripts.length > 0
+                    ? availableScripts
+                    : 'No scripts loaded. Navigate to a page first.',
                 totalScripts: scripts.length,
             });
         }
@@ -233,8 +251,15 @@ export class CoreAnalysisHandlers {
             aggressive: argBool(args, 'aggressive'),
             ...this.extractWebcrackArgs(args),
         });
-        if (result && typeof result === 'object' && 'success' in result && result.success === false && !('error' in result)) {
-            return asJsonResponse({ ...result, error: result.reason || 'deobfuscation failed' });
+        if (result &&
+            typeof result === 'object' &&
+            'success' in result &&
+            result.success === false &&
+            !('error' in result)) {
+            return asJsonResponse({
+                ...result,
+                error: result.reason || 'deobfuscation failed',
+            });
         }
         return asJsonResponse(result);
     }
@@ -288,7 +313,10 @@ export class CoreAnalysisHandlers {
                 this.hookManager.clearHookRecords(argString(args, 'hookId'));
                 return asJsonResponse({ success: true, message: 'Hook records cleared' });
             default:
-                return asJsonResponse({ success: false, message: `Unknown hook action: ${action}. Valid actions: create, list, records, clear` });
+                return asJsonResponse({
+                    success: false,
+                    message: `Unknown hook action: ${action}. Valid actions: create, list, records, clear`,
+                });
         }
     }
     async handleDetectObfuscation(args) {

package/dist/src/server/domains/analysis/handlers.web-tools.js

@@ -1,4 +1,5 @@
 import { logger } from '../../../utils/logger.js';
+import { evaluateWithTimeout } from '../../../modules/collector/PageController.js';
 import { asJsonResponse, asErrorResponse } from '../../domains/shared/response.js';
 import { argString, argBool, argNumber } from '../../domains/shared/parse-args.js';
 export async function runWebpackEnumerate(collector, args) {
@@ -7,7 +8,7 @@ export async function runWebpackEnumerate(collector, args) {
     const maxResults = argNumber(args, 'maxResults', 20);
     try {
         const page = await collector.getActivePage();
-        const result = await page.evaluate(async (opts) => {
+        const result = await evaluateWithTimeout(page, async (opts) => {
             const w = window;
             let requireFn = null;
             if (typeof w['__webpack_require__'] === 'function') {
@@ -40,7 +41,7 @@ export async function runWebpackEnumerate(collector, args) {
             if (!requireFn) {
                 for (const key of chunkKeys) {
                     const arr = w[key];
-                    if (arr && arr.m && typeof arr.m === 'object') {
+                    if (arr?.m && typeof arr.m === 'object') {
                         const mods = arr.m;
                         requireFn = (id) => {
                             try {
@@ -81,7 +82,8 @@ export async function runWebpackEnumerate(collector, args) {
                     catch {
                         str = String(mod);
                     }
-                    if (!opts.searchKeyword || str.toLowerCase().includes(opts.searchKeyword.toLowerCase())) {
+                    if (!opts.searchKeyword ||
+                        str.toLowerCase().includes(opts.searchKeyword.toLowerCase())) {
                         matches.push({ id, preview: str.slice(0, 600) });
                     }
                 }
@@ -109,7 +111,7 @@ export async function runSourceMapExtract(collector, args) {
     const maxFiles = argNumber(args, 'maxFiles', 50);
     try {
         const page = await collector.getActivePage();
-        const result = await page.evaluate(async (opts) => {
+        const result = await evaluateWithTimeout(page, async (opts) => {
             const scriptUrls = Array.from(document.querySelectorAll('script[src]'))
                 .map((s) => s.src)
                 .filter(Boolean);
@@ -138,10 +140,18 @@ export async function runSourceMapExtract(collector, args) {
                 if (files.length >= opts.maxFiles)
                     break;
                 try {
-                    const resp = await fetch(scriptUrl, { cache: 'force-cache' });
-                    const text = await resp.text();
+                    const ac1 = new AbortController();
+                    const t1 = setTimeout(() => ac1.abort(), 10000);
+                    let text;
+                    try {
+                        const resp = await fetch(scriptUrl, { cache: 'force-cache', signal: ac1.signal });
+                        text = await resp.text();
+                    }
+                    finally {
+                        clearTimeout(t1);
+                    }
                     const match = text.match(/\/\/# sourceMappingURL=([^\s]+)/);
-                    if (!match || !match[1])
+                    if (!match?.[1])
                         continue;
                     let mapUrl = match[1].trim();
                     if (mapUrl.startsWith('data:')) {
@@ -162,8 +172,16 @@ export async function runSourceMapExtract(collector, args) {
                             continue;
                         }
                     }
-                    const mapResp = await fetch(mapUrl);
-                    const mapData = (await mapResp.json());
+                    const ac2 = new AbortController();
+                    const t2 = setTimeout(() => ac2.abort(), 10000);
+                    let mapData;
+                    try {
+                        const mapResp = await fetch(mapUrl, { signal: ac2.signal });
+                        mapData = await mapResp.json();
+                    }
+                    finally {
+                        clearTimeout(t2);
+                    }
                     processMapData(mapData, scriptUrl);
                 }
                 catch {

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

@@ -9,6 +9,18 @@ declare const manifest: {
     depKey: "coreAnalysisHandlers";
     profiles: ("workflow" | "full")[];
     ensure: typeof ensure;
+    workflowRule: {
+        patterns: RegExp[];
+        priority: number;
+        tools: string[];
+        hint: string;
+    };
+    prerequisites: {
+        collect_code: {
+            condition: string;
+            fix: string;
+        }[];
+    };
     registrations: {
         tool: {
             inputSchema: {

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

@@ -46,21 +46,61 @@ const manifest = {
     depKey: DEP_KEY,
     profiles: ['workflow', 'full'],
     ensure,
+    workflowRule: {
+        patterns: [
+            /(deobfuscate|deobfusc|beautify|analyze).*(javascript|js|script|code)/i,
+            /(反混淆|美化|分析).*(javascript|js|脚本|代码)/i,
+        ],
+        priority: 85,
+        tools: ['deobfuscate', 'advanced_deobfuscate', 'extract_function_tree'],
+        hint: 'JavaScript analysis workflow: collect -> deobfuscate -> inspect function tree',
+    },
+    prerequisites: {
+        collect_code: [{ condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' }],
+    },
     registrations: [
         { tool: t('collect_code'), domain: DOMAIN, bind: b((h, a) => h.handleCollectCode(a)) },
         { tool: t('search_in_scripts'), domain: DOMAIN, bind: b((h, a) => h.handleSearchInScripts(a)) },
-        { tool: t('extract_function_tree'), domain: DOMAIN, bind: b((h, a) => h.handleExtractFunctionTree(a)) },
+        {
+            tool: t('extract_function_tree'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleExtractFunctionTree(a)),
+        },
         { tool: t('deobfuscate'), domain: DOMAIN, bind: b((h, a) => h.handleDeobfuscate(a)) },
         { tool: t('understand_code'), domain: DOMAIN, bind: b((h, a) => h.handleUnderstandCode(a)) },
         { tool: t('detect_crypto'), domain: DOMAIN, bind: b((h, a) => h.handleDetectCrypto(a)) },
         { tool: t('manage_hooks'), domain: DOMAIN, bind: b((h, a) => h.handleManageHooks(a)) },
-        { tool: t('detect_obfuscation'), domain: DOMAIN, bind: b((h, a) => h.handleDetectObfuscation(a)) },
-        { tool: t('advanced_deobfuscate'), domain: DOMAIN, bind: b((h, a) => h.handleAdvancedDeobfuscate(a)) },
+        {
+            tool: t('detect_obfuscation'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleDetectObfuscation(a)),
+        },
+        {
+            tool: t('advanced_deobfuscate'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleAdvancedDeobfuscate(a)),
+        },
         { tool: t('webcrack_unpack'), domain: DOMAIN, bind: b((h, a) => h.handleWebcrackUnpack(a)) },
-        { tool: t('clear_collected_data'), domain: DOMAIN, bind: b((h) => h.handleClearCollectedData()) },
-        { tool: t('get_collection_stats'), domain: DOMAIN, bind: b((h) => h.handleGetCollectionStats()) },
-        { tool: t('webpack_enumerate'), domain: DOMAIN, bind: b((h, a) => h.handleWebpackEnumerate(a)) },
-        { tool: t('source_map_extract'), domain: DOMAIN, bind: b((h, a) => h.handleSourceMapExtract(a)) },
+        {
+            tool: t('clear_collected_data'),
+            domain: DOMAIN,
+            bind: b((h) => h.handleClearCollectedData()),
+        },
+        {
+            tool: t('get_collection_stats'),
+            domain: DOMAIN,
+            bind: b((h) => h.handleGetCollectionStats()),
+        },
+        {
+            tool: t('webpack_enumerate'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleWebpackEnumerate(a)),
+        },
+        {
+            tool: t('source_map_extract'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleSourceMapExtract(a)),
+        },
     ],
 };
 export default manifest;