@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/ToolRouter.js

@@ -1,5 +1,7 @@
 import { logger } from '../utils/logger.js';
 import { allTools, getToolDomain } from './ToolCatalog.js';
+import { getActiveToolNames } from './MCPServer.search.helpers.js';
+import { normalizeToolName } from './MCPServer.search.validation.js';
 const WORKFLOW_RULES = [
     {
         patterns: [
@@ -8,8 +10,8 @@ const WORKFLOW_RULES = [
         ],
         domain: 'network',
         priority: 100,
-        tools: ['web_api_capture_session', 'page_navigate', 'hooks_install_listener'],
-        hint: 'Network capture workflow: Start capture session → Navigate to target → Inspect captured requests',
+        tools: ['web_api_capture_session', 'network_enable', 'page_navigate', 'network_get_requests'],
+        hint: 'Network capture workflow: bootstrap browser/page state -> enable capture -> navigate or act -> inspect captured requests',
     },
     {
         patterns: [
@@ -19,17 +21,17 @@ const WORKFLOW_RULES = [
         domain: 'browser',
         priority: 90,
         tools: ['page_navigate', 'page_screenshot', 'page_click', 'page_type', 'page_evaluate'],
-        hint: 'Browser automation workflow: Navigate → Interact → Extract data',
+        hint: 'Browser automation workflow: bootstrap browser/page state -> navigate -> interact -> extract data',
     },
     {
         patterns: [
             /(deobfuscate|deobfusc|beautify|analyze).*(javascript|js|script|code)/i,
             /(反混淆|美化|分析).*(javascript|js|脚本|代码)/i,
         ],
-        domain: 'analysis',
+        domain: 'core',
         priority: 85,
-        tools: ['deobfuscate_javascript', 'bundle_inspect', 'ast_parse'],
-        hint: 'JavaScript analysis workflow: Parse → Deobfuscate → Analyze AST',
+        tools: ['deobfuscate', 'advanced_deobfuscate', 'extract_function_tree'],
+        hint: 'JavaScript analysis workflow: collect -> deobfuscate -> inspect function tree',
     },
     {
         patterns: [
@@ -39,9 +41,11 @@ const WORKFLOW_RULES = [
         domain: 'workflow',
         priority: 95,
         tools: ['run_extension_workflow', 'list_extension_workflows'],
-        hint: 'Extension workflow: List available → Run specific workflow',
+        hint: 'Extension workflow: list available workflows -> run the best matching workflow',
     },
 ];
+const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
+const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
 function detectWorkflowIntent(query) {
     const matches = [];
     for (const rule of WORKFLOW_RULES) {
@@ -58,145 +62,270 @@ function detectWorkflowIntent(query) {
     return matches[0];
 }
 function getToolInputSchema(toolName, ctx) {
-    const builtInTool = allTools.find(t => t.name === toolName);
+    const canonicalName = normalizeToolName(toolName);
+    const builtInTool = allTools.find((tool) => tool.name === canonicalName);
     if (builtInTool) {
         return builtInTool.inputSchema;
     }
-    const extTool = ctx.extensionToolsByName.get(toolName);
+    const extTool = ctx.extensionToolsByName.get(canonicalName);
     if (extTool) {
         return extTool.tool.inputSchema;
     }
     return undefined;
 }
 function getToolDescription(toolName, ctx) {
-    const builtInTool = allTools.find(t => t.name === toolName);
+    const canonicalName = normalizeToolName(toolName);
+    const builtInTool = allTools.find((tool) => tool.name === canonicalName);
     if (builtInTool?.description) {
         return builtInTool.description.split('\n')[0] || 'No description available';
     }
-    const extTool = ctx.extensionToolsByName.get(toolName);
+    const extTool = ctx.extensionToolsByName.get(canonicalName);
     if (extTool?.tool?.description) {
         return extTool.tool.description.split('\n')[0] || 'No description available';
     }
     return 'No description available';
 }
 function isActive(toolName, ctx) {
+    const canonicalName = normalizeToolName(toolName);
     const activeTools = new Set([
-        ...ctx.selectedTools.map(t => t.name),
-        ...ctx.boostedToolNames,
+        ...ctx.selectedTools.map((tool) => tool.name),
         ...ctx.activatedToolNames,
-        ...ctx.boostedExtensionToolNames,
     ]);
-    return activeTools.has(toolName);
+    return activeTools.has(canonicalName);
+}
+function getAvailableToolNames(ctx) {
+    return new Set([
+        ...allTools.map((tool) => tool.name),
+        ...ctx.extensionToolsByName.keys(),
+    ]);
+}
+async function getRoutingState(ctx) {
+    let hasActivePage = false;
+    if (ctx.pageController && typeof ctx.pageController.getPage === 'function') {
+        try {
+            hasActivePage = Boolean(await ctx.pageController.getPage());
+        }
+        catch {
+            hasActivePage = false;
+        }
+    }
+    let networkEnabled = false;
+    let capturedRequestCount = 0;
+    if (ctx.consoleMonitor) {
+        try {
+            if (typeof ctx.consoleMonitor.getNetworkStatus === 'function') {
+                networkEnabled = Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
+            }
+            else if (typeof ctx.consoleMonitor.isNetworkEnabled === 'function') {
+                networkEnabled = Boolean(ctx.consoleMonitor.isNetworkEnabled());
+            }
+        }
+        catch {
+            networkEnabled = false;
+        }
+        try {
+            if (typeof ctx.consoleMonitor.getNetworkRequests === 'function') {
+                const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
+                if (Array.isArray(requests)) {
+                    capturedRequestCount = requests.length;
+                }
+            }
+        }
+        catch {
+            try {
+                if (typeof ctx.consoleMonitor.getNetworkRequests === 'function') {
+                    const requests = ctx.consoleMonitor.getNetworkRequests();
+                    if (Array.isArray(requests)) {
+                        capturedRequestCount = requests.length;
+                    }
+                }
+            }
+            catch {
+                capturedRequestCount = 0;
+            }
+        }
+    }
+    return {
+        hasActivePage,
+        networkEnabled,
+        capturedRequestCount,
+    };
+}
+function buildWorkflowToolSequence(workflow, state, availableToolNames) {
+    const sequence = [];
+    const pushIfAvailable = (toolName) => {
+        if (availableToolNames.has(toolName) && !sequence.includes(toolName)) {
+            sequence.push(toolName);
+        }
+    };
+    if ((workflow.domain === 'browser' || workflow.domain === 'network') && !state.hasActivePage) {
+        pushIfAvailable('browser_launch');
+        pushIfAvailable('browser_attach');
+    }
+    if (workflow.domain === 'network') {
+        if (state.hasActivePage && !state.networkEnabled) {
+            pushIfAvailable('network_enable');
+        }
+        if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0) {
+            pushIfAvailable('network_get_requests');
+        }
+    }
+    for (const toolName of workflow.tools) {
+        pushIfAvailable(toolName);
+    }
+    if (workflow.domain === 'network' && state.hasActivePage && state.networkEnabled) {
+        pushIfAvailable('network_get_requests');
+    }
+    return sequence;
+}
+function isBrowserOrNetworkTask(task, workflow) {
+    return workflow?.domain === 'browser' ||
+        workflow?.domain === 'network' ||
+        BROWSER_OR_NETWORK_TASK_PATTERN.test(task);
+}
+function isMaintenanceTask(task) {
+    return MAINTENANCE_TASK_PATTERN.test(task);
+}
+function rerankResultsForContext(results, task, workflow, state) {
+    const browserOrNetworkTask = isBrowserOrNetworkTask(task, workflow);
+    const maintenanceTask = isMaintenanceTask(task);
+    const reranked = results.map((result) => {
+        let score = result.score;
+        if (browserOrNetworkTask && !maintenanceTask && result.domain === 'maintenance') {
+            score *= 0.1;
+        }
+        if (browserOrNetworkTask) {
+            if (!state.hasActivePage && result.name === 'browser_launch') {
+                score *= 1.4;
+            }
+            if (!state.hasActivePage && result.name === 'browser_attach') {
+                score *= 1.2;
+            }
+            if (state.hasActivePage && !state.networkEnabled && result.name === 'network_enable') {
+                score *= 1.35;
+            }
+            if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0 && result.name === 'network_get_requests') {
+                score *= 1.5;
+            }
+        }
+        return {
+            ...result,
+            score,
+        };
+    });
+    reranked.sort((a, b) => b.score - a.score);
+    return reranked;
 }
 export async function routeToolRequest(request, ctx, searchEngine) {
     const { task, context = {} } = request;
     const maxRecommendations = context.maxRecommendations || 5;
-    const autoActivate = context.autoActivate !== false;
     logger.info('[ToolRouter] Routing request', { task, context });
     const workflow = detectWorkflowIntent(task);
-    const searchResults = searchEngine.search(task, maxRecommendations * 2);
+    const activeNames = getActiveToolNames(ctx);
+    const routingState = await getRoutingState(ctx);
+    const availableToolNames = getAvailableToolNames(ctx);
+    const searchResults = searchEngine.search(task, maxRecommendations * 2, activeNames);
     let finalResults = [];
     if (workflow) {
-        const workflowTools = workflow.tools.map(name => {
-            const domain = getToolDomain(name);
-            const isToolActive = isActive(name, ctx);
-            return {
-                name,
-                domain,
-                shortDescription: getToolDescription(name, ctx),
-                score: workflow.priority,
-                isActive: isToolActive,
-            };
-        });
-        const workflowNames = new Set(workflow.tools);
-        const otherResults = searchResults.filter(r => !workflowNames.has(r.name));
-        finalResults = [...workflowTools, ...otherResults].slice(0, maxRecommendations);
+        const workflowSequence = buildWorkflowToolSequence(workflow, routingState, availableToolNames);
+        const workflowTools = workflowSequence.map((name, index) => ({
+            name,
+            domain: getToolDomain(name) ?? ctx.extensionToolsByName.get(name)?.domain ?? null,
+            shortDescription: getToolDescription(name, ctx),
+            score: workflow.priority - (index * 0.01),
+            isActive: isActive(name, ctx),
+        }));
+        const workflowNames = new Set(workflowSequence);
+        const otherResults = searchResults.filter((result) => !workflowNames.has(result.name));
+        finalResults = [...workflowTools, ...otherResults];
     }
     else {
-        finalResults = searchResults.slice(0, maxRecommendations);
+        finalResults = [...searchResults];
     }
+    const dedupedResults = [];
+    const seenNames = new Set();
+    for (const result of finalResults) {
+        if (seenNames.has(result.name)) {
+            continue;
+        }
+        seenNames.add(result.name);
+        dedupedResults.push(result);
+    }
+    finalResults = rerankResultsForContext(dedupedResults, task, workflow, routingState);
     if (context.preferredDomain && finalResults.length > 0) {
         const domainBoostFactor = 1.15;
-        finalResults = finalResults.map(r => ({
-            ...r,
-            score: r.domain === context.preferredDomain ? r.score * domainBoostFactor : r.score,
+        finalResults = finalResults.map((result) => ({
+            ...result,
+            score: result.domain === context.preferredDomain ? result.score * domainBoostFactor : result.score,
         }));
         finalResults.sort((a, b) => b.score - a.score);
     }
-    const recommendations = finalResults.map(result => {
+    finalResults = finalResults.slice(0, maxRecommendations);
+    const recommendations = finalResults.map((result) => {
         const schema = getToolInputSchema(result.name, ctx);
-        const isToolActive = isActive(result.name, ctx);
-        const rec = {
+        const toolIsActive = isActive(result.name, ctx);
+        const recommendation = {
             name: result.name,
             domain: result.domain,
             description: result.shortDescription,
             inputSchema: schema || { type: 'object' },
             score: result.score,
-            isActive: isToolActive,
+            isActive: toolIsActive,
+            callCommand: buildCallToolCommand(result.name, schema || { type: 'object' }),
         };
-        if (!isToolActive) {
-            rec.activationCommand = `activate_tools with names: ["${result.name}"]`;
+        if (!toolIsActive) {
+            recommendation.activationCommand = `activate_tools with names: ["${result.name}"]`;
         }
-        return rec;
+        return recommendation;
     });
     const nextActions = [];
-    const inactiveTools = recommendations.filter(r => !r.isActive);
-    if (inactiveTools.length > 0 && autoActivate) {
-        const toActivate = inactiveTools.length === 1 ? [inactiveTools[0]] : [];
-        if (toActivate.length > 0 && toActivate[0]) {
-            nextActions.push({
-                step: 1,
-                action: 'activate',
-                toolName: toActivate[0].name,
-                command: `activate_tools with names: ["${toActivate[0].name}"]`,
-                description: `Activate ${toActivate[0].name} tool`,
-            });
-            nextActions.push({
-                step: 2,
-                action: 'call',
-                toolName: toActivate[0].name,
-                command: toActivate[0].name,
-                exampleArgs: generateExampleArgs(toActivate[0].inputSchema),
-                description: `Call ${toActivate[0].name} with appropriate arguments`,
-            });
-        }
-        else {
-            const topInactive = inactiveTools[0];
-            nextActions.push({
-                step: 1,
-                action: 'activate',
-                command: `activate_tools with names: [${inactiveTools.map(t => `"${t.name}"`).join(', ')}]`,
-                description: `Activate ${inactiveTools.length} recommended tools`,
-            });
-            nextActions.push({
-                step: 2,
-                action: 'call',
-                toolName: topInactive.name,
-                command: topInactive.name,
-                exampleArgs: generateExampleArgs(topInactive.inputSchema),
-                description: `Call ${topInactive.name} (top recommendation)`,
-            });
-        }
-    }
-    else if (recommendations.length > 0 && recommendations[0]?.isActive) {
+    const inactiveTools = recommendations.filter((recommendation) => !recommendation.isActive);
+    const activationCandidates = (() => {
+        if (!isBrowserOrNetworkTask(task, workflow) || isMaintenanceTask(task)) {
+            return inactiveTools;
+        }
+        const nonMaintenanceTools = inactiveTools.filter((tool) => tool.domain !== 'maintenance');
+        return nonMaintenanceTools.length > 0 ? nonMaintenanceTools : inactiveTools;
+    })();
+    if (recommendations.length > 0 && recommendations[0]?.isActive) {
         nextActions.push({
             step: 1,
             action: 'call',
             toolName: recommendations[0].name,
             command: recommendations[0].name,
             exampleArgs: generateExampleArgs(recommendations[0].inputSchema),
-            description: `Call ${recommendations[0].name} with appropriate arguments`,
+            description: `Call ${recommendations[0].name}. Use describe_tool("${recommendations[0].name}") only if you need the full schema.`,
         });
     }
-    const response = {
+    else if (activationCandidates.length > 0) {
+        const topInactive = activationCandidates[0];
+        nextActions.push({
+            step: 1,
+            action: 'activate',
+            toolName: activationCandidates.length === 1 ? topInactive.name : undefined,
+            command: `activate_tools with names: [${activationCandidates.map((tool) => `"${tool.name}"`).join(', ')}]`,
+            description: `Activate ${activationCandidates.length} recommended tool${activationCandidates.length === 1 ? '' : 's'}`,
+        });
+        nextActions.push({
+            step: 2,
+            action: 'call',
+            toolName: topInactive.name,
+            command: topInactive.name,
+            exampleArgs: generateExampleArgs(topInactive.inputSchema),
+            description: `Call ${topInactive.name}. Use describe_tool("${topInactive.name}") only if you need the full schema.`,
+        });
+    }
+    return {
         recommendations,
         nextActions,
         workflowHint: workflow?.hint,
         autoActivated: false,
     };
-    return response;
 }
-function generateExampleArgs(schema) {
+export function buildCallToolCommand(toolName, schema) {
+    return `call_tool({ name: "${toolName}", args: ${JSON.stringify(generateExampleArgs(schema))} })`;
+}
+export function generateExampleArgs(schema) {
     if (!schema || schema.type !== 'object' || !schema.properties) {
         return {};
     }
@@ -204,8 +333,9 @@ function generateExampleArgs(schema) {
     const required = new Set(Array.isArray(schema.required) ? schema.required : []);
     for (const [key, prop] of Object.entries(schema.properties)) {
         const propSchema = prop;
-        if (!required.has(key) && propSchema.default === undefined)
+        if (!required.has(key) && propSchema.default === undefined) {
             continue;
+        }
         if (propSchema.default !== undefined) {
             example[key] = propSchema.default;
         }
@@ -231,13 +361,14 @@ function generateExampleArgs(schema) {
     return example;
 }
 export function describeTool(toolName, ctx) {
-    const schema = getToolInputSchema(toolName, ctx);
+    const canonicalName = normalizeToolName(toolName);
+    const schema = getToolInputSchema(canonicalName, ctx);
     if (!schema) {
         return null;
     }
     return {
-        name: toolName,
-        description: getToolDescription(toolName, ctx),
+        name: canonicalName,
+        description: getToolDescription(canonicalName, ctx),
         inputSchema: schema,
     };
 }

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

@@ -1,5 +1,10 @@
 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';
+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_ACTIONS = new Set(['log', 'block', 'modify']);
 import { runSourceMapExtract, runWebpackEnumerate } from '../../domains/analysis/handlers.web-tools.js';
 import { runWebcrack } from '../../../modules/deobfuscator/webcrack.js';
 export class CoreAnalysisHandlers {
@@ -57,8 +62,8 @@ export class CoreAnalysisHandlers {
         return extracted;
     }
     async handleCollectCode(args) {
-        const returnSummaryOnly = args.returnSummaryOnly ?? false;
-        let smartMode = args.smartMode;
+        const returnSummaryOnly = argBool(args, 'returnSummaryOnly', false);
+        let smartMode = argEnum(args, 'smartMode', SMART_MODES);
         const maxSummaryFiles = 40;
         const summarizeFiles = (files) => files.slice(0, maxSummaryFiles).map((file) => ({
             url: file.url,
@@ -72,14 +77,14 @@ export class CoreAnalysisHandlers {
             smartMode = 'summary';
         }
         const result = await this.collector.collect({
-            url: args.url,
-            includeInline: args.includeInline,
-            includeExternal: args.includeExternal,
-            includeDynamic: args.includeDynamic,
+            url: argStringRequired(args, 'url'),
+            includeInline: argBool(args, 'includeInline'),
+            includeExternal: argBool(args, 'includeExternal'),
+            includeDynamic: argBool(args, 'includeDynamic'),
             smartMode,
-            compress: args.compress,
-            maxTotalSize: args.maxTotalSize,
-            maxFileSize: args.maxFileSize ? args.maxFileSize * 1024 : undefined,
+            compress: argBool(args, 'compress'),
+            maxTotalSize: argNumber(args, 'maxTotalSize'),
+            maxFileSize: args.maxFileSize ? argNumber(args, 'maxFileSize', 0) * 1024 : undefined,
             priorities: args.priorities,
         });
         if (returnSummaryOnly) {
@@ -122,17 +127,17 @@ export class CoreAnalysisHandlers {
     }
     async handleSearchInScripts(args) {
         await this.scriptManager.init();
-        const keyword = args.keyword;
+        const keyword = argString(args, 'keyword');
         if (!keyword) {
             return asJsonResponse({ success: false, error: 'keyword is required' });
         }
-        const maxMatches = args.maxMatches ?? 100;
-        const returnSummary = args.returnSummary ?? false;
-        const maxContextSize = args.maxContextSize ?? 50000;
+        const maxMatches = argNumber(args, 'maxMatches', 100);
+        const returnSummary = argBool(args, 'returnSummary', false);
+        const maxContextSize = argNumber(args, 'maxContextSize', 50000);
         const result = await this.scriptManager.searchInScripts(keyword, {
-            isRegex: args.isRegex,
-            caseSensitive: args.caseSensitive,
-            contextLines: args.contextLines,
+            isRegex: argBool(args, 'isRegex'),
+            caseSensitive: argBool(args, 'caseSensitive'),
+            contextLines: argNumber(args, 'contextLines'),
             maxMatches,
         });
         const resultSize = JSON.stringify(result).length;
@@ -165,8 +170,8 @@ export class CoreAnalysisHandlers {
         return asJsonResponse(result);
     }
     async handleExtractFunctionTree(args) {
-        const scriptId = args.scriptId;
-        const functionName = args.functionName;
+        const scriptId = argString(args, 'scriptId');
+        const functionName = argString(args, 'functionName');
         if (!scriptId) {
             return asJsonResponse({
                 success: false,
@@ -199,9 +204,9 @@ export class CoreAnalysisHandlers {
         }
         try {
             const result = await this.scriptManager.extractFunctionTree(scriptId, functionName, {
-                maxDepth: args.maxDepth,
-                maxSize: args.maxSize,
-                includeComments: args.includeComments,
+                maxDepth: argNumber(args, 'maxDepth'),
+                maxSize: argNumber(args, 'maxSize'),
+                includeComments: argBool(args, 'includeComments'),
             });
             return asJsonResponse({ success: true, ...result });
         }
@@ -224,8 +229,8 @@ export class CoreAnalysisHandlers {
         }
         const result = await this.deobfuscator.deobfuscate({
             code,
-            llm: args.llm,
-            aggressive: args.aggressive,
+            llm: argString(args, 'llm'),
+            aggressive: argBool(args, 'aggressive'),
             ...this.extractWebcrackArgs(args),
         });
         if (result && typeof result === 'object' && 'success' in result && result.success === false && !('error' in result)) {
@@ -243,8 +248,8 @@ export class CoreAnalysisHandlers {
         }
         const result = await this.analyzer.understand({
             code,
-            context: args.context,
-            focus: args.focus || 'all',
+            context: argObject(args, 'context'),
+            focus: argEnum(args, 'focus', FOCUS_MODES, 'all'),
         });
         return asJsonResponse(result);
     }
@@ -262,14 +267,14 @@ export class CoreAnalysisHandlers {
         return asJsonResponse(result);
     }
     async handleManageHooks(args) {
-        const action = args.action;
+        const action = argStringRequired(args, 'action');
         switch (action) {
             case 'create': {
                 const result = await this.hookManager.createHook({
-                    target: args.target,
-                    type: args.type,
-                    action: args.hookAction || 'log',
-                    customCode: args.customCode,
+                    target: argStringRequired(args, 'target'),
+                    type: argEnum(args, 'type', HOOK_TYPES) ?? 'function',
+                    action: argEnum(args, 'hookAction', HOOK_ACTIONS, 'log'),
+                    customCode: argString(args, 'customCode'),
                 });
                 return asJsonResponse(result);
             }
@@ -277,10 +282,10 @@ export class CoreAnalysisHandlers {
                 return asJsonResponse({ hooks: this.hookManager.getAllHooks() });
             case 'records':
                 return asJsonResponse({
-                    records: this.hookManager.getHookRecords(args.hookId),
+                    records: this.hookManager.getHookRecords(argStringRequired(args, 'hookId')),
                 });
             case 'clear':
-                this.hookManager.clearHookRecords(args.hookId);
+                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` });
@@ -294,7 +299,7 @@ export class CoreAnalysisHandlers {
                 error: 'code is required and must be a non-empty string',
             });
         }
-        const generateReport = args.generateReport ?? true;
+        const generateReport = argBool(args, 'generateReport', true);
         const result = this.obfuscationDetector.detect(code);
         if (!generateReport) {
             return asJsonResponse(result);
@@ -331,10 +336,10 @@ export class CoreAnalysisHandlers {
             });
         }
         const result = await runWebcrack(code, {
-            unpack: args.unpack ?? true,
-            unminify: args.unminify ?? true,
-            jsx: args.jsx ?? true,
-            mangle: args.mangle ?? false,
+            unpack: argBool(args, 'unpack', true),
+            unminify: argBool(args, 'unminify', true),
+            jsx: argBool(args, 'jsx', true),
+            mangle: argBool(args, 'mangle', false),
             ...this.extractWebcrackArgs(args),
         });
         if (!result.applied) {

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

@@ -1,9 +1,10 @@
 import { logger } from '../../../utils/logger.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) {
-    const searchKeyword = args.searchKeyword ?? '';
-    const forceRequireAll = args.forceRequireAll ?? !!searchKeyword;
-    const maxResults = args.maxResults ?? 20;
+    const searchKeyword = argString(args, 'searchKeyword', '');
+    const forceRequireAll = argBool(args, 'forceRequireAll', !!searchKeyword);
+    const maxResults = argNumber(args, 'maxResults', 20);
     try {
         const page = await collector.getActivePage();
         const result = await page.evaluate(async (opts) => {
@@ -103,9 +104,9 @@ export async function runWebpackEnumerate(collector, args) {
     }
 }
 export async function runSourceMapExtract(collector, args) {
-    const includeContent = args.includeContent ?? false;
-    const filterPath = args.filterPath ?? '';
-    const maxFiles = args.maxFiles ?? 50;
+    const includeContent = argBool(args, 'includeContent', false);
+    const filterPath = argString(args, 'filterPath', '');
+    const maxFiles = argNumber(args, 'maxFiles', 50);
     try {
         const page = await collector.getActivePage();
         const result = await page.evaluate(async (opts) => {