@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -0,0 +1,156 @@
+export interface RetryPolicy {
+    maxAttempts: number;
+    backoffMs: number;
+    multiplier?: number;
+}
+export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch';
+export interface ToolNode {
+    readonly kind: 'tool';
+    readonly id: string;
+    readonly toolName: string;
+    readonly input?: Record<string, unknown>;
+    readonly timeoutMs?: number;
+    readonly retry?: RetryPolicy;
+}
+export interface SequenceNode {
+    readonly kind: 'sequence';
+    readonly id: string;
+    readonly steps: WorkflowNode[];
+}
+export interface ParallelNode {
+    readonly kind: 'parallel';
+    readonly id: string;
+    readonly steps: WorkflowNode[];
+    readonly maxConcurrency?: number;
+    readonly failFast?: boolean;
+}
+export interface BranchNode {
+    readonly kind: 'branch';
+    readonly id: string;
+    readonly predicateId: string;
+    readonly predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>;
+    readonly whenTrue: WorkflowNode;
+    readonly whenFalse?: WorkflowNode;
+}
+export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode;
+export interface ToolNodeOptions {
+    input?: Record<string, unknown>;
+    retry?: RetryPolicy;
+    timeoutMs?: number;
+}
+export interface WorkflowExecutionContext {
+    readonly workflowRunId: string;
+    readonly profile: string;
+    invokeTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    emitSpan(name: string, attrs?: Record<string, unknown>): void;
+    emitMetric(name: string, value: number, type: 'counter' | 'gauge' | 'histogram', attrs?: Record<string, unknown>): void;
+    getConfig<T = unknown>(path: string, fallback?: T): T;
+}
+export interface WorkflowRouteStep {
+    readonly id: string;
+    readonly toolName: string;
+    readonly description: string;
+    readonly prerequisites: string[];
+    readonly parallel?: boolean;
+    readonly expectedInputs?: Record<string, string>;
+    readonly evidenceNodeType?: string;
+}
+export type WorkflowRouteKind = 'preset' | 'workflow';
+export interface WorkflowRouteMetadata {
+    readonly kind: WorkflowRouteKind;
+    readonly triggerPatterns: RegExp[];
+    readonly steps: WorkflowRouteStep[];
+    readonly requiredDomains: string[];
+    readonly priority: number;
+}
+export interface WorkflowContract {
+    readonly kind: 'workflow-contract';
+    readonly version: 1;
+    readonly id: string;
+    readonly displayName: string;
+    readonly description?: string;
+    readonly tags?: string[];
+    readonly timeoutMs?: number;
+    readonly defaultMaxConcurrency?: number;
+    readonly route?: WorkflowRouteMetadata;
+    build(ctx: WorkflowExecutionContext): WorkflowNode;
+    onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
+    onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
+    onError?(ctx: WorkflowExecutionContext, error: Error): Promise<void> | void;
+}
+export declare abstract class WorkflowNodeBuilder<T extends WorkflowNode> {
+    protected id: string;
+    constructor(id: string);
+    abstract build(): T;
+}
+type AnyWorkflowNodeBuilder = WorkflowNodeBuilder<WorkflowNode>;
+export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
+    private toolName;
+    private _input?;
+    private _retry?;
+    private _timeoutMs?;
+    constructor(id: string, toolName: string);
+    input(input: Record<string, unknown>): this;
+    retry(policy: RetryPolicy): this;
+    timeout(ms: number): this;
+    build(): ToolNode;
+}
+declare abstract class CompositeNodeBuilder<T extends WorkflowNode> extends WorkflowNodeBuilder<T> {
+    protected _steps: AnyWorkflowNodeBuilder[];
+    step(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    tool(id: string, toolName: string, config?: ToolNodeOptions | ((b: ToolNodeBuilder) => void)): this;
+    sequence(id: string, config?: (b: SequenceNodeBuilder) => void): this;
+    parallel(id: string, config?: (b: ParallelNodeBuilder) => void): this;
+    branch(id: string, predicateId: string, config?: (b: BranchNodeBuilder) => void): this;
+}
+export declare class SequenceNodeBuilder extends CompositeNodeBuilder<SequenceNode> {
+    build(): SequenceNode;
+}
+export declare class ParallelNodeBuilder extends CompositeNodeBuilder<ParallelNode> {
+    private _maxConcurrency?;
+    private _failFast?;
+    maxConcurrency(concurrency: number): this;
+    failFast(ff: boolean): this;
+    build(): ParallelNode;
+}
+export declare class BranchNodeBuilder extends WorkflowNodeBuilder<BranchNode> {
+    private predicateId;
+    private _predicateFn?;
+    private _whenTrue?;
+    private _whenFalse?;
+    constructor(id: string, predicateId: string);
+    predicateFn(fn: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>): this;
+    whenTrue(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    whenFalse(nodeBuilder: AnyWorkflowNodeBuilder): this;
+    build(): BranchNode;
+}
+export declare class WorkflowBuilder {
+    private _id;
+    private _displayName;
+    private _description?;
+    private _tags?;
+    private _timeoutMs?;
+    private _defaultMaxConcurrency?;
+    private _route?;
+    private _buildFn;
+    private _onStart?;
+    private _onFinish?;
+    private _onError?;
+    constructor(id: string, displayName: string);
+    description(desc: string): this;
+    tags(tags: string[]): this;
+    timeoutMs(timeout: number): this;
+    defaultMaxConcurrency(max: number): this;
+    route(route: WorkflowRouteMetadata): this;
+    buildGraph(fn: (ctx: WorkflowExecutionContext) => AnyWorkflowNodeBuilder): this;
+    onStart(fn: (ctx: WorkflowExecutionContext) => Promise<void> | void): this;
+    onFinish(fn: (ctx: WorkflowExecutionContext, result: unknown) => Promise<void> | void): this;
+    onError(fn: (ctx: WorkflowExecutionContext, error: Error) => Promise<void> | void): this;
+    build(): WorkflowContract;
+}
+export declare function createWorkflow(id: string, displayName: string): WorkflowBuilder;
+export declare function toolNode(id: string, toolName: string): ToolNodeBuilder;
+export declare function sequenceNode(id: string): SequenceNodeBuilder;
+export declare function parallelNode(id: string): ParallelNodeBuilder;
+export declare function branchNode(id: string, predicateId: string): BranchNodeBuilder;
+export {};

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

@@ -0,0 +1,236 @@
+export class WorkflowNodeBuilder {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
+export class ToolNodeBuilder extends WorkflowNodeBuilder {
+    toolName;
+    _input;
+    _retry;
+    _timeoutMs;
+    constructor(id, toolName) {
+        super(id);
+        this.toolName = toolName;
+    }
+    input(input) {
+        this._input = input;
+        return this;
+    }
+    retry(policy) {
+        this._retry = policy;
+        return this;
+    }
+    timeout(ms) {
+        this._timeoutMs = ms;
+        return this;
+    }
+    build() {
+        return {
+            kind: 'tool',
+            id: this.id,
+            toolName: this.toolName,
+            input: this._input,
+            retry: this._retry,
+            timeoutMs: this._timeoutMs,
+        };
+    }
+}
+class CompositeNodeBuilder extends WorkflowNodeBuilder {
+    _steps = [];
+    step(nodeBuilder) {
+        this._steps.push(nodeBuilder);
+        return this;
+    }
+    tool(id, toolName, config) {
+        const builder = new ToolNodeBuilder(id, toolName);
+        if (config) {
+            if (typeof config === 'function') {
+                config(builder);
+            }
+            else {
+                if (config.input)
+                    builder.input(config.input);
+                if (config.retry)
+                    builder.retry(config.retry);
+                if (config.timeoutMs !== undefined)
+                    builder.timeout(config.timeoutMs);
+            }
+        }
+        this._steps.push(builder);
+        return this;
+    }
+    sequence(id, config) {
+        const builder = new SequenceNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+    parallel(id, config) {
+        const builder = new ParallelNodeBuilder(id);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+    branch(id, predicateId, config) {
+        const builder = new BranchNodeBuilder(id, predicateId);
+        if (config)
+            config(builder);
+        this._steps.push(builder);
+        return this;
+    }
+}
+export class SequenceNodeBuilder extends CompositeNodeBuilder {
+    build() {
+        return {
+            kind: 'sequence',
+            id: this.id,
+            steps: this._steps.map((b) => b.build()),
+        };
+    }
+}
+export class ParallelNodeBuilder extends CompositeNodeBuilder {
+    _maxConcurrency = 4;
+    _failFast = false;
+    maxConcurrency(concurrency) {
+        this._maxConcurrency = concurrency;
+        return this;
+    }
+    failFast(ff) {
+        this._failFast = ff;
+        return this;
+    }
+    build() {
+        return {
+            kind: 'parallel',
+            id: this.id,
+            steps: this._steps.map((b) => b.build()),
+            maxConcurrency: this._maxConcurrency,
+            failFast: this._failFast,
+        };
+    }
+}
+export class BranchNodeBuilder extends WorkflowNodeBuilder {
+    predicateId;
+    _predicateFn;
+    _whenTrue;
+    _whenFalse;
+    constructor(id, predicateId) {
+        super(id);
+        this.predicateId = predicateId;
+    }
+    predicateFn(fn) {
+        this._predicateFn = fn;
+        return this;
+    }
+    whenTrue(nodeBuilder) {
+        this._whenTrue = nodeBuilder;
+        return this;
+    }
+    whenFalse(nodeBuilder) {
+        this._whenFalse = nodeBuilder;
+        return this;
+    }
+    build() {
+        if (!this._whenTrue) {
+            throw new Error(`BranchNode '${this.id}' requires a whenTrue step`);
+        }
+        return {
+            kind: 'branch',
+            id: this.id,
+            predicateId: this.predicateId,
+            predicateFn: this._predicateFn,
+            whenTrue: this._whenTrue.build(),
+            whenFalse: this._whenFalse ? this._whenFalse.build() : undefined,
+        };
+    }
+}
+export class WorkflowBuilder {
+    _id;
+    _displayName;
+    _description;
+    _tags;
+    _timeoutMs;
+    _defaultMaxConcurrency;
+    _route;
+    _buildFn;
+    _onStart;
+    _onFinish;
+    _onError;
+    constructor(id, displayName) {
+        this._id = id;
+        this._displayName = displayName;
+    }
+    description(desc) {
+        this._description = desc;
+        return this;
+    }
+    tags(tags) {
+        this._tags = tags;
+        return this;
+    }
+    timeoutMs(timeout) {
+        this._timeoutMs = timeout;
+        return this;
+    }
+    defaultMaxConcurrency(max) {
+        this._defaultMaxConcurrency = max;
+        return this;
+    }
+    route(route) {
+        this._route = route;
+        return this;
+    }
+    buildGraph(fn) {
+        this._buildFn = (ctx) => fn(ctx).build();
+        return this;
+    }
+    onStart(fn) {
+        this._onStart = fn;
+        return this;
+    }
+    onFinish(fn) {
+        this._onFinish = fn;
+        return this;
+    }
+    onError(fn) {
+        this._onError = fn;
+        return this;
+    }
+    build() {
+        if (!this._buildFn)
+            throw new Error(`WorkflowBuilder '${this._id}' needs a buildGraph() function.`);
+        return {
+            kind: 'workflow-contract',
+            version: 1,
+            id: this._id,
+            displayName: this._displayName,
+            description: this._description,
+            tags: this._tags,
+            timeoutMs: this._timeoutMs,
+            defaultMaxConcurrency: this._defaultMaxConcurrency,
+            route: this._route,
+            build: this._buildFn,
+            onStart: this._onStart,
+            onFinish: this._onFinish,
+            onError: this._onError,
+        };
+    }
+}
+export function createWorkflow(id, displayName) {
+    return new WorkflowBuilder(id, displayName);
+}
+export function toolNode(id, toolName) {
+    return new ToolNodeBuilder(id, toolName);
+}
+export function sequenceNode(id) {
+    return new SequenceNodeBuilder(id);
+}
+export function parallelNode(id) {
+    return new ParallelNodeBuilder(id);
+}
+export function branchNode(id, predicateId) {
+    return new BranchNodeBuilder(id, predicateId);
+}

package/dist/src/config/search-defaults.js

@@ -58,6 +58,14 @@ export const DEFAULT_QUERY_CATEGORY_PROFILE_CONFIGS = [
             { domain: 'browser', weight: 1.1 },
         ],
     },
+    {
+        pattern: '(?:reverse|mission|signature|hook|crypto|encrypt|websocket|\\bws\\b|protocol|bundle|webpack|deobfusc|stealth|fingerprint|evidence|\\bhar\\b|逆向|签名|加签|协议|反混淆|反检测|指纹|证据|报告)',
+        flags: 'i',
+        domainBoosts: [
+            { domain: 'workflow', weight: 1.8 },
+            { domain: 'analysis', weight: 1.1 },
+        ],
+    },
 ];
 export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '工作流|流程编排|流程自动化|编排', tokens: ['workflow', 'flow', 'orchestration'] },
@@ -74,6 +82,14 @@ export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '批量|并发', tokens: ['batch', 'parallel'] },
     { pattern: '令牌|凭证|鉴权|认证', tokens: ['token', 'auth', 'credential'] },
     { pattern: '提取|抽取|解析', tokens: ['extract', 'parse'] },
+    { pattern: '签名|加签|加密|hook', tokens: ['signature', 'crypto', 'hook', 'sign'] },
+    { pattern: '协议|消息|帧|handler', tokens: ['websocket', 'protocol', 'ws', 'handler'] },
+    { pattern: '打包|webpack|混淆|反混淆', tokens: ['bundle', 'webpack', 'deobfuscate', 'unpack'] },
+    {
+        pattern: '反爬|反检测|指纹|stealth',
+        tokens: ['antibot', 'stealth', 'fingerprint', 'detection'],
+    },
+    { pattern: '证据|取证|导出|报告|快照', tokens: ['evidence', 'export', 'report', 'forensic'] },
     { pattern: '多标签页|多标签|标签页', tokens: ['tab', 'multi'] },
     { pattern: '脚本库|脚本仓库', tokens: ['script', 'library'] },
     { pattern: '脚本', tokens: ['script'] },
@@ -81,6 +97,19 @@ export const DEFAULT_CJK_QUERY_ALIAS_CONFIGS = [
     { pattern: '导出', tokens: ['export'] },
     { pattern: '回放|重放', tokens: ['replay'] },
     { pattern: '请求', tokens: ['request'] },
+    { pattern: '鉴权面|认证面|授权面|凭证枚举', tokens: ['auth', 'surface', 'token', 'credential'] },
+    { pattern: '通道|通信|协议注册|协议枚举', tokens: ['protocol', 'channel', 'registry'] },
+    { pattern: '人机|挑战|风控|拦截页', tokens: ['challenge', 'captcha', 'cloudflare', 'turnstile'] },
+    {
+        pattern: '签名谱系|签名链路|加签链路|签名追踪',
+        tokens: ['signing', 'lineage', 'signature', 'trace'],
+    },
+    { pattern: '复现|重发|篡改|参数篡改', tokens: ['replay', 'tamper', 'request'] },
+    {
+        pattern: '反混淆链|反混淆管道|清洗|还原',
+        tokens: ['deobfuscate', 'pipeline', 'transform', 'ast'],
+    },
+    { pattern: '桌面应用|electron|nwjs|预加载', tokens: ['electron', 'bridge', 'preload', 'ipc'] },
 ];
 export const DEFAULT_INTENT_TOOL_BOOST_RULE_CONFIGS = [
     {
@@ -139,6 +168,138 @@ export const DEFAULT_INTENT_TOOL_BOOST_RULE_CONFIGS = [
             { tool: 'network_extract_auth', bonus: 18 },
         ],
     },
+    {
+        pattern: '(?:signature|crypto|encrypt|hash|hook|签名|加签|加密)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'search_in_scripts', bonus: 12 },
+            { tool: 'detect_crypto', bonus: 10 },
+            { tool: 'manage_hooks', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:websocket|\\bws\\b|protocol|socket|handler|协议|消息|帧)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'ws_monitor_enable', bonus: 12 },
+            { tool: 'ws_get_frames', bonus: 10 },
+            { tool: 'ws_get_connections', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:bundle|webpack|chunk|source.*map|deobfusc|源码|打包|混淆|反混淆)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'js_bundle_search', bonus: 14 },
+            { tool: 'collect_code', bonus: 10 },
+            { tool: 'source_map_extract', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:stealth|fingerprint|webdriver|antibot|bot.*detect|反爬|反检测|指纹)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'stealth_inject', bonus: 10 },
+            { tool: 'stealth_generate_fingerprint', bonus: 10 },
+            { tool: 'stealth_verify', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:evidence|export|har|report|snapshot|证据|导出|报告|快照|取证)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'evidence_query_url', bonus: 14 },
+            { tool: 'evidence_export_markdown', bonus: 12 },
+            { tool: 'evidence_export_json', bonus: 10 },
+        ],
+    },
+    {
+        pattern: '(?:auth.*surface|token.*enum|credential.*map|鉴权面|认证面|凭证枚举|jwt|csrf|api.?key|授权)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'network_extract_auth', bonus: 14 },
+            { tool: 'page_get_cookies', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:protocol.*registry|channel.*enum|通道枚举|协议注册|协议归类|SSE|EventSource|beacon|postMessage)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'ws_monitor_enable', bonus: 10 },
+            { tool: 'sse_monitor_enable', bonus: 10 },
+            { tool: 'network_get_requests', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:challenge|turnstile|cloudflare|hcaptcha|datadome|akamai|perimeterx|kasada|人机|挑战|风控|拦截页)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'captcha_detect', bonus: 14 },
+            { tool: 'stealth_verify', bonus: 10 },
+        ],
+    },
+    {
+        pattern: '(?:signing.*lineage|签名谱系|签名链路|加签链路|签名追踪|plaintext.*cipher|明文.*密文)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'detect_crypto', bonus: 12 },
+            { tool: 'extract_function_tree', bonus: 10 },
+            { tool: 'manage_hooks', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:replay.*lab|request.*replay|复现|重发|篡改|参数篡改|request.*tamper)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'network_replay_request', bonus: 14 },
+            { tool: 'instrumentation_network_replay', bonus: 12 },
+            { tool: 'network_export_har', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:deobfusc.*pipeline|反混淆链|反混淆管道|清洗|还原|ast.*transform|packer|unpack)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'webcrack_unpack', bonus: 14 },
+            { tool: 'ast_transform_apply', bonus: 12 },
+            { tool: 'deobfuscate', bonus: 10 },
+            { tool: 'detect_obfuscation', bonus: 8 },
+        ],
+    },
+    {
+        pattern: '(?:electron|nwjs|preload|ipc|asar|桌面应用|预加载|桥接|electron.*bridge)',
+        flags: 'i',
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'electron_inspect_app', bonus: 14 },
+            { tool: 'electron_ipc_sniff', bonus: 12 },
+            { tool: 'asar_search', bonus: 10 },
+            { tool: 'electron_check_fuses', bonus: 8 },
+        ],
+    },
 ];
 export const DEFAULT_SEARCH_CONFIG = {
     queryCategoryProfiles: DEFAULT_QUERY_CATEGORY_PROFILE_CONFIGS,

package/dist/src/constants.d.ts

@@ -1,3 +1,6 @@
+export declare const SHUTDOWN_TIMEOUT_MS: number;
+export declare const RUNTIME_ERROR_WINDOW_MS: number;
+export declare const RUNTIME_ERROR_THRESHOLD: number;
 export declare const DEBUG_PORT_CANDIDATES: number[];
 export declare const DEFAULT_DEBUG_PORT: number;
 export declare const GHIDRA_BRIDGE_ENDPOINT: string;

package/dist/src/constants.js

@@ -40,6 +40,9 @@ const csv = (key, fallback) => {
         .filter(Boolean);
     return parsed.length > 0 ? parsed : fallback;
 };
+export const SHUTDOWN_TIMEOUT_MS = int('SHUTDOWN_TIMEOUT_MS', 10_000);
+export const RUNTIME_ERROR_WINDOW_MS = int('RUNTIME_ERROR_WINDOW_MS', 60_000);
+export const RUNTIME_ERROR_THRESHOLD = int('RUNTIME_ERROR_THRESHOLD', 5);
 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');
@@ -146,7 +149,7 @@ export const PARALLEL_DEFAULT_TIMEOUT_MS = int('PARALLEL_DEFAULT_TIMEOUT_MS', 60
 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 CACHE_LOW_HIT_RATE_THRESHOLD = float('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);

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export declare function main(): Promise<void>;

package/dist/src/index.js

@@ -5,7 +5,7 @@ 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 SHUTDOWN_TIMEOUT_MS = 10_000;
+import { SHUTDOWN_TIMEOUT_MS, RUNTIME_ERROR_WINDOW_MS, RUNTIME_ERROR_THRESHOLD, } from './constants.js';
 const FATAL_ERROR_CODES = new Set([
     'ERR_WORKER_OUT_OF_MEMORY',
     'ERR_MEMORY_ALLOCATION_FAILED',
@@ -41,8 +41,16 @@ function formatUnknownError(input) {
         return String(input);
     }
 }
-async function main() {
+export async function main() {
     try {
+        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);
+            return;
+        }
         const config = getConfig();
         logger.debug('Configuration loaded:', config);
         const validation = validateConfig(config);
@@ -50,12 +58,7 @@ async function main() {
             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.');
+            return;
         }
         const artifactRetention = getArtifactRetentionConfig();
         if (artifactRetention.cleanupOnStart && artifactRetention.enabled) {
@@ -68,8 +71,8 @@ async function main() {
         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 recoveryWindowMs = Math.max(1000, RUNTIME_ERROR_WINDOW_MS);
+        const maxRecoverableErrors = Math.max(1, RUNTIME_ERROR_THRESHOLD);
         const runtimeRecovery = {
             windowStart: Date.now(),
             errorCount: 0,
@@ -175,11 +178,4 @@ async function main() {
         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);
-}
 void main();

package/dist/src/modules/analyzer/CodeAnalyzer.d.ts

@@ -1,8 +1,6 @@
 import type { UnderstandCodeOptions, UnderstandCodeResult } from '../../types/index.js';
-import { LLMService } from '../../services/LLMService.js';
 export declare class CodeAnalyzer {
-    private llm;
-    constructor(llm: LLMService);
+    constructor(legacyDependency?: unknown);
     understand(options: UnderstandCodeOptions): Promise<UnderstandCodeResult>;
     private analyzeStructure;
     private aiAnalyze;