@jshookmcp/jshook 0.1.8 → 0.1.9

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);

package/dist/src/index.js

@@ -0,0 +1,139 @@
+#!/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();