@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/index.js

@@ -1,139 +1,2 @@
 #!/usr/bin/env node
-import { MCPServer } from './server/MCPServer.js';
-import { getConfig, validateConfig } from './utils/config.js';
-import { logger } from './utils/logger.js';
-import { initRegistry } from './server/registry/index.js';
-import { resolveCliFastPath } from './utils/cliFastPath.js';
-import { cleanupArtifacts, getArtifactRetentionConfig, startArtifactRetentionScheduler } from './utils/artifactRetention.js';
-const FATAL_ERROR_CODES = new Set([
-    'ERR_WORKER_OUT_OF_MEMORY',
-    'ERR_MEMORY_ALLOCATION_FAILED',
-]);
-const FATAL_ERRNO_CODES = new Set([
-    'ENOMEM',
-    'ENOSPC',
-    'EMFILE',
-    'ENFILE',
-]);
-function isFatalError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const appErr = error;
-    if (appErr.code && FATAL_ERROR_CODES.has(appErr.code))
-        return true;
-    if (appErr.code && FATAL_ERRNO_CODES.has(appErr.code))
-        return true;
-    if (error instanceof RangeError && error.message.includes('allocation'))
-        return true;
-    return false;
-}
-function formatUnknownError(input) {
-    if (input instanceof Error) {
-        return `${input.name}: ${input.message}`;
-    }
-    try {
-        return typeof input === 'string' ? input : JSON.stringify(input);
-    }
-    catch {
-        return String(input);
-    }
-}
-async function main() {
-    try {
-        const config = getConfig();
-        logger.debug('Configuration loaded:', config);
-        const validation = validateConfig(config);
-        if (!validation.valid) {
-            logger.error('Configuration validation failed:');
-            validation.errors.forEach((error) => logger.error(`  - ${error}`));
-            process.exit(1);
-        }
-        if (config.llm.provider === 'openai' && !config.llm.openai?.apiKey) {
-            logger.warn('OPENAI_API_KEY is not configured. AI-assisted tools may return configuration errors.');
-        }
-        if (config.llm.provider === 'anthropic' && !config.llm.anthropic?.apiKey) {
-            logger.warn('ANTHROPIC_API_KEY is not configured. AI-assisted tools may return configuration errors.');
-        }
-        const artifactRetention = getArtifactRetentionConfig();
-        if (artifactRetention.cleanupOnStart && artifactRetention.enabled) {
-            const cleanup = await cleanupArtifacts();
-            if (cleanup.removedFiles > 0) {
-                logger.info(`[artifacts] Startup cleanup removed ${cleanup.removedFiles} files (${cleanup.removedBytes} bytes)`);
-            }
-        }
-        logger.info('Creating MCP server instance...');
-        await initRegistry();
-        const server = new MCPServer(config);
-        const stopArtifactRetentionScheduler = startArtifactRetentionScheduler();
-        const recoveryWindowMs = Math.max(1000, parseInt(process.env.RUNTIME_ERROR_WINDOW_MS ?? '60000', 10));
-        const maxRecoverableErrors = Math.max(1, parseInt(process.env.RUNTIME_ERROR_THRESHOLD ?? '5', 10));
-        const runtimeRecovery = {
-            windowStart: Date.now(),
-            errorCount: 0,
-            degradedMode: false,
-        };
-        const handleRuntimeFailure = (kind, reason) => {
-            if (isFatalError(reason)) {
-                logger.error(`[${kind}] FATAL unrecoverable error — forcing exit: ${formatUnknownError(reason)}`);
-                process.exit(1);
-            }
-            const now = Date.now();
-            if (now - runtimeRecovery.windowStart > recoveryWindowMs) {
-                runtimeRecovery.windowStart = now;
-                runtimeRecovery.errorCount = 0;
-            }
-            runtimeRecovery.errorCount += 1;
-            logger.error(`[${kind}] Runtime failure captured (${runtimeRecovery.errorCount}/${maxRecoverableErrors}): ${formatUnknownError(reason)}`);
-            if (!runtimeRecovery.degradedMode && runtimeRecovery.errorCount >= maxRecoverableErrors) {
-                runtimeRecovery.degradedMode = true;
-                server.enterDegradedMode(`Runtime failures reached ${runtimeRecovery.errorCount} within ${recoveryWindowMs}ms`);
-                logger.warn('Degraded mode enabled. Server keeps running without forced process exit.');
-            }
-        };
-        process.on('SIGINT', async () => {
-            logger.info('Received SIGINT, shutting down...');
-            stopArtifactRetentionScheduler?.();
-            await server.close();
-            process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            logger.info('Received SIGTERM, shutting down...');
-            stopArtifactRetentionScheduler?.();
-            await server.close();
-            process.exit(0);
-        });
-        process.on('uncaughtException', (error) => {
-            handleRuntimeFailure('uncaughtException', error);
-        });
-        process.on('unhandledRejection', (reason) => {
-            handleRuntimeFailure('unhandledRejection', reason);
-        });
-        logger.info('Starting MCP server...');
-        await server.start();
-        logger.info('MCP server started successfully');
-        logger.info('MCP server is running. Press Ctrl+C to stop.');
-    }
-    catch (error) {
-        logger.error('Failed to start MCP server:');
-        const appError = error;
-        logger.error('Error name:', appError.name);
-        logger.error('Error message:', appError.message);
-        logger.error('Error stack:', appError.stack);
-        logger.error('Full error object:', JSON.stringify(error, null, 2));
-        if (appError.code === 'EADDRINUSE') {
-            logger.error('Port is already in use. Please check if another instance is running.');
-        }
-        if (appError.message?.includes('credentials')) {
-            logger.error('Authentication failed. Please check your API keys or credentials.');
-        }
-        process.exit(1);
-    }
-}
-const cliFastPath = resolveCliFastPath(process.argv.slice(2), import.meta.url);
-if (cliFastPath.handled) {
-    if (cliFastPath.output) {
-        process.stdout.write(cliFastPath.output);
-    }
-    process.exit(cliFastPath.exitCode);
-}
-main();
+export * from './src/index.js';

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

@@ -0,0 +1,89 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export type ToolProfileId = 'search' | 'workflow' | 'full';
+export type ToolArgs = Record<string, unknown>;
+export type ToolResponse = CallToolResult;
+export type PluginState = 'loaded' | 'validated' | 'registered' | 'activated' | 'deactivated' | 'unloaded';
+export interface PluginLifecycleContext {
+    readonly pluginId: string;
+    readonly pluginRoot: string;
+    readonly config: Record<string, unknown>;
+    readonly state: PluginState;
+    registerMetric(metricName: string): void;
+    invokeTool(name: string, args?: ToolArgs): Promise<ToolResponse>;
+    hasPermission(capability: string): boolean;
+    getConfig<T = unknown>(path: string, fallback?: T): T;
+    setRuntimeData(key: string, value: unknown): void;
+    getRuntimeData<T = unknown>(key: string): T | undefined;
+}
+export type ExtensionToolHandler = (args: ToolArgs, ctx: PluginLifecycleContext) => Promise<ToolResponse>;
+export interface ExtensionToolDefinition {
+    name: string;
+    description: string;
+    schema: Record<string, unknown>;
+    handler: ExtensionToolHandler;
+}
+export declare class ExtensionBuilder {
+    _id: string;
+    _version: string;
+    constructor(id: string, version: string);
+    get id(): string;
+    get version(): string;
+    _name: string;
+    _description: string;
+    _compatibleCore: string;
+    _tools: ExtensionToolDefinition[];
+    _allowCommands: string[];
+    _allowHosts: string[];
+    _allowTools: string[];
+    _metrics: string[];
+    _configDefaults: Record<string, unknown>;
+    _onLoadHandler?: (ctx: PluginLifecycleContext) => Promise<void> | void;
+    _onValidateHandler?: (ctx: PluginLifecycleContext) => Promise<{
+        valid: boolean;
+        errors: string[];
+    }> | {
+        valid: boolean;
+        errors: string[];
+    };
+    _onActivateHandler?: (ctx: PluginLifecycleContext) => Promise<void> | void;
+    _onDeactivateHandler?: (ctx: PluginLifecycleContext) => Promise<void> | void;
+    get getName(): string;
+    get getDescription(): string;
+    get getCompatibleCore(): string;
+    get tools(): ExtensionToolDefinition[];
+    get allowCommands(): string[];
+    get allowHosts(): string[];
+    get allowTools(): string[];
+    get metrics(): string[];
+    get configDefaults(): Record<string, unknown>;
+    get onLoadHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+    get onValidateHandler(): ((ctx: PluginLifecycleContext) => Promise<{
+        valid: boolean;
+        errors: string[];
+    }> | {
+        valid: boolean;
+        errors: string[];
+    }) | undefined;
+    get onActivateHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+    get onDeactivateHandler(): ((ctx: PluginLifecycleContext) => Promise<void> | void) | undefined;
+    name(name: string): this;
+    description(desc: string): this;
+    compatibleCore(range: string): this;
+    allowCommand(cmd: string | string[]): this;
+    allowHost(host: string | string[]): this;
+    allowTool(tool: string | string[]): this;
+    metric(m: string | string[]): this;
+    configDefault(key: string, value: unknown): this;
+    tool(name: string, desc: string, schema: Record<string, unknown>, handler: ExtensionToolHandler): this;
+    onLoad(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+    onValidate(h: (ctx: PluginLifecycleContext) => Promise<{
+        valid: boolean;
+        errors: string[];
+    }> | {
+        valid: boolean;
+        errors: string[];
+    }): this;
+    onActivate(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+    onDeactivate(h: (ctx: PluginLifecycleContext) => Promise<void> | void): this;
+}
+export declare function createExtension(id: string, version: string): ExtensionBuilder;

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

@@ -0,0 +1,55 @@
+export class ExtensionBuilder {
+    _id;
+    _version;
+    constructor(id, version) {
+        this._id = id;
+        this._version = version;
+    }
+    get id() { return this._id; }
+    get version() { return this._version; }
+    _name = '';
+    _description = '';
+    _compatibleCore = '>=0.1.0';
+    _tools = [];
+    _allowCommands = [];
+    _allowHosts = [];
+    _allowTools = [];
+    _metrics = [];
+    _configDefaults = {};
+    _onLoadHandler;
+    _onValidateHandler;
+    _onActivateHandler;
+    _onDeactivateHandler;
+    get getName() { return this._name; }
+    get getDescription() { return this._description; }
+    get getCompatibleCore() { return this._compatibleCore; }
+    get tools() { return this._tools; }
+    get allowCommands() { return this._allowCommands; }
+    get allowHosts() { return this._allowHosts; }
+    get allowTools() { return this._allowTools; }
+    get metrics() { return this._metrics; }
+    get configDefaults() { return this._configDefaults; }
+    get onLoadHandler() { return this._onLoadHandler; }
+    get onValidateHandler() { return this._onValidateHandler; }
+    get onActivateHandler() { return this._onActivateHandler; }
+    get onDeactivateHandler() { return this._onDeactivateHandler; }
+    name(name) { this._name = name; return this; }
+    description(desc) { this._description = desc; return this; }
+    compatibleCore(range) { this._compatibleCore = range; return this; }
+    allowCommand(cmd) { this._allowCommands.push(...(Array.isArray(cmd) ? cmd : [cmd])); return this; }
+    allowHost(host) { this._allowHosts.push(...(Array.isArray(host) ? host : [host])); return this; }
+    allowTool(tool) { this._allowTools.push(...(Array.isArray(tool) ? tool : [tool])); return this; }
+    metric(m) { this._metrics.push(...(Array.isArray(m) ? m : [m])); return this; }
+    configDefault(key, value) { this._configDefaults[key] = value; return this; }
+    tool(name, desc, schema, handler) {
+        this._tools.push({ name, description: desc, schema: { type: 'object', properties: schema }, handler });
+        return this;
+    }
+    onLoad(h) { this._onLoadHandler = h; return this; }
+    onValidate(h) { this._onValidateHandler = h; return this; }
+    onActivate(h) { this._onActivateHandler = h; return this; }
+    onDeactivate(h) { this._onDeactivateHandler = h; return this; }
+}
+export function createExtension(id, version) {
+    return new ExtensionBuilder(id, version);
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,127 @@
+export declare const DEBUG_PORT_CANDIDATES: number[];
+export declare const DEFAULT_DEBUG_PORT: number;
+export declare const GHIDRA_BRIDGE_ENDPOINT: string;
+export declare const IDA_BRIDGE_ENDPOINT: string;
+export declare const CAPTCHA_SOLVER_BASE_URL: string;
+export declare const EXTENSION_REGISTRY_BASE_URL: string;
+export declare const MCP_HTTP_REQUEST_TIMEOUT_MS: number;
+export declare const MCP_HTTP_HEADERS_TIMEOUT_MS: number;
+export declare const MCP_HTTP_KEEPALIVE_TIMEOUT_MS: number;
+export declare const MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS: number;
+export declare const EXTERNAL_TOOL_TIMEOUT_MS: number;
+export declare const EXTERNAL_TOOL_PROBE_TIMEOUT_MS: number;
+export declare const EXTERNAL_TOOL_PROBE_CACHE_TTL_MS: number;
+export declare const EXTERNAL_TOOL_FORCE_KILL_GRACE_MS: number;
+export declare const SANDBOX_EXEC_TIMEOUT_MS: number;
+export declare const SANDBOX_MEMORY_LIMIT_MB: number;
+export declare const SANDBOX_STACK_SIZE_MB: number;
+export declare const SANDBOX_TERMINATE_GRACE_MS: number;
+export declare const SYMBOLIC_EXEC_MAX_PATHS: number;
+export declare const SYMBOLIC_EXEC_MAX_DEPTH: number;
+export declare const SYMBOLIC_EXEC_TIMEOUT_MS: number;
+export declare const JSVMP_DEOBFUSCATE_TIMEOUT_MS: number;
+export declare const JSVMP_MAX_ITERATIONS: number;
+export declare const JSVMP_SYMBOLIC_MAX_STEPS: number;
+export declare const JSVMP_SYMBOLIC_TIMEOUT_MS: number;
+export declare const DEBUGGER_WAIT_FOR_PAUSED_TIMEOUT_MS: number;
+export declare const WATCH_EVAL_TIMEOUT_MS: number;
+export declare const TRANSFORM_WORKER_TIMEOUT_MS: number;
+export declare const TRANSFORM_VM_SCRIPT_TIMEOUT_MS: number;
+export declare const TRANSFORM_CRYPTO_POOL_MAX_WORKERS: number;
+export declare const TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: number;
+export declare const TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: number;
+export declare const TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: number;
+export declare const EMULATOR_FETCH_GOTO_TIMEOUT_MS: number;
+export declare const WASM_TOOL_TIMEOUT_MS: number;
+export declare const WASM_OFFLINE_RUN_TIMEOUT_MS: number;
+export declare const WASM_OPTIMIZE_TIMEOUT_MS: number;
+export declare const MINIAPP_UNPACK_TIMEOUT_MS: number;
+export declare const CAPTCHA_SUBMIT_TIMEOUT_MS: number;
+export declare const CAPTCHA_POLL_INTERVAL_MS: number;
+export declare const CAPTCHA_RESULT_TIMEOUT_MS: number;
+export declare const CAPTCHA_DEFAULT_TIMEOUT_MS: number;
+export declare const CAPTCHA_MIN_TIMEOUT_MS: number;
+export declare const CAPTCHA_MAX_TIMEOUT_MS: number;
+export declare const CAPTCHA_MAX_RETRIES: number;
+export declare const CAPTCHA_DEFAULT_RETRIES: number;
+export declare const NETWORK_REPLAY_TIMEOUT_MS: number;
+export declare const NETWORK_REPLAY_MAX_BODY_BYTES: number;
+export declare const NETWORK_REPLAY_MAX_REDIRECTS: number;
+export declare const NETWORK_HAR_BODY_CONCURRENCY: number;
+export declare const WORKFLOW_BATCH_MAX_RETRIES: number;
+export declare const WORKFLOW_BATCH_MAX_BACKOFF_MS: number;
+export declare const WORKFLOW_BATCH_MAX_TIMEOUT_MS: number;
+export declare const WORKFLOW_BATCH_RETRY_BACKOFF_MS: number;
+export declare const WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS: number;
+export declare const WORKFLOW_JS_BUNDLE_MAX_SIZE_BYTES: number;
+export declare const WORKFLOW_JS_BUNDLE_MAX_REDIRECTS: number;
+export declare const WORKFLOW_JS_BUNDLE_FETCH_TIMEOUT_MS: number;
+export declare const WORKFLOW_BUNDLE_CACHE_TTL_MS: number;
+export declare const WORKFLOW_BUNDLE_CACHE_MAX_BYTES: number;
+export declare const SEARCH_WORKFLOW_BOOST_TIERS: Set<string>;
+export declare const SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: number;
+export type SearchIntentToolBoostRuleConfig = {
+    pattern: string;
+    flags?: string;
+    boosts: Array<{
+        tool: string;
+        bonus: number;
+    }>;
+};
+export declare const SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE: SearchIntentToolBoostRuleConfig[] | null;
+export declare const DYNAMIC_BOOST_ENABLED: boolean;
+export type DynamicBoostStrategy = 'max' | 'top1' | 'majority' | 'weighted';
+export declare const DYNAMIC_BOOST_STRATEGY: DynamicBoostStrategy;
+export declare const DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL: boolean;
+export declare const DYNAMIC_BOOST_MAX_JUMP: number;
+export declare const DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST: boolean;
+export declare const SEARCH_TFIDF_COSINE_WEIGHT: number;
+export declare const SEARCH_AFFINITY_BOOST_FACTOR: number;
+export declare const SEARCH_AFFINITY_TOP_N: number;
+export declare const SEARCH_DOMAIN_HUB_THRESHOLD: number;
+export declare const SEARCH_QUERY_CACHE_CAPACITY: number;
+export declare const EXTENSION_GIT_CLONE_TIMEOUT_MS: number;
+export declare const EXTENSION_GIT_CHECKOUT_TIMEOUT_MS: number;
+export declare const PROCESS_LIST_MAX_BUFFER_BYTES: number;
+export declare const EXTERNAL_TOOL_MAX_STDOUT_BYTES: number;
+export declare const EXTERNAL_TOOL_MAX_STDERR_BYTES: number;
+export declare const WORKER_POOL_MIN_WORKERS: number;
+export declare const WORKER_POOL_MAX_WORKERS: number;
+export declare const WORKER_POOL_IDLE_TIMEOUT_MS: number;
+export declare const WORKER_POOL_JOB_TIMEOUT_MS: number;
+export declare const PARALLEL_DEFAULT_CONCURRENCY: number;
+export declare const PARALLEL_DEFAULT_TIMEOUT_MS: number;
+export declare const PARALLEL_DEFAULT_MAX_RETRIES: number;
+export declare const PARALLEL_RETRY_BACKOFF_BASE_MS: number;
+export declare const CACHE_GLOBAL_MAX_SIZE_BYTES: number;
+export declare const CACHE_LOW_HIT_RATE_THRESHOLD: number;
+export declare const TOKEN_BUDGET_MAX_TOKENS: number;
+export declare const DETAILED_DATA_DEFAULT_TTL_MS: number;
+export declare const DETAILED_DATA_MAX_TTL_MS: number;
+export declare const DETAILED_DATA_SMART_THRESHOLD_BYTES: number;
+export declare const ADV_DEOBF_LLM_MAX_TOKENS: number;
+export declare const VM_DEOBF_LLM_MAX_TOKENS: number;
+export declare const DEOBF_LLM_MAX_TOKENS: number;
+export declare const CRYPTO_DETECT_LLM_MAX_TOKENS: number;
+export declare const MEMORY_READ_TIMEOUT_MS: number;
+export declare const MEMORY_MAX_READ_BYTES: number;
+export declare const MEMORY_WRITE_TIMEOUT_MS: number;
+export declare const MEMORY_MAX_WRITE_BYTES: number;
+export declare const MEMORY_DUMP_TIMEOUT_MS: number;
+export declare const MEMORY_SCAN_TIMEOUT_MS: number;
+export declare const MEMORY_SCAN_MAX_BUFFER_BYTES: number;
+export declare const MEMORY_SCAN_MAX_RESULTS: number;
+export declare const MEMORY_SCAN_MAX_REGIONS: number;
+export declare const MEMORY_SCAN_REGION_MAX_BYTES: number;
+export declare const MEMORY_INJECT_TIMEOUT_MS: number;
+export declare const ENABLE_INJECTION_TOOLS: boolean;
+export declare const MEMORY_MONITOR_INTERVAL_MS: number;
+export declare const MEMORY_VMMAP_TIMEOUT_MS: number;
+export declare const MEMORY_PROTECTION_QUERY_TIMEOUT_MS: number;
+export declare const MEMORY_PROTECTION_PWSH_TIMEOUT_MS: number;
+export declare const NATIVE_ADMIN_CHECK_TIMEOUT_MS: number;
+export declare const NATIVE_SCAN_MAX_RESULTS: number;
+export declare const PROCESS_LAUNCH_WAIT_MS: number;
+export declare const WIN_DEBUG_PORT_POLL_ATTEMPTS: number;
+export declare const WIN_DEBUG_PORT_POLL_INTERVAL_MS: number;
+export declare const PACKER_SANDBOX_TIMEOUT_MS: number;

package/dist/src/constants.js

@@ -0,0 +1,173 @@
+const int = (key, fallback) => {
+    const v = process.env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+};
+const float = (key, fallback) => {
+    const v = process.env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : fallback;
+};
+const bool = (key, fallback) => {
+    const v = process.env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const normalized = v.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1')
+        return true;
+    if (normalized === 'false' || normalized === '0')
+        return false;
+    return fallback;
+};
+const str = (key, fallback) => process.env[key] || fallback;
+const list = (key, fallback) => {
+    const v = process.env[key];
+    if (!v)
+        return fallback;
+    return v.split(',').map(Number).filter(Number.isFinite);
+};
+const csv = (key, fallback) => {
+    const v = process.env[key];
+    if (!v)
+        return fallback;
+    const parsed = v
+        .split(',')
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean);
+    return parsed.length > 0 ? parsed : fallback;
+};
+const json = (key, fallback) => {
+    const v = process.env[key];
+    if (!v)
+        return fallback;
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return fallback;
+    }
+};
+export const DEBUG_PORT_CANDIDATES = list('DEBUG_PORT_CANDIDATES', [9222, 9229, 9333, 2039]);
+export const DEFAULT_DEBUG_PORT = int('DEFAULT_DEBUG_PORT', 9222);
+export const GHIDRA_BRIDGE_ENDPOINT = str('GHIDRA_BRIDGE_URL', 'http://127.0.0.1:18080');
+export const IDA_BRIDGE_ENDPOINT = str('IDA_BRIDGE_URL', 'http://127.0.0.1:18081');
+export const CAPTCHA_SOLVER_BASE_URL = process.env.CAPTCHA_SOLVER_BASE_URL?.trim() ||
+    process.env.CAPTCHA_2CAPTCHA_BASE_URL?.trim() ||
+    '';
+export const EXTENSION_REGISTRY_BASE_URL = process.env.EXTENSION_REGISTRY_BASE_URL?.trim() || '';
+export const MCP_HTTP_REQUEST_TIMEOUT_MS = int('MCP_HTTP_REQUEST_TIMEOUT_MS', 30_000);
+export const MCP_HTTP_HEADERS_TIMEOUT_MS = int('MCP_HTTP_HEADERS_TIMEOUT_MS', 10_000);
+export const MCP_HTTP_KEEPALIVE_TIMEOUT_MS = int('MCP_HTTP_KEEPALIVE_TIMEOUT_MS', 60_000);
+export const MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS = int('MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS', 5_000);
+export const EXTERNAL_TOOL_TIMEOUT_MS = int('EXTERNAL_TOOL_TIMEOUT_MS', 30_000);
+export const EXTERNAL_TOOL_PROBE_TIMEOUT_MS = int('EXTERNAL_TOOL_PROBE_TIMEOUT_MS', 5_000);
+export const EXTERNAL_TOOL_PROBE_CACHE_TTL_MS = int('EXTERNAL_TOOL_PROBE_CACHE_TTL_MS', 60_000);
+export const EXTERNAL_TOOL_FORCE_KILL_GRACE_MS = int('EXTERNAL_TOOL_FORCE_KILL_GRACE_MS', 2_000);
+export const SANDBOX_EXEC_TIMEOUT_MS = int('SANDBOX_EXEC_TIMEOUT_MS', 5_000);
+export const SANDBOX_MEMORY_LIMIT_MB = int('SANDBOX_MEMORY_LIMIT_MB', 128);
+export const SANDBOX_STACK_SIZE_MB = int('SANDBOX_STACK_SIZE_MB', 4);
+export const SANDBOX_TERMINATE_GRACE_MS = int('SANDBOX_TERMINATE_GRACE_MS', 2_000);
+export const SYMBOLIC_EXEC_MAX_PATHS = int('SYMBOLIC_EXEC_MAX_PATHS', 100);
+export const SYMBOLIC_EXEC_MAX_DEPTH = int('SYMBOLIC_EXEC_MAX_DEPTH', 50);
+export const SYMBOLIC_EXEC_TIMEOUT_MS = int('SYMBOLIC_EXEC_TIMEOUT_MS', 30_000);
+export const JSVMP_DEOBFUSCATE_TIMEOUT_MS = int('JSVMP_DEOBFUSCATE_TIMEOUT_MS', 30_000);
+export const JSVMP_MAX_ITERATIONS = int('JSVMP_MAX_ITERATIONS', 100);
+export const JSVMP_SYMBOLIC_MAX_STEPS = int('JSVMP_SYMBOLIC_MAX_STEPS', 1_000);
+export const JSVMP_SYMBOLIC_TIMEOUT_MS = int('JSVMP_SYMBOLIC_TIMEOUT_MS', 30_000);
+export const DEBUGGER_WAIT_FOR_PAUSED_TIMEOUT_MS = int('DEBUGGER_WAIT_FOR_PAUSED_TIMEOUT_MS', 30_000);
+export const WATCH_EVAL_TIMEOUT_MS = int('WATCH_EVAL_TIMEOUT_MS', 5_000);
+export const TRANSFORM_WORKER_TIMEOUT_MS = int('TRANSFORM_WORKER_TIMEOUT_MS', 15_000);
+export const TRANSFORM_VM_SCRIPT_TIMEOUT_MS = int('TRANSFORM_VM_SCRIPT_TIMEOUT_MS', 5_000);
+export const TRANSFORM_CRYPTO_POOL_MAX_WORKERS = int('TRANSFORM_CRYPTO_POOL_MAX_WORKERS', 4);
+export const TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS = int('TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS', 30_000);
+export const TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB = int('TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB', 128);
+export const TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB = int('TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB', 32);
+export const EMULATOR_FETCH_GOTO_TIMEOUT_MS = int('EMULATOR_FETCH_GOTO_TIMEOUT_MS', 30_000);
+export const WASM_TOOL_TIMEOUT_MS = int('WASM_TOOL_TIMEOUT_MS', 60_000);
+export const WASM_OFFLINE_RUN_TIMEOUT_MS = int('WASM_OFFLINE_RUN_TIMEOUT_MS', 10_000);
+export const WASM_OPTIMIZE_TIMEOUT_MS = int('WASM_OPTIMIZE_TIMEOUT_MS', 120_000);
+export const MINIAPP_UNPACK_TIMEOUT_MS = int('MINIAPP_UNPACK_TIMEOUT_MS', 180_000);
+export const CAPTCHA_SUBMIT_TIMEOUT_MS = int('CAPTCHA_SUBMIT_TIMEOUT_MS', 15_000);
+export const CAPTCHA_POLL_INTERVAL_MS = int('CAPTCHA_POLL_INTERVAL_MS', 5_000);
+export const CAPTCHA_RESULT_TIMEOUT_MS = int('CAPTCHA_RESULT_TIMEOUT_MS', 10_000);
+export const CAPTCHA_DEFAULT_TIMEOUT_MS = int('CAPTCHA_DEFAULT_TIMEOUT_MS', 180_000);
+export const CAPTCHA_MIN_TIMEOUT_MS = int('CAPTCHA_MIN_TIMEOUT_MS', 5_000);
+export const CAPTCHA_MAX_TIMEOUT_MS = int('CAPTCHA_MAX_TIMEOUT_MS', 600_000);
+export const CAPTCHA_MAX_RETRIES = int('CAPTCHA_MAX_RETRIES', 5);
+export const CAPTCHA_DEFAULT_RETRIES = int('CAPTCHA_DEFAULT_RETRIES', 2);
+export const NETWORK_REPLAY_TIMEOUT_MS = int('NETWORK_REPLAY_TIMEOUT_MS', 30_000);
+export const NETWORK_REPLAY_MAX_BODY_BYTES = int('NETWORK_REPLAY_MAX_BODY_BYTES', 512_000);
+export const NETWORK_REPLAY_MAX_REDIRECTS = int('NETWORK_REPLAY_MAX_REDIRECTS', 5);
+export const NETWORK_HAR_BODY_CONCURRENCY = int('NETWORK_HAR_BODY_CONCURRENCY', 8);
+export const WORKFLOW_BATCH_MAX_RETRIES = int('WORKFLOW_BATCH_MAX_RETRIES', 3);
+export const WORKFLOW_BATCH_MAX_BACKOFF_MS = int('WORKFLOW_BATCH_MAX_BACKOFF_MS', 30_000);
+export const WORKFLOW_BATCH_MAX_TIMEOUT_MS = int('WORKFLOW_BATCH_MAX_TIMEOUT_MS', 300_000);
+export const WORKFLOW_BATCH_RETRY_BACKOFF_MS = int('WORKFLOW_BATCH_RETRY_BACKOFF_MS', 2_000);
+export const WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS = int('WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS', 90_000);
+export const WORKFLOW_JS_BUNDLE_MAX_SIZE_BYTES = int('WORKFLOW_JS_BUNDLE_MAX_SIZE_BYTES', 20 * 1024 * 1024);
+export const WORKFLOW_JS_BUNDLE_MAX_REDIRECTS = int('WORKFLOW_JS_BUNDLE_MAX_REDIRECTS', 5);
+export const WORKFLOW_JS_BUNDLE_FETCH_TIMEOUT_MS = int('WORKFLOW_JS_BUNDLE_FETCH_TIMEOUT_MS', 30_000);
+export const WORKFLOW_BUNDLE_CACHE_TTL_MS = int('WORKFLOW_BUNDLE_CACHE_TTL_MS', 5 * 60 * 1000);
+export const WORKFLOW_BUNDLE_CACHE_MAX_BYTES = int('WORKFLOW_BUNDLE_CACHE_MAX_BYTES', 100 * 1024 * 1024);
+export const SEARCH_WORKFLOW_BOOST_TIERS = new Set(csv('SEARCH_WORKFLOW_BOOST_TIERS', ['workflow', 'full']));
+export const SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER = float('SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER', 1.5);
+export const SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE = json('SEARCH_INTENT_TOOL_BOOST_RULES_JSON', null);
+export const DYNAMIC_BOOST_ENABLED = bool('DYNAMIC_BOOST_ENABLED', true);
+export const DYNAMIC_BOOST_STRATEGY = str('DYNAMIC_BOOST_STRATEGY', 'majority');
+export const DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL = bool('DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL', true);
+export const DYNAMIC_BOOST_MAX_JUMP = int('DYNAMIC_BOOST_MAX_JUMP', 1);
+export const DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST = bool('DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST', false);
+export const SEARCH_TFIDF_COSINE_WEIGHT = float('SEARCH_TFIDF_COSINE_WEIGHT', 0.3);
+export const SEARCH_AFFINITY_BOOST_FACTOR = float('SEARCH_AFFINITY_BOOST_FACTOR', 0.15);
+export const SEARCH_AFFINITY_TOP_N = int('SEARCH_AFFINITY_TOP_N', 5);
+export const SEARCH_DOMAIN_HUB_THRESHOLD = int('SEARCH_DOMAIN_HUB_THRESHOLD', 3);
+export const SEARCH_QUERY_CACHE_CAPACITY = int('SEARCH_QUERY_CACHE_CAPACITY', 100);
+export const EXTENSION_GIT_CLONE_TIMEOUT_MS = int('EXTENSION_GIT_CLONE_TIMEOUT_MS', 60_000);
+export const EXTENSION_GIT_CHECKOUT_TIMEOUT_MS = int('EXTENSION_GIT_CHECKOUT_TIMEOUT_MS', 30_000);
+export const PROCESS_LIST_MAX_BUFFER_BYTES = int('PROCESS_LIST_MAX_BUFFER_BYTES', 1024 * 1024 * 10);
+export const EXTERNAL_TOOL_MAX_STDOUT_BYTES = int('EXTERNAL_TOOL_MAX_STDOUT_BYTES', 10 * 1024 * 1024);
+export const EXTERNAL_TOOL_MAX_STDERR_BYTES = int('EXTERNAL_TOOL_MAX_STDERR_BYTES', 1 * 1024 * 1024);
+export const WORKER_POOL_MIN_WORKERS = int('WORKER_POOL_MIN_WORKERS', 2);
+export const WORKER_POOL_MAX_WORKERS = int('WORKER_POOL_MAX_WORKERS', 4);
+export const WORKER_POOL_IDLE_TIMEOUT_MS = int('WORKER_POOL_IDLE_TIMEOUT_MS', 30_000);
+export const WORKER_POOL_JOB_TIMEOUT_MS = int('WORKER_POOL_JOB_TIMEOUT_MS', 15_000);
+export const PARALLEL_DEFAULT_CONCURRENCY = int('PARALLEL_DEFAULT_CONCURRENCY', 3);
+export const PARALLEL_DEFAULT_TIMEOUT_MS = int('PARALLEL_DEFAULT_TIMEOUT_MS', 60_000);
+export const PARALLEL_DEFAULT_MAX_RETRIES = int('PARALLEL_DEFAULT_MAX_RETRIES', 2);
+export const PARALLEL_RETRY_BACKOFF_BASE_MS = int('PARALLEL_RETRY_BACKOFF_BASE_MS', 1_000);
+export const CACHE_GLOBAL_MAX_SIZE_BYTES = int('CACHE_GLOBAL_MAX_SIZE_BYTES', 500 * 1024 * 1024);
+export const CACHE_LOW_HIT_RATE_THRESHOLD = parseFloat(process.env.CACHE_LOW_HIT_RATE_THRESHOLD || '0.3');
+export const TOKEN_BUDGET_MAX_TOKENS = int('TOKEN_BUDGET_MAX_TOKENS', 200_000);
+export const DETAILED_DATA_DEFAULT_TTL_MS = int('DETAILED_DATA_DEFAULT_TTL_MS', 30 * 60 * 1000);
+export const DETAILED_DATA_MAX_TTL_MS = int('DETAILED_DATA_MAX_TTL_MS', 60 * 60 * 1000);
+export const DETAILED_DATA_SMART_THRESHOLD_BYTES = int('DETAILED_DATA_SMART_THRESHOLD_BYTES', 50 * 1024);
+export const ADV_DEOBF_LLM_MAX_TOKENS = int('ADV_DEOBF_LLM_MAX_TOKENS', 3_000);
+export const VM_DEOBF_LLM_MAX_TOKENS = int('VM_DEOBF_LLM_MAX_TOKENS', 4_000);
+export const DEOBF_LLM_MAX_TOKENS = int('DEOBF_LLM_MAX_TOKENS', 2_000);
+export const CRYPTO_DETECT_LLM_MAX_TOKENS = int('CRYPTO_DETECT_LLM_MAX_TOKENS', 2_000);
+export const MEMORY_READ_TIMEOUT_MS = int('MEMORY_READ_TIMEOUT_MS', 10_000);
+export const MEMORY_MAX_READ_BYTES = int('MEMORY_MAX_READ_BYTES', 16 * 1024 * 1024);
+export const MEMORY_WRITE_TIMEOUT_MS = int('MEMORY_WRITE_TIMEOUT_MS', 10_000);
+export const MEMORY_MAX_WRITE_BYTES = int('MEMORY_MAX_WRITE_BYTES', 16 * 1024);
+export const MEMORY_DUMP_TIMEOUT_MS = int('MEMORY_DUMP_TIMEOUT_MS', 60_000);
+export const MEMORY_SCAN_TIMEOUT_MS = int('MEMORY_SCAN_TIMEOUT_MS', 120_000);
+export const MEMORY_SCAN_MAX_BUFFER_BYTES = int('MEMORY_SCAN_MAX_BUFFER_BYTES', 1024 * 1024 * 50);
+export const MEMORY_SCAN_MAX_RESULTS = int('MEMORY_SCAN_MAX_RESULTS', 10_000);
+export const MEMORY_SCAN_MAX_REGIONS = int('MEMORY_SCAN_MAX_REGIONS', 50_000);
+export const MEMORY_SCAN_REGION_MAX_BYTES = int('MEMORY_SCAN_REGION_MAX_BYTES', 16_777_216);
+export const MEMORY_INJECT_TIMEOUT_MS = int('MEMORY_INJECT_TIMEOUT_MS', 30_000);
+export const ENABLE_INJECTION_TOOLS = bool('ENABLE_INJECTION_TOOLS', true);
+export const MEMORY_MONITOR_INTERVAL_MS = int('MEMORY_MONITOR_INTERVAL_MS', 1_000);
+export const MEMORY_VMMAP_TIMEOUT_MS = int('MEMORY_VMMAP_TIMEOUT_MS', 15_000);
+export const MEMORY_PROTECTION_QUERY_TIMEOUT_MS = int('MEMORY_PROTECTION_QUERY_TIMEOUT_MS', 15_000);
+export const MEMORY_PROTECTION_PWSH_TIMEOUT_MS = int('MEMORY_PROTECTION_PWSH_TIMEOUT_MS', 30_000);
+export const NATIVE_ADMIN_CHECK_TIMEOUT_MS = int('NATIVE_ADMIN_CHECK_TIMEOUT_MS', 5_000);
+export const NATIVE_SCAN_MAX_RESULTS = int('NATIVE_SCAN_MAX_RESULTS', 10_000);
+export const PROCESS_LAUNCH_WAIT_MS = int('PROCESS_LAUNCH_WAIT_MS', 2_000);
+export const WIN_DEBUG_PORT_POLL_ATTEMPTS = int('WIN_DEBUG_PORT_POLL_ATTEMPTS', 20);
+export const WIN_DEBUG_PORT_POLL_INTERVAL_MS = int('WIN_DEBUG_PORT_POLL_INTERVAL_MS', 500);
+export const PACKER_SANDBOX_TIMEOUT_MS = int('PACKER_SANDBOX_TIMEOUT_MS', 3_000);