@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/antidebug/exports.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
+describe('server/domains/antidebug exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes anti-debug tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'antidebug',
+            definitionExportNames: ['antidebugTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/antidebug/definitions.js'),
+            getToolArrays: (module) => [
+                module.antidebugTools,
+            ],
+            loadManifest: () => import('../../../../src/server/domains/antidebug/manifest.js'),
+        });
+    });
+});

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

@@ -63,4 +63,148 @@ describe('AntiDebugToolHandlers', () => {
         expect(body.count).toBe(0);
         expect(body.protections).toEqual([]);
     });
+    describe('handleAntiDebugBypassAll', () => {
+        it('injects all bypass scripts with persistence by default', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassAll({}));
+            expect(body.success).toBe(true);
+            expect(body.tool).toBe('antidebug_bypass_all');
+            expect(body.persistent).toBe(true);
+            expect(body.injectedCount).toBe(4);
+            expect(body.injected).toEqual([
+                'bypassDebuggerStatement',
+                'bypassTiming',
+                'bypassStackTrace',
+                'bypassConsoleDetect',
+            ]);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(4);
+            expect(page.evaluate).toHaveBeenCalledTimes(4);
+        });
+        it('skips evaluateOnNewDocument when persistent=false', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassAll({ persistent: false }));
+            expect(body.success).toBe(true);
+            expect(body.persistent).toBe(false);
+            expect(page.evaluateOnNewDocument).not.toHaveBeenCalled();
+            expect(page.evaluate).toHaveBeenCalledTimes(4);
+        });
+        it('returns error on page failure', async () => {
+            collector.getActivePage.mockRejectedValueOnce(new Error('no page'));
+            const body = parseJson(await handlers.handleAntiDebugBypassAll({}));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('no page');
+        });
+    });
+    describe('handleAntiDebugBypassStackTrace', () => {
+        it('uses default filter patterns when none provided', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassStackTrace({}));
+            expect(body.success).toBe(true);
+            expect(body.filterPatterns).toContain('puppeteer');
+            expect(body.filterPatterns).toContain('devtools');
+        });
+        it('merges user patterns with defaults', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassStackTrace({
+                filterPatterns: ['custom_pattern', 'another'],
+            }));
+            expect(body.success).toBe(true);
+            expect(body.filterPatterns).toContain('custom_pattern');
+            expect(body.filterPatterns).toContain('another');
+            expect(body.filterPatterns).toContain('puppeteer');
+        });
+        it('handles comma-separated string patterns', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassStackTrace({
+                filterPatterns: 'foo, bar, baz',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.filterPatterns).toContain('foo');
+            expect(body.filterPatterns).toContain('bar');
+        });
+        it('deduplicates patterns', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassStackTrace({
+                filterPatterns: ['puppeteer', 'puppeteer', 'custom'],
+            }));
+            const puppeteerCount = body.filterPatterns.filter((p) => p === 'puppeteer').length;
+            expect(puppeteerCount).toBe(1);
+        });
+        it('returns error on failure', async () => {
+            collector.getActivePage.mockRejectedValueOnce(new Error('crash'));
+            const body = parseJson(await handlers.handleAntiDebugBypassStackTrace({}));
+            expect(body.success).toBe(false);
+        });
+    });
+    describe('handleAntiDebugBypassConsoleDetect', () => {
+        it('injects console detect bypass script', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassConsoleDetect({}));
+            expect(body.success).toBe(true);
+            expect(body.tool).toBe('antidebug_bypass_console_detect');
+            expect(body.persistent).toBe(true);
+        });
+        it('returns error on failure', async () => {
+            collector.getActivePage.mockRejectedValueOnce(new Error('no page'));
+            const body = parseJson(await handlers.handleAntiDebugBypassConsoleDetect({}));
+            expect(body.success).toBe(false);
+        });
+    });
+    describe('handleAntiDebugBypassDebuggerStatement', () => {
+        it('accepts noop mode', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassDebuggerStatement({ mode: 'noop' }));
+            expect(body.success).toBe(true);
+            expect(body.mode).toBe('noop');
+        });
+        it('accepts remove mode', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassDebuggerStatement({ mode: 'remove' }));
+            expect(body.success).toBe(true);
+            expect(body.mode).toBe('remove');
+        });
+        it('normalizes case for mode', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassDebuggerStatement({ mode: 'NOOP' }));
+            expect(body.success).toBe(true);
+            expect(body.mode).toBe('noop');
+        });
+        it('returns error on page failure', async () => {
+            collector.getActivePage.mockRejectedValueOnce(new Error('err'));
+            const body = parseJson(await handlers.handleAntiDebugBypassDebuggerStatement({}));
+            expect(body.success).toBe(false);
+        });
+    });
+    describe('parseBooleanArg edge cases', () => {
+        it('handles numeric 1 and 0', async () => {
+            const body1 = parseJson(await handlers.handleAntiDebugBypassAll({ persistent: 1 }));
+            expect(body1.persistent).toBe(true);
+            vi.clearAllMocks();
+            const body0 = parseJson(await handlers.handleAntiDebugBypassAll({ persistent: 0 }));
+            expect(body0.persistent).toBe(false);
+        });
+        it('handles string true/false', async () => {
+            const bodyTrue = parseJson(await handlers.handleAntiDebugBypassAll({ persistent: 'yes' }));
+            expect(bodyTrue.persistent).toBe(true);
+            vi.clearAllMocks();
+            const bodyFalse = parseJson(await handlers.handleAntiDebugBypassAll({ persistent: 'off' }));
+            expect(bodyFalse.persistent).toBe(false);
+        });
+    });
+    describe('parseNumberArg edge cases', () => {
+        it('parses string numbers', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: '100' }));
+            expect(body.maxDrift).toBe(100);
+        });
+        it('uses default for non-numeric strings', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: 'abc' }));
+            expect(body.maxDrift).toBe(50);
+        });
+        it('uses default for NaN', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: NaN }));
+            expect(body.maxDrift).toBe(50);
+        });
+        it('uses default for Infinity', async () => {
+            const body = parseJson(await handlers.handleAntiDebugBypassTiming({ maxDrift: Infinity }));
+            expect(body.maxDrift).toBe(50);
+        });
+    });
+    describe('detect protections error path', () => {
+        it('returns error on evaluate failure', async () => {
+            collector.getActivePage.mockRejectedValueOnce(new Error('timeout'));
+            const body = parseJson(await handlers.handleAntiDebugDetectProtections({}));
+            expect(body.success).toBe(false);
+            expect(body.tool).toBe('antidebug_detect_protections');
+        });
+    });
 });

package/dist/tests/server/domains/barrel-exports.test.d.ts

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

package/dist/tests/server/domains/barrel-exports.test.js

@@ -0,0 +1,289 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockClass = () => vi.fn().mockImplementation(() => ({
+    on: vi.fn(),
+    getActivePage: vi.fn(),
+    getPage: vi.fn(),
+    probeAll: vi.fn().mockResolvedValue({}),
+    run: vi.fn().mockResolvedValue({ ok: true, stdout: '', stderr: '', exitCode: 0 }),
+}));
+vi.mock('@server/domains/shared/modules', () => ({
+    CodeAnalyzer: mockClass(),
+    CamoufoxBrowserManager: mockClass(),
+    AICaptchaDetector: mockClass(),
+    CodeCollector: mockClass(),
+    DOMInspector: mockClass(),
+    PageController: mockClass(),
+    CryptoDetector: mockClass(),
+    ASTOptimizer: mockClass(),
+    AdvancedDeobfuscator: mockClass(),
+    Deobfuscator: mockClass(),
+    ObfuscationDetector: mockClass(),
+    DebuggerManager: mockClass(),
+    RuntimeInspector: mockClass(),
+    ScriptManager: mockClass(),
+    BlackboxManager: mockClass(),
+    ExternalToolRunner: mockClass(),
+    ToolRegistry: mockClass(),
+    AIHookGenerator: mockClass(),
+    HookManager: mockClass(),
+    ConsoleMonitor: mockClass(),
+    PerformanceMonitor: mockClass(),
+    MemoryManager: mockClass(),
+    UnifiedProcessManager: mockClass(),
+    StealthScripts: mockClass(),
+}));
+vi.mock('@server/domains/shared/response', () => ({
+    asJsonResponse: vi.fn(),
+    asTextResponse: vi.fn(),
+    serializeError: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}));
+vi.mock('@server/domains/antidebug/scripts', () => ({
+    ANTI_DEBUG_SCRIPTS: {
+        bypassDebuggerStatement: '',
+        bypassTiming: '',
+        bypassStackTrace: '',
+        bypassConsoleDetect: '',
+        detectProtections: '',
+    },
+}));
+vi.mock('@server/domains/antidebug/scripts.data', () => ({
+    ANTI_DEBUG_SCRIPTS: {
+        bypassDebuggerStatement: '',
+        bypassTiming: '',
+        bypassStackTrace: '',
+        bypassConsoleDetect: '',
+        detectProtections: '',
+    },
+}));
+const mockSubHandler = () => vi.fn().mockImplementation(() => new Proxy({}, { get: () => vi.fn().mockResolvedValue({ content: [] }) }));
+vi.mock('@server/domains/debugger/handlers/debugger-control', () => ({ DebuggerControlHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/debugger-stepping', () => ({ DebuggerSteppingHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/debugger-evaluate', () => ({ DebuggerEvaluateHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/debugger-state', () => ({ DebuggerStateHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/session-management', () => ({ SessionManagementHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/breakpoint-basic', () => ({ BreakpointBasicHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/breakpoint-exception', () => ({ BreakpointExceptionHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/xhr-breakpoint', () => ({ XHRBreakpointHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/event-breakpoint', () => ({ EventBreakpointHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/watch-expressions', () => ({ WatchExpressionsHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/scope-inspection', () => ({ ScopeInspectionHandlers: mockSubHandler() }));
+vi.mock('@server/domains/debugger/handlers/blackbox-handlers', () => ({ BlackboxHandlers: mockSubHandler() }));
+vi.mock('@server/domains/platform/handlers/miniapp-handlers', () => ({
+    MiniappHandlers: vi.fn().mockImplementation(() => ({})),
+}));
+vi.mock('@server/domains/platform/handlers/electron-handlers', () => ({
+    ElectronHandlers: vi.fn().mockImplementation(() => ({})),
+}));
+vi.mock('@server/domains/platform/handlers/bridge-handlers', () => ({
+    BridgeHandlers: vi.fn().mockImplementation(() => ({})),
+}));
+vi.mock('@server/domains/hooks/preset-definitions', () => ({ PRESETS: {}, PRESET_LIST: [] }));
+vi.mock('@server/domains/hooks/preset-builder', () => ({ buildHookCode: vi.fn() }));
+vi.mock('@utils/TokenBudgetManager', () => ({ TokenBudgetManager: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@utils/UnifiedCacheManager', () => ({ UnifiedCacheManager: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@utils/artifactRetention', () => ({ cleanupArtifacts: vi.fn() }));
+vi.mock('@utils/environmentDoctor', () => ({ runEnvironmentDoctor: vi.fn() }));
+vi.mock('@services/LLMService', () => ({ LLMService: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@utils/DetailedDataManager', () => ({ DetailedDataManager: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@utils/outputPaths', () => ({ resolveOutputDirectory: vi.fn() }));
+vi.mock('@utils/artifacts', () => ({
+    resolveArtifactPath: vi.fn().mockResolvedValue({ absolutePath: '/tmp/test', displayPath: 'test' }),
+}));
+vi.mock('@src/constants', () => ({
+    EXTENSION_GIT_CLONE_TIMEOUT_MS: 30000,
+    EXTENSION_GIT_CHECKOUT_TIMEOUT_MS: 10000,
+}));
+vi.mock('@server/domains/analysis/handlers.web-tools', () => ({
+    runSourceMapExtract: vi.fn(),
+    runWebpackEnumerate: vi.fn(),
+}));
+vi.mock('@modules/deobfuscator/webcrack', () => ({ runWebcrack: vi.fn() }));
+vi.mock('@server/domains/browser/handlers/browser-control', () => ({ BrowserControlHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/camoufox-browser', () => ({ CamoufoxBrowserHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/page-navigation', () => ({ PageNavigationHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/page-interaction', () => ({ PageInteractionHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/page-evaluation', () => ({ PageEvaluationHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/page-data', () => ({ PageDataHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/dom-query', () => ({ DOMQueryHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/dom-style', () => ({ DOMStyleHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/dom-search', () => ({ DOMSearchHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/console-handlers', () => ({ ConsoleHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/script-management', () => ({ ScriptManagementHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/captcha-handlers', () => ({ CaptchaHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/stealth-injection', () => ({ StealthInjectionHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/framework-state', () => ({ FrameworkStateHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/indexeddb-dump', () => ({ IndexedDBDumpHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/detailed-data', () => ({ DetailedDataHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/js-heap', () => ({ JSHeapSearchHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/tab-workflow', () => ({ TabWorkflowHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/browser/handlers/facade-initializer', () => ({ initializeBrowserHandlerModules: vi.fn().mockReturnValue({}) }));
+vi.mock('@server/domains/browser/handlers/human-behavior', () => ({ handleHumanMouse: vi.fn(), handleHumanScroll: vi.fn(), handleHumanTyping: vi.fn() }));
+vi.mock('@server/domains/browser/handlers/captcha-solver', () => ({ handleCaptchaVisionSolve: vi.fn(), handleWidgetChallengeSolve: vi.fn() }));
+vi.mock('@server/domains/browser/handlers/camoufox-flow', () => ({ handleCamoufoxLaunchFlow: vi.fn(), handleCamoufoxNavigateFlow: vi.fn() }));
+vi.mock('@server/domains/encoding/handlers.impl.core.runtime', () => ({ EncodingToolHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/graphql/handlers.impl.core.runtime', () => ({ GraphQLToolHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/network/handlers.impl.core.runtime', () => ({ AdvancedToolHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/process/handlers.impl.core.runtime', () => ({ ProcessToolHandlers: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/sourcemap/handlers.impl.sourcemap-main', () => ({ SourcemapToolHandlersMain: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/streaming/handlers.impl.streaming-sse', () => ({ StreamingToolHandlersSse: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/transform/handlers.impl.transform-crypto', () => ({ TransformToolHandlersCrypto: vi.fn().mockImplementation(() => ({})) }));
+vi.mock('@server/domains/workflow/handlers.impl.workflow-batch', () => ({ WorkflowHandlersBatch: vi.fn().mockImplementation(() => ({})) }));
+describe('Domain barrel file exports (index.ts)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('analysis/index.ts', () => {
+        it('exports coreTools and CoreAnalysisHandlers', async () => {
+            const mod = await import('../../../src/server/domains/analysis/index.js');
+            expect(mod.coreTools).toBeDefined();
+            expect(Array.isArray(mod.coreTools)).toBe(true);
+            expect(mod.CoreAnalysisHandlers).toBeDefined();
+            expect(typeof mod.CoreAnalysisHandlers).toBe('function');
+        });
+    });
+    describe('antidebug/index.ts', () => {
+        it('exports antidebugTools, ANTI_DEBUG_SCRIPTS, and AntiDebugToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/antidebug/index.js');
+            expect(mod.antidebugTools).toBeDefined();
+            expect(Array.isArray(mod.antidebugTools)).toBe(true);
+            expect(mod.ANTI_DEBUG_SCRIPTS).toBeDefined();
+            expect(mod.AntiDebugToolHandlers).toBeDefined();
+            expect(typeof mod.AntiDebugToolHandlers).toBe('function');
+        });
+    });
+    describe('browser/index.ts', () => {
+        it('exports browserTools, advancedBrowserToolDefinitions, and BrowserToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/browser/index.js');
+            expect(mod.browserTools).toBeDefined();
+            expect(mod.advancedBrowserToolDefinitions).toBeDefined();
+            expect(mod.BrowserToolHandlers).toBeDefined();
+            expect(typeof mod.BrowserToolHandlers).toBe('function');
+        });
+    });
+    describe('debugger/index.ts', () => {
+        it('exports debuggerTools and DebuggerToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/debugger/index.js');
+            expect(mod.debuggerTools).toBeDefined();
+            expect(Array.isArray(mod.debuggerTools)).toBe(true);
+            expect(mod.DebuggerToolHandlers).toBeDefined();
+            expect(typeof mod.DebuggerToolHandlers).toBe('function');
+        });
+    });
+    describe('encoding/index.ts', () => {
+        it('exports encodingTools and EncodingToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/encoding/index.js');
+            expect(mod.encodingTools).toBeDefined();
+            expect(Array.isArray(mod.encodingTools)).toBe(true);
+            expect(mod.EncodingToolHandlers).toBeDefined();
+            expect(typeof mod.EncodingToolHandlers).toBe('function');
+        });
+    });
+    describe('graphql/index.ts', () => {
+        it('exports graphqlTools and GraphQLToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/graphql/index.js');
+            expect(mod.graphqlTools).toBeDefined();
+            expect(Array.isArray(mod.graphqlTools)).toBe(true);
+            expect(mod.GraphQLToolHandlers).toBeDefined();
+            expect(typeof mod.GraphQLToolHandlers).toBe('function');
+        });
+    });
+    describe('hooks/index.ts', () => {
+        it('exports hook tool definitions and both handler classes', async () => {
+            const mod = await import('../../../src/server/domains/hooks/index.js');
+            expect(mod.aiHookTools).toBeDefined();
+            expect(mod.hookPresetTools).toBeDefined();
+            expect(mod.AIHookToolHandlers).toBeDefined();
+            expect(typeof mod.AIHookToolHandlers).toBe('function');
+            expect(mod.HookPresetToolHandlers).toBeDefined();
+            expect(typeof mod.HookPresetToolHandlers).toBe('function');
+        });
+    });
+    describe('maintenance/index.ts', () => {
+        it('exports tool definitions and both handler classes', async () => {
+            const mod = await import('../../../src/server/domains/maintenance/index.js');
+            expect(mod.tokenBudgetTools).toBeDefined();
+            expect(mod.cacheTools).toBeDefined();
+            expect(mod.extensionTools).toBeDefined();
+            expect(mod.artifactTools).toBeDefined();
+            expect(mod.CoreMaintenanceHandlers).toBeDefined();
+            expect(typeof mod.CoreMaintenanceHandlers).toBe('function');
+            expect(mod.ExtensionManagementHandlers).toBeDefined();
+            expect(typeof mod.ExtensionManagementHandlers).toBe('function');
+        });
+    });
+    describe('network/index.ts', () => {
+        it('exports advancedTools and AdvancedToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/network/index.js');
+            expect(mod.advancedTools).toBeDefined();
+            expect(Array.isArray(mod.advancedTools)).toBe(true);
+            expect(mod.AdvancedToolHandlers).toBeDefined();
+            expect(typeof mod.AdvancedToolHandlers).toBe('function');
+        });
+    });
+    describe('platform/index.ts', () => {
+        it('exports platformTools and PlatformToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/platform/index.js');
+            expect(mod.platformTools).toBeDefined();
+            expect(Array.isArray(mod.platformTools)).toBe(true);
+            expect(mod.PlatformToolHandlers).toBeDefined();
+            expect(typeof mod.PlatformToolHandlers).toBe('function');
+        });
+    });
+    describe('process/index.ts', () => {
+        it('exports processToolDefinitions and ProcessToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/process/index.js');
+            expect(mod.processToolDefinitions).toBeDefined();
+            expect(Array.isArray(mod.processToolDefinitions)).toBe(true);
+            expect(mod.ProcessToolHandlers).toBeDefined();
+            expect(typeof mod.ProcessToolHandlers).toBe('function');
+        });
+    });
+    describe('sourcemap/index.ts', () => {
+        it('exports sourcemapTools and SourcemapToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/sourcemap/index.js');
+            expect(mod.sourcemapTools).toBeDefined();
+            expect(Array.isArray(mod.sourcemapTools)).toBe(true);
+            expect(mod.SourcemapToolHandlers).toBeDefined();
+            expect(typeof mod.SourcemapToolHandlers).toBe('function');
+        });
+    });
+    describe('streaming/index.ts', () => {
+        it('exports streamingTools and StreamingToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/streaming/index.js');
+            expect(mod.streamingTools).toBeDefined();
+            expect(Array.isArray(mod.streamingTools)).toBe(true);
+            expect(mod.StreamingToolHandlers).toBeDefined();
+            expect(typeof mod.StreamingToolHandlers).toBe('function');
+        });
+    });
+    describe('transform/index.ts', () => {
+        it('exports transformTools and TransformToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/transform/index.js');
+            expect(mod.transformTools).toBeDefined();
+            expect(Array.isArray(mod.transformTools)).toBe(true);
+            expect(mod.TransformToolHandlers).toBeDefined();
+            expect(typeof mod.TransformToolHandlers).toBe('function');
+        });
+    });
+    describe('wasm/index.ts', () => {
+        it('exports wasmTools and WasmToolHandlers', async () => {
+            const mod = await import('../../../src/server/domains/wasm/index.js');
+            expect(mod.wasmTools).toBeDefined();
+            expect(Array.isArray(mod.wasmTools)).toBe(true);
+            expect(mod.WasmToolHandlers).toBeDefined();
+            expect(typeof mod.WasmToolHandlers).toBe('function');
+        });
+    });
+    describe('workflow/index.ts', () => {
+        it('exports workflowToolDefinitions and WorkflowHandlers', async () => {
+            const mod = await import('../../../src/server/domains/workflow/index.js');
+            expect(mod.workflowToolDefinitions).toBeDefined();
+            expect(Array.isArray(mod.workflowToolDefinitions)).toBe(true);
+            expect(mod.WorkflowHandlers).toBeDefined();
+            expect(typeof mod.WorkflowHandlers).toBe('function');
+        });
+    });
+});