@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/server/domains/browser/human-behavior.test.js

@@ -0,0 +1,155 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { handleHumanMouse, handleHumanScroll, handleHumanTyping, } from '../../../../src/server/domains/browser/handlers/human-behavior.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+function createMockCollector(hasPage = true) {
+    const mouse = { move: vi.fn(), click: vi.fn() };
+    const keyboard = { type: vi.fn(), press: vi.fn() };
+    const page = hasPage
+        ? {
+            mouse,
+            keyboard,
+            click: vi.fn(),
+            evaluate: vi.fn().mockResolvedValue(null),
+            url: () => 'http://test.local',
+        }
+        : null;
+    return {
+        collector: { getActivePage: vi.fn().mockResolvedValue(page) },
+        page,
+        mouse,
+        keyboard,
+    };
+}
+async function runWithFakeTimers(fn) {
+    vi.useFakeTimers();
+    const promise = fn();
+    let resolved = false;
+    let result;
+    let error;
+    promise.then((r) => { resolved = true; result = r; }, (e) => { resolved = true; error = e; });
+    while (!resolved) {
+        await vi.advanceTimersByTimeAsync(1000);
+    }
+    vi.useRealTimers();
+    if (error)
+        throw error;
+    return result;
+}
+describe('handleHumanMouse', () => {
+    afterEach(() => { vi.useRealTimers(); });
+    it('throws when no active page', async () => {
+        const { collector } = createMockCollector(false);
+        await expect(handleHumanMouse({ toX: 100, toY: 100 }, collector)).rejects.toThrow(/No active page/);
+    });
+    it('throws when neither selector nor coordinates provided', async () => {
+        const { collector } = createMockCollector(true);
+        await expect(handleHumanMouse({}, collector)).rejects.toThrow(/selector.*toX\/toY/i);
+    });
+    it('clamps steps to [1, 500]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanMouse({ toX: 100, toY: 100, steps: 0 }, collector));
+        expect(parseJson(result).steps).toBe(1);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanMouse({ toX: 100, toY: 100, steps: 999 }, c2));
+        expect(parseJson(result2).steps).toBe(500);
+    }, 30_000);
+    it('clamps durationMs to [10, 30000]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanMouse({ toX: 100, toY: 100, durationMs: 0, steps: 1 }, collector));
+        expect(parseJson(result).durationMs).toBe(10);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanMouse({ toX: 100, toY: 100, durationMs: 99999, steps: 1 }, c2));
+        expect(parseJson(result2).durationMs).toBe(30000);
+    }, 30_000);
+    it('moves mouse and reports success', async () => {
+        const { collector, mouse } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanMouse({ fromX: 0, fromY: 0, toX: 100, toY: 200, steps: 2 }, collector));
+        const parsed = parseJson(result);
+        expect(parsed.success).toBe(true);
+        expect(parsed.to).toEqual({ x: 100, y: 200 });
+        expect(mouse.move).toHaveBeenCalled();
+    });
+    it('clicks when click=true', async () => {
+        const { collector, mouse } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanMouse({ toX: 50, toY: 50, click: true, steps: 1 }, collector));
+        const parsed = parseJson(result);
+        expect(parsed.clicked).toBe(true);
+        expect(mouse.click).toHaveBeenCalledWith(50, 50);
+    });
+    it('resolves selector to coordinates', async () => {
+        const { collector, page } = createMockCollector(true);
+        page.evaluate.mockResolvedValueOnce({ x: 200, y: 300 });
+        const result = await runWithFakeTimers(() => handleHumanMouse({ selector: '#btn', steps: 1 }, collector));
+        const parsed = parseJson(result);
+        expect(parsed.success).toBe(true);
+        expect(parsed.to).toEqual({ x: 200, y: 300 });
+    });
+});
+describe('handleHumanScroll', () => {
+    afterEach(() => { vi.useRealTimers(); });
+    it('throws when no active page', async () => {
+        const { collector } = createMockCollector(false);
+        await expect(handleHumanScroll({}, collector)).rejects.toThrow(/No active page/);
+    });
+    it('clamps distance to [1, 10000]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanScroll({ distance: -5, segments: 1 }, collector));
+        expect(parseJson(result).requestedDistance).toBe(1);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanScroll({ distance: 99999, segments: 1 }, c2));
+        expect(parseJson(result2).requestedDistance).toBe(10000);
+    });
+    it('clamps segments to [1, 200]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanScroll({ segments: 0 }, collector));
+        expect(parseJson(result).segments).toBe(1);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanScroll({ segments: 999 }, c2));
+        expect(parseJson(result2).segments).toBe(200);
+    }, 30_000);
+    it('scrolls and reports success', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanScroll({ distance: 300, direction: 'down', segments: 2 }, collector));
+        const parsed = parseJson(result);
+        expect(parsed.success).toBe(true);
+        expect(parsed.direction).toBe('down');
+        expect(parsed.actualScrolled).toBeGreaterThan(0);
+    });
+});
+describe('handleHumanTyping', () => {
+    afterEach(() => { vi.useRealTimers(); });
+    it('throws when no active page', async () => {
+        const { collector } = createMockCollector(false);
+        await expect(handleHumanTyping({ selector: '#input', text: 'hi' }, collector)).rejects.toThrow(/No active page/);
+    });
+    it('requires selector and text', async () => {
+        const { collector } = createMockCollector(true);
+        await expect(handleHumanTyping({}, collector)).rejects.toThrow(/selector.*text/i);
+    });
+    it('clamps wpm to [10, 300]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanTyping({ selector: '#in', text: 'a', wpm: 1 }, collector));
+        expect(parseJson(result).wpm).toBe(10);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanTyping({ selector: '#in', text: 'a', wpm: 999 }, c2));
+        expect(parseJson(result2).wpm).toBe(300);
+    });
+    it('clamps errorRate to [0, 0.3]', async () => {
+        const { collector } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanTyping({ selector: '#in', text: 'a', errorRate: -1 }, collector));
+        expect(parseJson(result).errorRate).toBe(0);
+        const { collector: c2 } = createMockCollector(true);
+        const result2 = await runWithFakeTimers(() => handleHumanTyping({ selector: '#in', text: 'a', errorRate: 0.9 }, c2));
+        expect(parseJson(result2).errorRate).toBeCloseTo(0.3);
+    });
+    it('types text and reports success', async () => {
+        const { collector, keyboard } = createMockCollector(true);
+        const result = await runWithFakeTimers(() => handleHumanTyping({ selector: '#in', text: 'hi', errorRate: 0 }, collector));
+        const parsed = parseJson(result);
+        expect(parsed.success).toBe(true);
+        expect(parsed.length).toBe(2);
+        expect(keyboard.type).toHaveBeenCalled();
+    });
+});

package/dist/tests/server/domains/browser/page-evaluation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/page-evaluation.test.js

@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PageEvaluationHandlers } from '../../../../src/server/domains/browser/handlers/page-evaluation.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('PageEvaluationHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('waits for selector through camoufox page when camoufox is active', async () => {
+        const page = {
+            waitForSelector: vi.fn(async () => { }),
+            evaluate: vi.fn(async () => ({
+                tagName: 'button',
+                id: 'submit',
+                className: 'primary',
+                textContent: 'Submit',
+                attributes: { type: 'submit' },
+            })),
+        };
+        const pageController = {
+            waitForSelector: vi.fn(),
+        };
+        const handlers = new PageEvaluationHandlers({
+            pageController,
+            detailedDataManager: { smartHandle: vi.fn((value) => value) },
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePageWaitForSelector({ selector: '#submit', timeout: 1500 }));
+        expect(page.waitForSelector).toHaveBeenCalledWith('#submit', { timeout: 1500 });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(pageController.waitForSelector).not.toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.element?.id).toBe('submit');
+    });
+});

package/dist/tests/server/domains/browser/page-interaction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/page-interaction.test.js

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PageInteractionHandlers } from '../../../../src/server/domains/browser/handlers/page-interaction.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('PageInteractionHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    function createCamoufoxPage() {
+        return {
+            click: vi.fn(async () => { }),
+            fill: vi.fn(async () => { }),
+            hover: vi.fn(async () => { }),
+            selectOption: vi.fn(async () => ['primary']),
+            evaluate: vi.fn(async () => undefined),
+            keyboard: {
+                press: vi.fn(async () => { }),
+            },
+        };
+    }
+    it('routes page_select to camoufox when camoufox is active', async () => {
+        const page = createCamoufoxPage();
+        const pageController = { select: vi.fn() };
+        const handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePageSelect({ selector: '#plan', values: ['primary'] }));
+        expect(page.selectOption).toHaveBeenCalledWith('#plan', ['primary']);
+        expect(pageController.select).not.toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('routes page_hover to camoufox when camoufox is active', async () => {
+        const page = createCamoufoxPage();
+        const pageController = { hover: vi.fn() };
+        const handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePageHover({ selector: '#menu' }));
+        expect(page.hover).toHaveBeenCalledWith('#menu');
+        expect(pageController.hover).not.toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('routes page_scroll to camoufox when camoufox is active', async () => {
+        const page = createCamoufoxPage();
+        const pageController = { scroll: vi.fn() };
+        const handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePageScroll({ x: 10, y: 20 }));
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(page.evaluate.mock.calls[0]?.[1]).toEqual({ x: 10, y: 20 });
+        expect(pageController.scroll).not.toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+    it('routes page_press_key to camoufox keyboard when camoufox is active', async () => {
+        const page = createCamoufoxPage();
+        const pageController = { pressKey: vi.fn() };
+        const handlers = new PageInteractionHandlers({
+            pageController,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePagePressKey({ key: 'Enter' }));
+        expect(page.keyboard.press).toHaveBeenCalledWith('Enter');
+        expect(pageController.pressKey).not.toHaveBeenCalled();
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+    });
+});

package/dist/tests/server/domains/browser/page-navigation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/page-navigation.test.js

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { PageNavigationHandlers } from '../../../../src/server/domains/browser/handlers/page-navigation.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('PageNavigationHandlers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('does not claim captcha_detected for chrome navigation without running detection', async () => {
+        const pageController = {
+            navigate: vi.fn(async () => ({ url: 'https://target.example', title: 'Target', loadTime: 12 })),
+            getURL: vi.fn(async () => 'https://target.example'),
+            getTitle: vi.fn(async () => 'Target'),
+        };
+        const consoleMonitor = {
+            enable: vi.fn(async () => { }),
+            isNetworkEnabled: vi.fn(() => false),
+            setPlaywrightPage: vi.fn(),
+        };
+        const handlers = new PageNavigationHandlers({
+            pageController,
+            consoleMonitor,
+            getActiveDriver: () => 'chrome',
+            getCamoufoxPage: async () => null,
+        });
+        const body = parseJson(await handlers.handlePageNavigate({ url: 'https://target.example' }));
+        expect(body.success).toBe(true);
+        expect(body.url).toBe('https://target.example');
+        expect(body).not.toHaveProperty('captcha_detected');
+    });
+    it('does not claim captcha_detected for camoufox navigation without running detection', async () => {
+        const page = {
+            goto: vi.fn(async () => { }),
+            url: vi.fn(() => 'https://target.example'),
+            title: vi.fn(async () => 'Camoufox Target'),
+        };
+        const consoleMonitor = {
+            enable: vi.fn(async () => { }),
+            isNetworkEnabled: vi.fn(() => false),
+            setPlaywrightPage: vi.fn(),
+        };
+        const handlers = new PageNavigationHandlers({
+            pageController: {},
+            consoleMonitor,
+            getActiveDriver: () => 'camoufox',
+            getCamoufoxPage: async () => page,
+        });
+        const body = parseJson(await handlers.handlePageNavigate({ url: 'https://target.example' }));
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.url).toBe('https://target.example');
+        expect(body).not.toHaveProperty('captcha_detected');
+    });
+});

package/dist/tests/server/domains/browser/security-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/security-tools.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { browserSecurityStateTools } from '../../../../src/server/domains/browser/definitions.tools.security.js';
+function getTool(name) {
+    const tool = browserSecurityStateTools.find((entry) => entry.name === name);
+    expect(tool).toBeDefined();
+    return tool;
+}
+describe('browserSecurityStateTools', () => {
+    it('describes captcha_detect using screenshotPath instead of base64 screenshots', () => {
+        const tool = getTool('captcha_detect');
+        expect(tool.description).toContain('screenshotPath');
+        expect(tool.description).not.toContain('the screenshot is provided as base64');
+        expect(tool.description).not.toContain('- screenshot: base64 screenshot');
+    });
+    it('does not claim captcha_wait switches browser modes automatically', () => {
+        const tool = getTool('captcha_wait');
+        expect(tool.description).toContain('does not switch browser modes on its own');
+        expect(tool.description).not.toContain('Browser switches to headed (visible) mode');
+    });
+    it('does not promise automatic CAPTCHA detection after page_navigate in captcha_config', () => {
+        const tool = getTool('captcha_config');
+        expect(tool.description).not.toContain('auto-detect CAPTCHA after page_navigate');
+        expect(tool.description).toContain('browser-mode integrations');
+    });
+});

package/dist/tests/server/domains/debugger/handlers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/debugger/handlers.test.js

@@ -0,0 +1,181 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { debuggerControl, debuggerStepping, debuggerEvaluate, debuggerState, sessionManagement, breakpointBasic, breakpointException, xhrBreakpoint, eventBreakpoint, watchExpressions, scopeInspection, blackbox, ctorSpies, } = vi.hoisted(() => ({
+    debuggerControl: {
+        handleDebuggerEnable: vi.fn(async (args) => ({ from: 'control-enable', args })),
+        handleDebuggerDisable: vi.fn(async (args) => ({ from: 'control-disable', args })),
+        handleDebuggerPause: vi.fn(async (args) => ({ from: 'control-pause', args })),
+        handleDebuggerResume: vi.fn(async (args) => ({ from: 'control-resume', args })),
+    },
+    debuggerStepping: {
+        handleDebuggerStepInto: vi.fn(async (args) => ({ from: 'step-into', args })),
+        handleDebuggerStepOver: vi.fn(async (args) => ({ from: 'step-over', args })),
+        handleDebuggerStepOut: vi.fn(async (args) => ({ from: 'step-out', args })),
+    },
+    debuggerEvaluate: {
+        handleDebuggerEvaluate: vi.fn(async (args) => ({ from: 'eval', args })),
+        handleDebuggerEvaluateGlobal: vi.fn(async (args) => ({ from: 'eval-global', args })),
+    },
+    debuggerState: {
+        handleDebuggerWaitForPaused: vi.fn(async (args) => ({ from: 'wait-paused', args })),
+        handleDebuggerGetPausedState: vi.fn(async (args) => ({ from: 'paused-state', args })),
+        handleGetCallStack: vi.fn(async (args) => ({ from: 'call-stack', args })),
+    },
+    sessionManagement: {
+        handleSaveSession: vi.fn(async (args) => ({ from: 'save-session', args })),
+        handleLoadSession: vi.fn(async (args) => ({ from: 'load-session', args })),
+        handleExportSession: vi.fn(async (args) => ({ from: 'export-session', args })),
+        handleListSessions: vi.fn(async (args) => ({ from: 'list-session', args })),
+    },
+    breakpointBasic: {
+        handleBreakpointSet: vi.fn(async (args) => ({ from: 'bp-set', args })),
+        handleBreakpointRemove: vi.fn(async (args) => ({ from: 'bp-remove', args })),
+        handleBreakpointList: vi.fn(async (args) => ({ from: 'bp-list', args })),
+    },
+    breakpointException: {
+        handleBreakpointSetOnException: vi.fn(async (args) => ({ from: 'bp-exception', args })),
+    },
+    xhrBreakpoint: {
+        handleXHRBreakpointSet: vi.fn(async (args) => ({ from: 'xhr-set', args })),
+        handleXHRBreakpointRemove: vi.fn(async (args) => ({ from: 'xhr-remove', args })),
+        handleXHRBreakpointList: vi.fn(async (args) => ({ from: 'xhr-list', args })),
+    },
+    eventBreakpoint: {
+        handleEventBreakpointSet: vi.fn(async (args) => ({ from: 'event-set', args })),
+        handleEventBreakpointSetCategory: vi.fn(async (args) => ({ from: 'event-category', args })),
+        handleEventBreakpointRemove: vi.fn(async (args) => ({ from: 'event-remove', args })),
+        handleEventBreakpointList: vi.fn(async (args) => ({ from: 'event-list', args })),
+    },
+    watchExpressions: {
+        handleWatchAdd: vi.fn(async (args) => ({ from: 'watch-add', args })),
+        handleWatchRemove: vi.fn(async (args) => ({ from: 'watch-remove', args })),
+        handleWatchList: vi.fn(async (args) => ({ from: 'watch-list', args })),
+        handleWatchEvaluateAll: vi.fn(async (args) => ({ from: 'watch-eval', args })),
+        handleWatchClearAll: vi.fn(async (args) => ({ from: 'watch-clear', args })),
+    },
+    scopeInspection: {
+        handleGetScopeVariablesEnhanced: vi.fn(async (args) => ({ from: 'scope-vars', args })),
+        handleGetObjectProperties: vi.fn(async (args) => ({ from: 'obj-props', args })),
+    },
+    blackbox: {
+        handleBlackboxAdd: vi.fn(async (args) => ({ from: 'blackbox-add', args })),
+        handleBlackboxAddCommon: vi.fn(async (args) => ({ from: 'blackbox-common', args })),
+        handleBlackboxList: vi.fn(async (args) => ({ from: 'blackbox-list', args })),
+    },
+    ctorSpies: {
+        control: vi.fn(),
+        stepping: vi.fn(),
+        evaluate: vi.fn(),
+        state: vi.fn(),
+        session: vi.fn(),
+        basic: vi.fn(),
+        exception: vi.fn(),
+        xhr: vi.fn(),
+        event: vi.fn(),
+        watch: vi.fn(),
+        scope: vi.fn(),
+        blackbox: vi.fn(),
+    },
+}));
+function classFactory(spy, instance) {
+    return class {
+        constructor(deps) {
+            spy(deps);
+            return instance;
+        }
+    };
+}
+vi.mock('@src/server/domains/debugger/handlers/debugger-control', () => ({
+    DebuggerControlHandlers: classFactory(ctorSpies.control, debuggerControl),
+}));
+vi.mock('@src/server/domains/debugger/handlers/debugger-stepping', () => ({
+    DebuggerSteppingHandlers: classFactory(ctorSpies.stepping, debuggerStepping),
+}));
+vi.mock('@src/server/domains/debugger/handlers/debugger-evaluate', () => ({
+    DebuggerEvaluateHandlers: classFactory(ctorSpies.evaluate, debuggerEvaluate),
+}));
+vi.mock('@src/server/domains/debugger/handlers/debugger-state', () => ({
+    DebuggerStateHandlers: classFactory(ctorSpies.state, debuggerState),
+}));
+vi.mock('@src/server/domains/debugger/handlers/session-management', () => ({
+    SessionManagementHandlers: classFactory(ctorSpies.session, sessionManagement),
+}));
+vi.mock('@src/server/domains/debugger/handlers/breakpoint-basic', () => ({
+    BreakpointBasicHandlers: classFactory(ctorSpies.basic, breakpointBasic),
+}));
+vi.mock('@src/server/domains/debugger/handlers/breakpoint-exception', () => ({
+    BreakpointExceptionHandlers: classFactory(ctorSpies.exception, breakpointException),
+}));
+vi.mock('@src/server/domains/debugger/handlers/xhr-breakpoint', () => ({
+    XHRBreakpointHandlers: classFactory(ctorSpies.xhr, xhrBreakpoint),
+}));
+vi.mock('@src/server/domains/debugger/handlers/event-breakpoint', () => ({
+    EventBreakpointHandlers: classFactory(ctorSpies.event, eventBreakpoint),
+}));
+vi.mock('@src/server/domains/debugger/handlers/watch-expressions', () => ({
+    WatchExpressionsHandlers: classFactory(ctorSpies.watch, watchExpressions),
+}));
+vi.mock('@src/server/domains/debugger/handlers/scope-inspection', () => ({
+    ScopeInspectionHandlers: classFactory(ctorSpies.scope, scopeInspection),
+}));
+vi.mock('@src/server/domains/debugger/handlers/blackbox-handlers', () => ({
+    BlackboxHandlers: classFactory(ctorSpies.blackbox, blackbox),
+}));
+import { DebuggerToolHandlers } from '../../../../src/server/domains/debugger/handlers.js';
+describe('DebuggerToolHandlers', () => {
+    const debuggerManager = { id: 'dm' };
+    const runtimeInspector = { id: 'ri' };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('constructs all sub-handlers with dependencies', () => {
+        new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        expect(ctorSpies.control).toHaveBeenCalledOnce();
+        expect(ctorSpies.stepping).toHaveBeenCalledOnce();
+        expect(ctorSpies.blackbox).toHaveBeenCalledOnce();
+    });
+    it('delegates debugger_enable', async () => {
+        const handlers = new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        const args = { x: 1 };
+        await expect(handlers.handleDebuggerEnable(args)).resolves.toEqual({
+            from: 'control-enable',
+            args,
+        });
+        expect(debuggerControl.handleDebuggerEnable).toHaveBeenCalledWith(args);
+    });
+    it('delegates debugger_step_over', async () => {
+        const handlers = new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        const args = { count: 2 };
+        await expect(handlers.handleDebuggerStepOver(args)).resolves.toEqual({
+            from: 'step-over',
+            args,
+        });
+        expect(debuggerStepping.handleDebuggerStepOver).toHaveBeenCalledWith(args);
+    });
+    it('delegates save_session', async () => {
+        const handlers = new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        const args = { name: 's1' };
+        await expect(handlers.handleSaveSession(args)).resolves.toEqual({
+            from: 'save-session',
+            args,
+        });
+        expect(sessionManagement.handleSaveSession).toHaveBeenCalledWith(args);
+    });
+    it('delegates watch_evaluate_all', async () => {
+        const handlers = new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        const args = {};
+        await expect(handlers.handleWatchEvaluateAll(args)).resolves.toEqual({
+            from: 'watch-eval',
+            args,
+        });
+        expect(watchExpressions.handleWatchEvaluateAll).toHaveBeenCalledWith(args);
+    });
+    it('delegates blackbox_list', async () => {
+        const handlers = new DebuggerToolHandlers(debuggerManager, runtimeInspector);
+        const args = {};
+        await expect(handlers.handleBlackboxList(args)).resolves.toEqual({
+            from: 'blackbox-list',
+            args,
+        });
+        expect(blackbox.handleBlackboxList).toHaveBeenCalledWith(args);
+    });
+});

package/dist/tests/server/domains/encoding/analysis.test.d.ts

@@ -0,0 +1 @@
+export {};