@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/DomainInstanceRegistry.d.ts

@@ -1,132 +0,0 @@
-import type { CodeCollector } from '../modules/collector/CodeCollector.js';
-import type { PageController } from '../modules/collector/PageController.js';
-import type { DOMInspector } from '../modules/collector/DOMInspector.js';
-import type { ScriptManager } from '../modules/debugger/ScriptManager.js';
-import type { DebuggerManager } from '../modules/debugger/DebuggerManager.js';
-import type { RuntimeInspector } from '../modules/debugger/RuntimeInspector.js';
-import type { ConsoleMonitor } from '../modules/monitor/ConsoleMonitor.js';
-import type { BrowserToolHandlers } from './domains/browser/index.js';
-import type { DebuggerToolHandlers } from './domains/debugger/index.js';
-import type { AdvancedToolHandlers } from './domains/network/index.js';
-import type { AIHookToolHandlers, HookPresetToolHandlers } from './domains/hooks/index.js';
-import type { Deobfuscator } from '../modules/deobfuscator/Deobfuscator.js';
-import type { AdvancedDeobfuscator } from '../modules/deobfuscator/AdvancedDeobfuscator.js';
-import type { ASTOptimizer } from '../modules/deobfuscator/ASTOptimizer.js';
-import type { ObfuscationDetector } from '../modules/detector/ObfuscationDetector.js';
-import type { LLMService } from '../services/LLMService.js';
-import type { CodeAnalyzer } from '../modules/analyzer/CodeAnalyzer.js';
-import type { CryptoDetector } from '../modules/crypto/CryptoDetector.js';
-import type { HookManager } from '../modules/hook/HookManager.js';
-import type { CoreAnalysisHandlers } from './domains/analysis/index.js';
-import type { CoreMaintenanceHandlers, ExtensionManagementHandlers } from './domains/maintenance/index.js';
-import type { ProcessToolHandlers } from './domains/process/index.js';
-import type { WorkflowHandlers } from './domains/workflow/index.js';
-import type { WasmToolHandlers } from './domains/wasm/index.js';
-import type { StreamingToolHandlers } from './domains/streaming/index.js';
-import type { EncodingToolHandlers } from './domains/encoding/index.js';
-import type { AntiDebugToolHandlers } from './domains/antidebug/index.js';
-import type { GraphQLToolHandlers } from './domains/graphql/index.js';
-import type { PlatformToolHandlers } from './domains/platform/index.js';
-import type { SourcemapToolHandlers } from './domains/sourcemap/index.js';
-import type { TransformToolHandlers } from './domains/transform/index.js';
-export declare class DomainInstanceRegistry {
-    private _collector?;
-    private _pageController?;
-    private _domInspector?;
-    private _scriptManager?;
-    private _debuggerManager?;
-    private _runtimeInspector?;
-    private _consoleMonitor?;
-    private _llm?;
-    private _deobfuscator?;
-    private _advancedDeobfuscator?;
-    private _astOptimizer?;
-    private _obfuscationDetector?;
-    private _analyzer?;
-    private _cryptoDetector?;
-    private _hookManager?;
-    private _browserHandlers?;
-    private _debuggerHandlers?;
-    private _advancedHandlers?;
-    private _aiHookHandlers?;
-    private _hookPresetHandlers?;
-    private _coreAnalysisHandlers?;
-    private _coreMaintenanceHandlers?;
-    private _extensionManagementHandlers?;
-    private _processHandlers?;
-    private _workflowHandlers?;
-    private _wasmHandlers?;
-    private _streamingHandlers?;
-    private _encodingHandlers?;
-    private _antidebugHandlers?;
-    private _graphqlHandlers?;
-    private _platformHandlers?;
-    private _sourcemapHandlers?;
-    private _transformHandlers?;
-    get collector(): CodeCollector | undefined;
-    set collector(value: CodeCollector | undefined);
-    get pageController(): PageController | undefined;
-    set pageController(value: PageController | undefined);
-    get domInspector(): DOMInspector | undefined;
-    set domInspector(value: DOMInspector | undefined);
-    get scriptManager(): ScriptManager | undefined;
-    set scriptManager(value: ScriptManager | undefined);
-    get debuggerManager(): DebuggerManager | undefined;
-    set debuggerManager(value: DebuggerManager | undefined);
-    get runtimeInspector(): RuntimeInspector | undefined;
-    set runtimeInspector(value: RuntimeInspector | undefined);
-    get consoleMonitor(): ConsoleMonitor | undefined;
-    set consoleMonitor(value: ConsoleMonitor | undefined);
-    get llm(): LLMService | undefined;
-    set llm(value: LLMService | undefined);
-    get deobfuscator(): Deobfuscator | undefined;
-    set deobfuscator(value: Deobfuscator | undefined);
-    get advancedDeobfuscator(): AdvancedDeobfuscator | undefined;
-    set advancedDeobfuscator(value: AdvancedDeobfuscator | undefined);
-    get astOptimizer(): ASTOptimizer | undefined;
-    set astOptimizer(value: ASTOptimizer | undefined);
-    get obfuscationDetector(): ObfuscationDetector | undefined;
-    set obfuscationDetector(value: ObfuscationDetector | undefined);
-    get analyzer(): CodeAnalyzer | undefined;
-    set analyzer(value: CodeAnalyzer | undefined);
-    get cryptoDetector(): CryptoDetector | undefined;
-    set cryptoDetector(value: CryptoDetector | undefined);
-    get hookManager(): HookManager | undefined;
-    set hookManager(value: HookManager | undefined);
-    get browserHandlers(): BrowserToolHandlers | undefined;
-    set browserHandlers(value: BrowserToolHandlers | undefined);
-    get debuggerHandlers(): DebuggerToolHandlers | undefined;
-    set debuggerHandlers(value: DebuggerToolHandlers | undefined);
-    get advancedHandlers(): AdvancedToolHandlers | undefined;
-    set advancedHandlers(value: AdvancedToolHandlers | undefined);
-    get aiHookHandlers(): AIHookToolHandlers | undefined;
-    set aiHookHandlers(value: AIHookToolHandlers | undefined);
-    get hookPresetHandlers(): HookPresetToolHandlers | undefined;
-    set hookPresetHandlers(value: HookPresetToolHandlers | undefined);
-    get coreAnalysisHandlers(): CoreAnalysisHandlers | undefined;
-    set coreAnalysisHandlers(value: CoreAnalysisHandlers | undefined);
-    get coreMaintenanceHandlers(): CoreMaintenanceHandlers | undefined;
-    set coreMaintenanceHandlers(value: CoreMaintenanceHandlers | undefined);
-    get extensionManagementHandlers(): ExtensionManagementHandlers | undefined;
-    set extensionManagementHandlers(value: ExtensionManagementHandlers | undefined);
-    get processHandlers(): ProcessToolHandlers | undefined;
-    set processHandlers(value: ProcessToolHandlers | undefined);
-    get workflowHandlers(): WorkflowHandlers | undefined;
-    set workflowHandlers(value: WorkflowHandlers | undefined);
-    get wasmHandlers(): WasmToolHandlers | undefined;
-    set wasmHandlers(value: WasmToolHandlers | undefined);
-    get streamingHandlers(): StreamingToolHandlers | undefined;
-    set streamingHandlers(value: StreamingToolHandlers | undefined);
-    get encodingHandlers(): EncodingToolHandlers | undefined;
-    set encodingHandlers(value: EncodingToolHandlers | undefined);
-    get antidebugHandlers(): AntiDebugToolHandlers | undefined;
-    set antidebugHandlers(value: AntiDebugToolHandlers | undefined);
-    get graphqlHandlers(): GraphQLToolHandlers | undefined;
-    set graphqlHandlers(value: GraphQLToolHandlers | undefined);
-    get platformHandlers(): PlatformToolHandlers | undefined;
-    set platformHandlers(value: PlatformToolHandlers | undefined);
-    get sourcemapHandlers(): SourcemapToolHandlers | undefined;
-    set sourcemapHandlers(value: SourcemapToolHandlers | undefined);
-    get transformHandlers(): TransformToolHandlers | undefined;
-    set transformHandlers(value: TransformToolHandlers | undefined);
-}

package/dist/src/server/DomainInstanceRegistry.js

@@ -1,233 +0,0 @@
-export class DomainInstanceRegistry {
-    _collector;
-    _pageController;
-    _domInspector;
-    _scriptManager;
-    _debuggerManager;
-    _runtimeInspector;
-    _consoleMonitor;
-    _llm;
-    _deobfuscator;
-    _advancedDeobfuscator;
-    _astOptimizer;
-    _obfuscationDetector;
-    _analyzer;
-    _cryptoDetector;
-    _hookManager;
-    _browserHandlers;
-    _debuggerHandlers;
-    _advancedHandlers;
-    _aiHookHandlers;
-    _hookPresetHandlers;
-    _coreAnalysisHandlers;
-    _coreMaintenanceHandlers;
-    _extensionManagementHandlers;
-    _processHandlers;
-    _workflowHandlers;
-    _wasmHandlers;
-    _streamingHandlers;
-    _encodingHandlers;
-    _antidebugHandlers;
-    _graphqlHandlers;
-    _platformHandlers;
-    _sourcemapHandlers;
-    _transformHandlers;
-    get collector() {
-        return this._collector;
-    }
-    set collector(value) {
-        this._collector = value;
-    }
-    get pageController() {
-        return this._pageController;
-    }
-    set pageController(value) {
-        this._pageController = value;
-    }
-    get domInspector() {
-        return this._domInspector;
-    }
-    set domInspector(value) {
-        this._domInspector = value;
-    }
-    get scriptManager() {
-        return this._scriptManager;
-    }
-    set scriptManager(value) {
-        this._scriptManager = value;
-    }
-    get debuggerManager() {
-        return this._debuggerManager;
-    }
-    set debuggerManager(value) {
-        this._debuggerManager = value;
-    }
-    get runtimeInspector() {
-        return this._runtimeInspector;
-    }
-    set runtimeInspector(value) {
-        this._runtimeInspector = value;
-    }
-    get consoleMonitor() {
-        return this._consoleMonitor;
-    }
-    set consoleMonitor(value) {
-        this._consoleMonitor = value;
-    }
-    get llm() {
-        return this._llm;
-    }
-    set llm(value) {
-        this._llm = value;
-    }
-    get deobfuscator() {
-        return this._deobfuscator;
-    }
-    set deobfuscator(value) {
-        this._deobfuscator = value;
-    }
-    get advancedDeobfuscator() {
-        return this._advancedDeobfuscator;
-    }
-    set advancedDeobfuscator(value) {
-        this._advancedDeobfuscator = value;
-    }
-    get astOptimizer() {
-        return this._astOptimizer;
-    }
-    set astOptimizer(value) {
-        this._astOptimizer = value;
-    }
-    get obfuscationDetector() {
-        return this._obfuscationDetector;
-    }
-    set obfuscationDetector(value) {
-        this._obfuscationDetector = value;
-    }
-    get analyzer() {
-        return this._analyzer;
-    }
-    set analyzer(value) {
-        this._analyzer = value;
-    }
-    get cryptoDetector() {
-        return this._cryptoDetector;
-    }
-    set cryptoDetector(value) {
-        this._cryptoDetector = value;
-    }
-    get hookManager() {
-        return this._hookManager;
-    }
-    set hookManager(value) {
-        this._hookManager = value;
-    }
-    get browserHandlers() {
-        return this._browserHandlers;
-    }
-    set browserHandlers(value) {
-        this._browserHandlers = value;
-    }
-    get debuggerHandlers() {
-        return this._debuggerHandlers;
-    }
-    set debuggerHandlers(value) {
-        this._debuggerHandlers = value;
-    }
-    get advancedHandlers() {
-        return this._advancedHandlers;
-    }
-    set advancedHandlers(value) {
-        this._advancedHandlers = value;
-    }
-    get aiHookHandlers() {
-        return this._aiHookHandlers;
-    }
-    set aiHookHandlers(value) {
-        this._aiHookHandlers = value;
-    }
-    get hookPresetHandlers() {
-        return this._hookPresetHandlers;
-    }
-    set hookPresetHandlers(value) {
-        this._hookPresetHandlers = value;
-    }
-    get coreAnalysisHandlers() {
-        return this._coreAnalysisHandlers;
-    }
-    set coreAnalysisHandlers(value) {
-        this._coreAnalysisHandlers = value;
-    }
-    get coreMaintenanceHandlers() {
-        return this._coreMaintenanceHandlers;
-    }
-    set coreMaintenanceHandlers(value) {
-        this._coreMaintenanceHandlers = value;
-    }
-    get extensionManagementHandlers() {
-        return this._extensionManagementHandlers;
-    }
-    set extensionManagementHandlers(value) {
-        this._extensionManagementHandlers = value;
-    }
-    get processHandlers() {
-        return this._processHandlers;
-    }
-    set processHandlers(value) {
-        this._processHandlers = value;
-    }
-    get workflowHandlers() {
-        return this._workflowHandlers;
-    }
-    set workflowHandlers(value) {
-        this._workflowHandlers = value;
-    }
-    get wasmHandlers() {
-        return this._wasmHandlers;
-    }
-    set wasmHandlers(value) {
-        this._wasmHandlers = value;
-    }
-    get streamingHandlers() {
-        return this._streamingHandlers;
-    }
-    set streamingHandlers(value) {
-        this._streamingHandlers = value;
-    }
-    get encodingHandlers() {
-        return this._encodingHandlers;
-    }
-    set encodingHandlers(value) {
-        this._encodingHandlers = value;
-    }
-    get antidebugHandlers() {
-        return this._antidebugHandlers;
-    }
-    set antidebugHandlers(value) {
-        this._antidebugHandlers = value;
-    }
-    get graphqlHandlers() {
-        return this._graphqlHandlers;
-    }
-    set graphqlHandlers(value) {
-        this._graphqlHandlers = value;
-    }
-    get platformHandlers() {
-        return this._platformHandlers;
-    }
-    set platformHandlers(value) {
-        this._platformHandlers = value;
-    }
-    get sourcemapHandlers() {
-        return this._sourcemapHandlers;
-    }
-    set sourcemapHandlers(value) {
-        this._sourcemapHandlers = value;
-    }
-    get transformHandlers() {
-        return this._transformHandlers;
-    }
-    set transformHandlers(value) {
-        this._transformHandlers = value;
-    }
-}

package/dist/tests/cli/doctor.test.js

@@ -1,32 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const state = vi.hoisted(() => ({
-    runEnvironmentDoctor: vi.fn(),
-    formatEnvironmentDoctorReport: vi.fn(),
-}));
-vi.mock('@utils/environmentDoctor', () => ({
-    runEnvironmentDoctor: state.runEnvironmentDoctor,
-    formatEnvironmentDoctorReport: state.formatEnvironmentDoctorReport,
-}));
-describe('cli/doctor', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-    });
-    it('runs the doctor with bridge health, prints the formatted report, and exits cleanly', async () => {
-        const report = {
-            success: true,
-            generatedAt: '2026-03-15T00:00:00.000Z',
-        };
-        state.runEnvironmentDoctor.mockResolvedValue(report);
-        state.formatEnvironmentDoctorReport.mockReturnValue('formatted report');
-        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
-        const exit = vi.spyOn(process, 'exit').mockImplementation((() => {
-            return undefined;
-        }));
-        await import('../../src/cli/doctor.js');
-        expect(state.runEnvironmentDoctor).toHaveBeenCalledWith({ includeBridgeHealth: true });
-        expect(state.formatEnvironmentDoctorReport).toHaveBeenCalledWith(report);
-        expect(stdoutWrite).toHaveBeenCalledWith('formatted report\n');
-        expect(exit).toHaveBeenCalledWith(0);
-    });
-});

package/dist/tests/constants.test.js

@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-const ORIGINAL_ENV = { ...process.env };
-async function loadConstants(overrides = {}) {
-    vi.resetModules();
-    process.env = { ...ORIGINAL_ENV };
-    for (const [key, value] of Object.entries(overrides)) {
-        if (value === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = value;
-        }
-    }
-    return import('../src/constants.js');
-}
-afterEach(() => {
-    process.env = { ...ORIGINAL_ENV };
-    vi.resetModules();
-});
-describe('constants env parsing', () => {
-    it('parses integer env values with fallback semantics', async () => {
-        expect((await loadConstants({ DEFAULT_DEBUG_PORT: undefined })).DEFAULT_DEBUG_PORT).toBe(9222);
-        expect((await loadConstants({ DEFAULT_DEBUG_PORT: '' })).DEFAULT_DEBUG_PORT).toBe(9222);
-        expect((await loadConstants({ DEFAULT_DEBUG_PORT: 'abc' })).DEFAULT_DEBUG_PORT).toBe(9222);
-        expect((await loadConstants({ DEFAULT_DEBUG_PORT: '1337' })).DEFAULT_DEBUG_PORT).toBe(1337);
-    });
-    it('parses float env values with fallback semantics', async () => {
-        expect((await loadConstants({ SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: undefined }))
-            .SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER).toBe(1.5);
-        expect((await loadConstants({ SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: '' }))
-            .SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER).toBe(1.5);
-        expect((await loadConstants({ SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: 'abc' }))
-            .SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER).toBe(1.5);
-        expect((await loadConstants({ SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: '2.25' }))
-            .SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER).toBe(2.25);
-    });
-    it('parses boolean env values for ENABLE_INJECTION_TOOLS', async () => {
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: undefined })).ENABLE_INJECTION_TOOLS).toBe(true);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: '' })).ENABLE_INJECTION_TOOLS).toBe(true);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: '1' })).ENABLE_INJECTION_TOOLS).toBe(true);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: ' TRUE ' })).ENABLE_INJECTION_TOOLS).toBe(true);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: '0' })).ENABLE_INJECTION_TOOLS).toBe(false);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: 'false' })).ENABLE_INJECTION_TOOLS).toBe(false);
-        expect((await loadConstants({ ENABLE_INJECTION_TOOLS: 'maybe' })).ENABLE_INJECTION_TOOLS).toBe(true);
-    });
-    it('parses string env values with fallback semantics', async () => {
-        expect((await loadConstants({ GHIDRA_BRIDGE_URL: undefined })).GHIDRA_BRIDGE_ENDPOINT).toBe('http://127.0.0.1:18080');
-        expect((await loadConstants({ GHIDRA_BRIDGE_URL: '' })).GHIDRA_BRIDGE_ENDPOINT).toBe('http://127.0.0.1:18080');
-        expect((await loadConstants({ GHIDRA_BRIDGE_URL: 'https://vmoranv.github.io/jshookmcp/test' })).GHIDRA_BRIDGE_ENDPOINT).toBe('https://vmoranv.github.io/jshookmcp/test');
-    });
-    it('parses numeric lists and drops invalid entries without falling back', async () => {
-        expect((await loadConstants({ DEBUG_PORT_CANDIDATES: '' })).DEBUG_PORT_CANDIDATES).toEqual([
-            9222, 9229, 9333, 2039,
-        ]);
-        expect((await loadConstants({ DEBUG_PORT_CANDIDATES: '9333,foo,9444' })).DEBUG_PORT_CANDIDATES).toEqual([
-            9333, 9444,
-        ]);
-        expect((await loadConstants({ DEBUG_PORT_CANDIDATES: 'foo,bar' })).DEBUG_PORT_CANDIDATES).toEqual([]);
-    });
-    it('parses csv tiers with normalization and fallback semantics', async () => {
-        expect((await loadConstants({ SEARCH_WORKFLOW_BOOST_TIERS: undefined })).SEARCH_WORKFLOW_BOOST_TIERS).toEqual(new Set(['workflow', 'full']));
-        expect((await loadConstants({ SEARCH_WORKFLOW_BOOST_TIERS: ' Workflow , FULL ' })).SEARCH_WORKFLOW_BOOST_TIERS).toEqual(new Set(['workflow', 'full']));
-        expect((await loadConstants({ SEARCH_WORKFLOW_BOOST_TIERS: ' , , ' })).SEARCH_WORKFLOW_BOOST_TIERS).toEqual(new Set(['workflow', 'full']));
-    });
-    it('prefers the primary captcha solver url and trims both env variants', async () => {
-        expect((await loadConstants({
-            CAPTCHA_SOLVER_BASE_URL: ' https://vmoranv.github.io/jshookmcp/captcha-a ',
-            CAPTCHA_2CAPTCHA_BASE_URL: 'https://vmoranv.github.io/jshookmcp/captcha-b',
-        })).CAPTCHA_SOLVER_BASE_URL).toBe('https://vmoranv.github.io/jshookmcp/captcha-a');
-        expect((await loadConstants({
-            CAPTCHA_SOLVER_BASE_URL: '   ',
-            CAPTCHA_2CAPTCHA_BASE_URL: ' https://vmoranv.github.io/jshookmcp/captcha-b ',
-        })).CAPTCHA_SOLVER_BASE_URL).toBe('https://vmoranv.github.io/jshookmcp/captcha-b');
-        expect((await loadConstants({
-            CAPTCHA_SOLVER_BASE_URL: undefined,
-            CAPTCHA_2CAPTCHA_BASE_URL: undefined,
-        })).CAPTCHA_SOLVER_BASE_URL).toBe('');
-    });
-    it('trims extension registry urls and collapses blank values', async () => {
-        expect((await loadConstants({ EXTENSION_REGISTRY_BASE_URL: ' https://vmoranv.github.io/jshookmcp/registry ' }))
-            .EXTENSION_REGISTRY_BASE_URL).toBe('https://vmoranv.github.io/jshookmcp/registry');
-        expect((await loadConstants({ EXTENSION_REGISTRY_BASE_URL: '   ' })).EXTENSION_REGISTRY_BASE_URL).toBe('');
-    });
-    it('preserves direct parseFloat behavior for CACHE_LOW_HIT_RATE_THRESHOLD', async () => {
-        expect((await loadConstants({ CACHE_LOW_HIT_RATE_THRESHOLD: undefined })).CACHE_LOW_HIT_RATE_THRESHOLD).toBe(0.3);
-        expect((await loadConstants({ CACHE_LOW_HIT_RATE_THRESHOLD: '0.75' })).CACHE_LOW_HIT_RATE_THRESHOLD).toBe(0.75);
-        expect(Number.isNaN((await loadConstants({ CACHE_LOW_HIT_RATE_THRESHOLD: 'abc' })).CACHE_LOW_HIT_RATE_THRESHOLD)).toBe(true);
-    });
-});

package/dist/tests/contracts/contracts.test.js

@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createWorkflow, ToolNodeBuilder, SequenceNodeBuilder, ParallelNodeBuilder, BranchNodeBuilder, } from '../../src/server/workflows/WorkflowContract.js';
-import { NoopInstrumentation, SpanNames, MetricNames, } from '../../src/server/observability/InstrumentationContract.js';
-describe('WorkflowContract - builder helpers', () => {
-    it('ToolNodeBuilder creates a ToolNode with kind=tool', () => {
-        const node = new ToolNodeBuilder('step1', 'my_tool').build();
-        expect(node.kind).toBe('tool');
-        expect(node.id).toBe('step1');
-        expect(node.toolName).toBe('my_tool');
-        expect(node.input).toBeUndefined();
-    });
-    it('ToolNodeBuilder accepts options', () => {
-        const node = new ToolNodeBuilder('step2', 'tool2')
-            .input({ key: 'value' })
-            .retry({ maxAttempts: 3, backoffMs: 1000, multiplier: 2 })
-            .timeout(5000)
-            .build();
-        expect(node.input).toEqual({ key: 'value' });
-        expect(node.retry?.maxAttempts).toBe(3);
-        expect(node.timeoutMs).toBe(5000);
-    });
-    it('SequenceNodeBuilder creates a SequenceNode', () => {
-        const node = new SequenceNodeBuilder('seq1')
-            .tool('a', 'tool_a')
-            .build();
-        expect(node.kind).toBe('sequence');
-        expect(node.steps).toHaveLength(1);
-        expect(node.steps[0].id).toBe('a');
-        expect(node.steps[0].toolName).toBe('tool_a');
-    });
-    it('ParallelNodeBuilder creates a ParallelNode with defaults', () => {
-        const node = new ParallelNodeBuilder('par1')
-            .tool('a', 'tool_a')
-            .tool('b', 'tool_b')
-            .build();
-        expect(node.kind).toBe('parallel');
-        expect(node.maxConcurrency).toBe(4);
-        expect(node.failFast).toBe(false);
-    });
-    it('ParallelNodeBuilder accepts custom concurrency and failFast', () => {
-        const node = new ParallelNodeBuilder('par2')
-            .maxConcurrency(2)
-            .failFast(true)
-            .build();
-        expect(node.maxConcurrency).toBe(2);
-        expect(node.failFast).toBe(true);
-    });
-    it('BranchNodeBuilder creates a BranchNode with predicateId', () => {
-        const node = new BranchNodeBuilder('br1', 'my_predicate')
-            .whenTrue(new ToolNodeBuilder('t', 'tool_t'))
-            .whenFalse(new ToolNodeBuilder('f', 'tool_f'))
-            .build();
-        expect(node.kind).toBe('branch');
-        expect(node.predicateId).toBe('my_predicate');
-        expect(node.whenTrue.id).toBe('t');
-        expect(node.whenFalse?.id).toBe('f');
-        expect(node.predicateFn).toBeUndefined();
-    });
-    it('BranchNodeBuilder accepts optional predicateFn', () => {
-        const fn = () => true;
-        const node = new BranchNodeBuilder('br2', 'pred')
-            .whenTrue(new ToolNodeBuilder('t', 'tool_t'))
-            .predicateFn(fn)
-            .build();
-        expect(node.predicateFn).toBe(fn);
-        expect(node.whenFalse).toBeUndefined();
-    });
-});
-describe('WorkflowContract - node composition', () => {
-    it('nodes can be nested arbitrarily', () => {
-        const root = new SequenceNodeBuilder('root')
-            .parallel('par', (b) => b
-            .tool('leaf1', 'tool_leaf')
-            .branch('br', 'check', (b) => b
-            .whenTrue(new ToolNodeBuilder('leaf2', 'tool_leaf'))))
-            .tool('leaf3', 'tool_leaf')
-            .build();
-        expect(root.kind).toBe('sequence');
-        expect(root.steps[0].kind).toBe('parallel');
-        expect(root.steps[0].steps[1].kind).toBe('branch');
-    });
-    it('createWorkflow builds a valid contract', () => {
-        const contract = createWorkflow('wf1', 'Test Workflow')
-            .description('A test')
-            .timeoutMs(10000)
-            .buildGraph(() => new ToolNodeBuilder('root', 'my_tool'))
-            .build();
-        expect(contract.kind).toBe('workflow-contract');
-        expect(contract.id).toBe('wf1');
-        expect(contract.displayName).toBe('Test Workflow');
-        expect(contract.timeoutMs).toBe(10000);
-        expect(contract.build({}).kind).toBe('tool');
-    });
-});
-describe('InstrumentationContract - NoopInstrumentation', () => {
-    it('startSpan returns a SpanLike that does not throw', () => {
-        const noop = new NoopInstrumentation();
-        const span = noop.startSpan('test.span', { key: 'value' });
-        expect(span.name).toBe('test.span');
-        expect(span.startTime).toBeGreaterThan(0);
-        expect(() => span.addEvent('event')).not.toThrow();
-        expect(() => span.end()).not.toThrow();
-    });
-    it('emitMetric does not throw', () => {
-        const noop = new NoopInstrumentation();
-        expect(() => noop.emitMetric('test_metric', 1, 'counter')).not.toThrow();
-        expect(() => noop.emitMetric('test_metric', 42, 'gauge', { dim: 'a' })).not.toThrow();
-        expect(() => noop.emitMetric('test_metric', 1.5, 'histogram')).not.toThrow();
-    });
-});
-describe('InstrumentationContract - well-known names', () => {
-    it('SpanNames contains expected keys', () => {
-        expect(SpanNames.toolExecute).toBe('tool.execute');
-        expect(SpanNames.pluginLifecycle).toBe('plugin.lifecycle');
-        expect(SpanNames.workflowRun).toBe('workflow.run');
-        expect(SpanNames.bridgeRequest).toBe('bridge.request');
-        expect(SpanNames.captchaSolve).toBe('captcha.solve');
-    });
-    it('MetricNames contains expected keys', () => {
-        expect(MetricNames.toolCallsTotal).toBe('tool_calls_total');
-        expect(MetricNames.workflowRunsTotal).toBe('workflow_runs_total');
-        expect(MetricNames.bridgeRequestsTotal).toBe('bridge_requests_total');
-        expect(MetricNames.pluginActiveTotal).toBe('plugin_active_total');
-    });
-});

package/dist/tests/e2e/context-capture.d.ts

@@ -1,2 +0,0 @@
-import type { E2EContext } from '../e2e/helpers/types.js';
-export declare function applyContextCapture(toolName: string, parsed: unknown, ctx: E2EContext, overrides: Record<string, Record<string, unknown>>): void;

package/dist/tests/e2e/context-capture.js

@@ -1,55 +0,0 @@
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-export function applyContextCapture(toolName, parsed, ctx, overrides) {
-    if (toolName === 'get_all_scripts' && isRecord(parsed) && Array.isArray(parsed.scripts) && parsed.scripts.length > 0) {
-        const firstScript = parsed.scripts[0];
-        if (firstScript.scriptId !== undefined) {
-            ctx.scriptId = String(firstScript.scriptId);
-        }
-    }
-    if (toolName === 'breakpoint_set' && isRecord(parsed)) {
-        const breakpoint = isRecord(parsed.breakpoint) ? parsed.breakpoint : undefined;
-        const breakpointId = parsed.breakpointId ?? breakpoint?.breakpointId;
-        if (breakpointId != null) {
-            ctx.breakpointId = String(breakpointId);
-            overrides.breakpoint_remove = { breakpointId: ctx.breakpointId };
-        }
-    }
-    if (toolName === 'network_get_requests' && isRecord(parsed) && Array.isArray(parsed.requests) && parsed.requests.length > 0) {
-        const first = parsed.requests[0];
-        if (first.requestId != null) {
-            ctx.requestId = String(first.requestId);
-            overrides.network_get_response_body = { requestId: ctx.requestId };
-            overrides.network_replay_request = { requestId: ctx.requestId };
-        }
-    }
-    if (toolName === 'ai_hook_generate' && isRecord(parsed)) {
-        const hookId = parsed.hookId ?? parsed.id;
-        if (hookId != null) {
-            ctx.hookId = String(hookId);
-            overrides.ai_hook_inject = { hookId: ctx.hookId };
-            overrides.ai_hook_toggle = { hookId: ctx.hookId, enabled: true };
-            overrides.ai_hook_get_data = { hookId: ctx.hookId };
-        }
-    }
-    if (toolName === 'get_scope_variables_enhanced' && isRecord(parsed) && Array.isArray(parsed.variables)) {
-        const objVar = parsed.variables.find((v) => v.objectId != null);
-        if (objVar) {
-            ctx.objectId = String(objVar.objectId);
-            overrides.get_object_properties = { objectId: ctx.objectId };
-        }
-    }
-    if (toolName === 'watch_add' && isRecord(parsed)) {
-        overrides.watch_remove = { id: String(parsed.id ?? parsed.watchId ?? '0') };
-    }
-    if (toolName === 'xhr_breakpoint_set' && isRecord(parsed)) {
-        overrides.xhr_breakpoint_remove = { id: String(parsed.id ?? parsed.breakpointId ?? '0') };
-    }
-    if (toolName === 'event_breakpoint_set' && isRecord(parsed)) {
-        overrides.event_breakpoint_remove = { id: String(parsed.id ?? parsed.breakpointId ?? '0') };
-    }
-    if (toolName === 'blackbox_add_common' && isRecord(parsed) && Array.isArray(parsed.added) && parsed.added.length > 0) {
-        overrides.blackbox_add = { pattern: parsed.added[0] };
-    }
-}