@jshookmcp/jshook 0.1.7 → 0.1.9

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

@@ -1,353 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { asJsonResponse, asTextResponse, serializeError } from '../../domains/shared/response.js';
-import { runSourceMapExtract, runWebpackEnumerate } from '../../domains/analysis/handlers.web-tools.js';
-export class CoreAnalysisHandlers {
-    collector;
-    scriptManager;
-    deobfuscator;
-    advancedDeobfuscator;
-    astOptimizer;
-    obfuscationDetector;
-    analyzer;
-    cryptoDetector;
-    hookManager;
-    constructor(deps) {
-        this.collector = deps.collector;
-        this.scriptManager = deps.scriptManager;
-        this.deobfuscator = deps.deobfuscator;
-        this.advancedDeobfuscator = deps.advancedDeobfuscator;
-        this.astOptimizer = deps.astOptimizer;
-        this.obfuscationDetector = deps.obfuscationDetector;
-        this.analyzer = deps.analyzer;
-        this.cryptoDetector = deps.cryptoDetector;
-        this.hookManager = deps.hookManager;
-    }
-    requireCodeArg(args, toolName) {
-        const code = args.code;
-        if (typeof code !== 'string' || code.trim().length === 0) {
-            logger.warn(`${toolName} called without valid code argument`);
-            return null;
-        }
-        return code;
-    }
-    async handleCollectCode(args) {
-        const returnSummaryOnly = args.returnSummaryOnly ?? false;
-        let smartMode = args.smartMode;
-        const maxSummaryFiles = 40;
-        const summarizeFiles = (files) => files.slice(0, maxSummaryFiles).map((file) => ({
-            url: file.url,
-            type: file.type,
-            size: file.size,
-            sizeKB: (file.size / 1024).toFixed(2),
-            truncated: file.metadata?.truncated || false,
-            preview: `${file.content.substring(0, 200)}...`,
-        }));
-        if (returnSummaryOnly && !smartMode) {
-            smartMode = 'summary';
-        }
-        const result = await this.collector.collect({
-            url: args.url,
-            includeInline: args.includeInline,
-            includeExternal: args.includeExternal,
-            includeDynamic: args.includeDynamic,
-            smartMode,
-            compress: args.compress,
-            maxTotalSize: args.maxTotalSize,
-            maxFileSize: args.maxFileSize ? args.maxFileSize * 1024 : undefined,
-            priorities: args.priorities,
-        });
-        if (returnSummaryOnly) {
-            return asJsonResponse({
-                mode: 'summary',
-                totalSize: result.totalSize,
-                totalSizeKB: (result.totalSize / 1024).toFixed(2),
-                filesCount: result.files.length,
-                summarizedFiles: Math.min(result.files.length, maxSummaryFiles),
-                omittedFiles: Math.max(0, result.files.length - maxSummaryFiles),
-                collectTime: result.collectTime,
-                summary: summarizeFiles(result.files),
-                hint: 'Use get_script_source for specific files.',
-            });
-        }
-        const maxSafeCollectedSize = 256 * 1024;
-        const maxSafeResponseSize = 220 * 1024;
-        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.`);
-            return asJsonResponse({
-                warning: 'Code size exceeds safe response threshold; summary returned.',
-                totalSize: result.totalSize,
-                totalSizeKB: (result.totalSize / 1024).toFixed(2),
-                estimatedResponseSize,
-                estimatedResponseSizeKB: (estimatedResponseSize / 1024).toFixed(2),
-                filesCount: result.files.length,
-                summarizedFiles: Math.min(result.files.length, maxSummaryFiles),
-                omittedFiles: Math.max(0, result.files.length - maxSummaryFiles),
-                collectTime: result.collectTime,
-                summary: summarizeFiles(result.files),
-                recommendations: [
-                    'Use get_script_source for targeted files.',
-                    'Use more specific priority filters.',
-                    'Use smartMode=summary for initial reconnaissance.',
-                ],
-            });
-        }
-        return asJsonResponse(result);
-    }
-    async handleSearchInScripts(args) {
-        await this.scriptManager.init();
-        const keyword = 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 result = await this.scriptManager.searchInScripts(keyword, {
-            isRegex: args.isRegex,
-            caseSensitive: args.caseSensitive,
-            contextLines: args.contextLines,
-            maxMatches,
-        });
-        const resultSize = JSON.stringify(result).length;
-        const shouldSummarize = returnSummary || resultSize > maxContextSize;
-        if (shouldSummarize) {
-            const matches = (result.matches ?? []);
-            return asJsonResponse({
-                success: true,
-                keyword: args.keyword,
-                totalMatches: matches.length,
-                resultSize,
-                resultSizeKB: (resultSize / 1024).toFixed(2),
-                truncated: resultSize > maxContextSize,
-                reason: resultSize > maxContextSize
-                    ? `Result too large (${(resultSize / 1024).toFixed(2)}KB > ${(maxContextSize / 1024).toFixed(2)}KB)`
-                    : 'Summary mode enabled',
-                matchesSummary: matches.slice(0, 10).map((match) => ({
-                    scriptId: match.scriptId,
-                    url: match.url,
-                    line: match.line,
-                    preview: `${(match.context ?? '').substring(0, 100)}...`,
-                })),
-                recommendations: [
-                    'Use more specific keywords.',
-                    `Reduce maxMatches (current: ${maxMatches}).`,
-                    'Use get_script_source for targeted file retrieval.',
-                ],
-            });
-        }
-        return asJsonResponse(result);
-    }
-    async handleExtractFunctionTree(args) {
-        const scriptId = args.scriptId;
-        const functionName = args.functionName;
-        if (!scriptId) {
-            return asJsonResponse({
-                success: false,
-                error: 'scriptId is required',
-                hint: 'Use get_all_scripts() to list available scripts and their scriptIds',
-            });
-        }
-        if (!functionName) {
-            return asJsonResponse({
-                success: false,
-                error: 'functionName is required',
-                hint: 'Specify the name of the function to extract',
-            });
-        }
-        await this.scriptManager.init();
-        const scripts = await this.scriptManager.getAllScripts();
-        const scriptExists = scripts.some(s => String(s.scriptId) === String(scriptId));
-        if (!scriptExists) {
-            const availableScripts = scripts.slice(0, 10).map(s => ({
-                scriptId: s.scriptId,
-                url: s.url?.substring(0, 80),
-            }));
-            return asJsonResponse({
-                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.',
-                totalScripts: scripts.length,
-            });
-        }
-        try {
-            const result = await this.scriptManager.extractFunctionTree(scriptId, functionName, {
-                maxDepth: args.maxDepth,
-                maxSize: args.maxSize,
-                includeComments: args.includeComments,
-            });
-            return asJsonResponse({ success: true, ...result });
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            return asJsonResponse({
-                success: false,
-                error: errorMsg,
-                hint: 'Make sure the function name exists in the specified script',
-            });
-        }
-    }
-    async handleDeobfuscate(args) {
-        const code = this.requireCodeArg(args, 'deobfuscate');
-        if (!code) {
-            return asJsonResponse({
-                success: false,
-                error: 'code is required and must be a non-empty string',
-            });
-        }
-        const result = await this.deobfuscator.deobfuscate({
-            code,
-            llm: args.llm,
-            aggressive: args.aggressive,
-        });
-        return asJsonResponse(result);
-    }
-    async handleUnderstandCode(args) {
-        const code = this.requireCodeArg(args, 'understand_code');
-        if (!code) {
-            return asJsonResponse({
-                success: false,
-                error: 'code is required and must be a non-empty string',
-            });
-        }
-        const result = await this.analyzer.understand({
-            code,
-            context: args.context,
-            focus: args.focus || 'all',
-        });
-        return asJsonResponse(result);
-    }
-    async handleDetectCrypto(args) {
-        const code = this.requireCodeArg(args, 'detect_crypto');
-        if (!code) {
-            return asJsonResponse({
-                success: false,
-                error: 'code is required and must be a non-empty string',
-            });
-        }
-        const result = await this.cryptoDetector.detect({
-            code,
-        });
-        return asJsonResponse(result);
-    }
-    async handleManageHooks(args) {
-        const action = 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,
-                });
-                return asJsonResponse(result);
-            }
-            case 'list':
-                return asJsonResponse({ hooks: this.hookManager.getAllHooks() });
-            case 'records':
-                return asJsonResponse({
-                    records: this.hookManager.getHookRecords(args.hookId),
-                });
-            case 'clear':
-                this.hookManager.clearHookRecords(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` });
-        }
-    }
-    async handleDetectObfuscation(args) {
-        const code = this.requireCodeArg(args, 'detect_obfuscation');
-        if (!code) {
-            return asJsonResponse({
-                success: false,
-                error: 'code is required and must be a non-empty string',
-            });
-        }
-        const generateReport = args.generateReport ?? true;
-        const result = this.obfuscationDetector.detect(code);
-        if (!generateReport) {
-            return asJsonResponse(result);
-        }
-        const report = this.obfuscationDetector.generateReport(result);
-        return asTextResponse(`${JSON.stringify(result, null, 2)}\n\n${report}`);
-    }
-    async handleAdvancedDeobfuscate(args) {
-        const code = this.requireCodeArg(args, 'advanced_deobfuscate');
-        if (!code) {
-            return asJsonResponse({
-                success: false,
-                error: 'code is required and must be a non-empty string',
-            });
-        }
-        const detectOnly = args.detectOnly ?? false;
-        const aggressiveVM = args.aggressiveVM ?? false;
-        const useASTOptimization = args.useASTOptimization ?? true;
-        const timeout = args.timeout ?? 60000;
-        const result = await this.advancedDeobfuscator.deobfuscate({
-            code,
-            detectOnly,
-            aggressiveVM,
-            timeout,
-        });
-        let finalCode = result.code;
-        if (useASTOptimization && !detectOnly) {
-            finalCode = this.astOptimizer.optimize(finalCode);
-        }
-        return asJsonResponse({
-            ...result,
-            code: finalCode,
-            astOptimized: useASTOptimization && !detectOnly,
-        });
-    }
-    async handleWebpackEnumerate(args) {
-        return runWebpackEnumerate(this.collector, args);
-    }
-    async handleSourceMapExtract(args) {
-        return runSourceMapExtract(this.collector, args);
-    }
-    async handleClearCollectedData() {
-        try {
-            await this.collector.clearAllData();
-            this.scriptManager.clear();
-            return asJsonResponse({
-                success: true,
-                message: 'All collected data cleared.',
-                cleared: {
-                    fileCache: true,
-                    compressionCache: true,
-                    collectedUrls: true,
-                    scriptManager: true,
-                },
-            });
-        }
-        catch (error) {
-            logger.error('Failed to clear collected data:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-    async handleGetCollectionStats() {
-        try {
-            const stats = await this.collector.getAllStats();
-            return asJsonResponse({
-                success: true,
-                stats,
-                summary: {
-                    totalCachedFiles: stats.cache.memoryEntries + stats.cache.diskEntries,
-                    totalCacheSize: `${(stats.cache.totalSize / 1024).toFixed(2)} KB`,
-                    compressionRatio: `${stats.compression.averageRatio.toFixed(1)}%`,
-                    cacheHitRate: stats.compression.cacheHits > 0
-                        ? `${((stats.compression.cacheHits /
-                            (stats.compression.cacheHits + stats.compression.cacheMisses)) *
-                            100).toFixed(1)}%`
-                        : '0%',
-                    collectedUrls: stats.collector.collectedUrls,
-                },
-            });
-        }
-        catch (error) {
-            logger.error('Failed to get collection stats:', error);
-            return asJsonResponse(serializeError(error));
-        }
-    }
-}

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

@@ -1,69 +0,0 @@
-import { bindByDepKey, ensureBrowserCore, toolLookup } from '../../domains/shared/registry.js';
-import { coreTools } from '../../domains/analysis/definitions.js';
-import { CoreAnalysisHandlers } from '../../domains/analysis/index.js';
-import { Deobfuscator } from '../../domains/shared/modules.js';
-import { AdvancedDeobfuscator } from '../../domains/shared/modules.js';
-import { ASTOptimizer } 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';
-const DOMAIN = 'core';
-const DEP_KEY = 'coreAnalysisHandlers';
-const t = toolLookup(coreTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    ensureBrowserCore(ctx);
-    if (!ctx.deobfuscator)
-        ctx.deobfuscator = new Deobfuscator(ctx.llm);
-    if (!ctx.advancedDeobfuscator)
-        ctx.advancedDeobfuscator = new AdvancedDeobfuscator(ctx.llm);
-    if (!ctx.astOptimizer)
-        ctx.astOptimizer = new ASTOptimizer();
-    if (!ctx.obfuscationDetector)
-        ctx.obfuscationDetector = new ObfuscationDetector();
-    if (!ctx.analyzer)
-        ctx.analyzer = new CodeAnalyzer(ctx.llm);
-    if (!ctx.cryptoDetector)
-        ctx.cryptoDetector = new CryptoDetector(ctx.llm);
-    if (!ctx.hookManager)
-        ctx.hookManager = new HookManager();
-    if (!ctx.coreAnalysisHandlers) {
-        ctx.coreAnalysisHandlers = new CoreAnalysisHandlers({
-            collector: ctx.collector,
-            scriptManager: ctx.scriptManager,
-            deobfuscator: ctx.deobfuscator,
-            advancedDeobfuscator: ctx.advancedDeobfuscator,
-            astOptimizer: ctx.astOptimizer,
-            obfuscationDetector: ctx.obfuscationDetector,
-            analyzer: ctx.analyzer,
-            cryptoDetector: ctx.cryptoDetector,
-            hookManager: ctx.hookManager,
-        });
-    }
-    return ctx.coreAnalysisHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    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('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('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;

package/dist/server/domains/browser/definitions.tools.behavior.js

@@ -1,132 +0,0 @@
-export const behaviorTools = [
-    {
-        name: 'human_mouse',
-        description: 'Move the mouse along a natural Bezier curve path with random jitter.\n\n' +
-            'Simulates human-like mouse movement using cubic Bezier curves with:\n' +
-            '- Non-linear speed (ease-in-out)\n' +
-            '- Configurable jitter/noise\n' +
-            '- Viewport-clamped trajectory\n\n' +
-            'Use this before page_click for anti-bot bypass (e.g. Cloudflare, Turnstile).\n\n' +
-            'Example:\n' +
-            '  human_mouse({ toX: 500, toY: 300, durationMs: 800 })',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                fromX: { type: 'number', description: 'Start X coordinate (default: current mouse position or 0)' },
-                fromY: { type: 'number', description: 'Start Y coordinate (default: current mouse position or 0)' },
-                toX: { type: 'number', description: 'Target X coordinate' },
-                toY: { type: 'number', description: 'Target Y coordinate' },
-                selector: { type: 'string', description: 'CSS selector to move to (alternative to toX/toY — auto-resolves element center)' },
-                durationMs: { type: 'number', description: 'Movement duration in ms (default: 600)', default: 600 },
-                steps: { type: 'integer', description: 'Number of intermediate points (default: 24)', default: 24 },
-                jitterPx: { type: 'number', description: 'Max random offset per step in pixels (default: 1.5)', default: 1.5 },
-                curve: { type: 'string', enum: ['ease', 'linear', 'ease-in', 'ease-out'], description: 'Speed curve (default: ease)', default: 'ease' },
-                click: { type: 'boolean', description: 'Click at destination after movement (default: false)', default: false },
-            },
-        },
-    },
-    {
-        name: 'human_scroll',
-        description: 'Scroll the page with human-like behavior: variable speed, micro-pauses, and deceleration.\n\n' +
-            'Simulates natural scrolling patterns:\n' +
-            '- Segmented scroll with random segment sizes\n' +
-            '- Brief pauses between segments\n' +
-            '- Velocity deceleration near the end\n\n' +
-            'Example:\n' +
-            '  human_scroll({ distance: 1000, direction: "down", durationMs: 2000 })',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                distance: { type: 'number', description: 'Total scroll distance in pixels (default: 500)', default: 500 },
-                direction: { type: 'string', enum: ['up', 'down', 'left', 'right'], description: 'Scroll direction (default: down)', default: 'down' },
-                durationMs: { type: 'number', description: 'Total scroll duration in ms (default: 1500)', default: 1500 },
-                segments: { type: 'integer', description: 'Number of scroll segments (default: 8)', default: 8 },
-                pauseMs: { type: 'number', description: 'Average pause between segments in ms (default: 80)', default: 80 },
-                jitter: { type: 'number', description: 'Random variation factor 0-1 (default: 0.3)', default: 0.3 },
-                selector: { type: 'string', description: 'CSS selector of scrollable container (default: window)' },
-            },
-        },
-    },
-    {
-        name: 'human_typing',
-        description: 'Type text with human-like patterns: variable speed, occasional typos, and natural corrections.\n\n' +
-            'Features:\n' +
-            '- Per-character random delay based on WPM\n' +
-            '- Configurable typo rate with auto-correction (backspace + retype)\n' +
-            '- Word boundary pauses\n' +
-            '- Shift key simulation for uppercase\n\n' +
-            'Use this instead of page_type for anti-bot bypass.\n\n' +
-            'Example:\n' +
-            '  human_typing({ selector: "#email", text: "user@example.com", wpm: 80 })',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', description: 'CSS selector of the input field' },
-                text: { type: 'string', description: 'Text to type' },
-                wpm: { type: 'integer', description: 'Words per minute (default: 90)', default: 90 },
-                errorRate: { type: 'number', description: 'Probability of typo per character 0-0.2 (default: 0.02)', default: 0.02 },
-                correctDelayMs: { type: 'number', description: 'Delay before correcting a typo in ms (default: 200)', default: 200 },
-                clearFirst: { type: 'boolean', description: 'Clear existing value before typing (default: false)', default: false },
-            },
-            required: ['selector', 'text'],
-        },
-    },
-    {
-        name: 'captcha_vision_solve',
-        description: 'Attempt to solve a CAPTCHA using an external solving service or AI vision.\n\n' +
-            'Supports multiple providers through a provider-agnostic interface:\n' +
-            '- `2captcha` / `anticaptcha` / `capsolver` — external solving services\n' +
-            '- `manual` — wait for user to solve manually (fallback)\n\n' +
-            'Automatically detects CAPTCHA type (image, reCAPTCHA, hCaptcha) if typeHint is not provided.\n\n' +
-            'Example:\n' +
-            '  captcha_vision_solve({ provider: "2captcha", apiKey: "..." })',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                provider: {
-                    type: 'string',
-                    enum: ['2captcha', 'anticaptcha', 'capsolver', 'manual'],
-                    description: 'Solving service provider (default: from config or "manual")',
-                },
-                apiKey: { type: 'string', description: 'Provider API key (default: from CAPTCHA_API_KEY env)' },
-                typeHint: {
-                    type: 'string',
-                    enum: ['image', 'recaptcha_v2', 'recaptcha_v3', 'hcaptcha', 'funcaptcha', 'turnstile', 'auto'],
-                    description: 'CAPTCHA type hint (default: auto-detect)',
-                    default: 'auto',
-                },
-                siteKey: { type: 'string', description: 'Site key for reCAPTCHA/hCaptcha/Turnstile (auto-extracted if omitted)' },
-                pageUrl: { type: 'string', description: 'Page URL for context (auto-detected if omitted)' },
-                timeoutMs: { type: 'number', description: 'Max solve time in ms (default: 180000)', default: 180000 },
-                maxRetries: { type: 'integer', description: 'Max retry attempts (default: 2)', default: 2 },
-            },
-        },
-    },
-    {
-        name: 'turnstile_solve',
-        description: 'Solve a Cloudflare Turnstile challenge specifically.\n\n' +
-            'Strategy:\n' +
-            '1. Detect Turnstile widget and extract siteKey\n' +
-            '2. Send to solving service (or hook window.cf to extract token)\n' +
-            '3. Inject solved token back into the page\n' +
-            '4. Trigger callback to proceed\n\n' +
-            'Requires either an external solver API key or uses the built-in hook approach.\n\n' +
-            'Example:\n' +
-            '  turnstile_solve({ provider: "capsolver" })',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                siteKey: { type: 'string', description: 'Turnstile site key (auto-detected if omitted)' },
-                pageUrl: { type: 'string', description: 'Page URL (auto-detected if omitted)' },
-                provider: {
-                    type: 'string',
-                    enum: ['2captcha', 'anticaptcha', 'capsolver', 'hook', 'manual'],
-                    description: 'Solving method (default: from config or "manual")',
-                },
-                apiKey: { type: 'string', description: 'Provider API key' },
-                timeoutMs: { type: 'number', description: 'Max solve time in ms (default: 120000)', default: 120000 },
-                injectToken: { type: 'boolean', description: 'Auto-inject solved token into page (default: true)', default: true },
-            },
-        },
-    },
-];