@jshookmcp/jshook 0.1.8 → 0.1.9

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

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const pm = {
+    getPlatform: vi.fn(() => 'win32'),
+    findProcesses: vi.fn(),
+    getProcessByPid: vi.fn(),
+    getProcessCommandLine: vi.fn(),
+    checkDebugPort: vi.fn(),
+    getProcessWindows: vi.fn(),
+    launchWithDebug: vi.fn(),
+    killProcess: vi.fn(),
+};
+const mm = {};
+const unifiedPmCtor = vi.fn(() => pm);
+const memoryCtor = vi.fn(() => mm);
+vi.mock('@src/modules/process/index', () => ({
+    UnifiedProcessManager: class {
+        constructor() {
+            return unifiedPmCtor();
+        }
+    },
+    MemoryManager: class {
+        constructor() {
+            return memoryCtor();
+        }
+    },
+}));
+import { ProcessToolHandlers } from '../../../../src/server/domains/process/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('ProcessToolHandlers', () => {
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new ProcessToolHandlers();
+    });
+    it('returns validation error when process_find has empty pattern', async () => {
+        const body = parseJson(await handlers.handleProcessFind({ pattern: '' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('pattern');
+    });
+    it('maps process_find result fields', async () => {
+        pm.findProcesses.mockResolvedValue([
+            {
+                pid: 100,
+                name: 'browser.exe',
+                executablePath: 'C:/browser.exe',
+                windowTitle: 'Browser',
+                windowHandle: '0x1',
+                memoryUsage: 50 * 1024 * 1024,
+            },
+        ]);
+        const body = parseJson(await handlers.handleProcessFind({ pattern: 'browser' }));
+        expect(body.success).toBe(true);
+        expect(body.count).toBe(1);
+        expect(body.processes[0]).toMatchObject({
+            pid: 100,
+            path: 'C:/browser.exe',
+            memoryMB: 50,
+        });
+    });
+    it('returns not-found message for missing PID', async () => {
+        pm.getProcessByPid.mockResolvedValue(null);
+        const body = parseJson(await handlers.handleProcessGet({ pid: 1234 }));
+        expect(body.success).toBe(false);
+        expect(body.message).toContain('1234');
+    });
+    it('returns process_get with command line and debug port', async () => {
+        pm.getProcessByPid.mockResolvedValue({ pid: 77, name: 'node' });
+        pm.getProcessCommandLine.mockResolvedValue({ commandLine: 'node app.js', parentPid: 1 });
+        pm.checkDebugPort.mockResolvedValue(9222);
+        const body = parseJson(await handlers.handleProcessGet({ pid: 77 }));
+        expect(body.success).toBe(true);
+        expect(body.process.commandLine).toBe('node app.js');
+        expect(body.process.parentPid).toBe(1);
+        expect(body.process.debugPort).toBe(9222);
+        expect(pm.checkDebugPort).toHaveBeenCalledWith(77, { commandLine: 'node app.js' });
+    });
+    it('returns disabled response for process_find_chromium', async () => {
+        const body = parseJson(await handlers.handleProcessFindChromium({}));
+        expect(body.success).toBe(false);
+        expect(body.disabled).toBe(true);
+        expect(body.platform).toBe('win32');
+    });
+    it('returns canAttach on process_check_debug_port', async () => {
+        pm.checkDebugPort.mockResolvedValue(9333);
+        const body = parseJson(await handlers.handleProcessCheckDebugPort({ pid: 200 }));
+        expect(body.success).toBe(true);
+        expect(body.canAttach).toBe(true);
+        expect(body.attachUrl).toBe('http://localhost:9333');
+    });
+    it('returns a stable failure message when process_launch_debug cannot resolve a process', async () => {
+        pm.launchWithDebug.mockResolvedValue(null);
+        const body = parseJson(await handlers.handleProcessLaunchDebug({
+            executablePath: 'C:/browser.exe',
+            debugPort: 9222,
+            args: ['--headless'],
+        }));
+        expect(body.success).toBe(false);
+        expect(body.message).toBe('Failed to launch process');
+        expect(body.error).toBeUndefined();
+    });
+});

package/dist/tests/server/domains/shared/response.test.d.ts

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

package/dist/tests/server/domains/shared/response.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { asErrorResponse, asJsonResponse, asTextResponse, serializeError } from '../../../../src/server/domains/shared/response.js';
+describe('shared response helpers', () => {
+    it('asTextResponse returns MCP text payload', () => {
+        const res = asTextResponse('ok');
+        expect(res).toEqual({
+            content: [{ type: 'text', text: 'ok' }],
+        });
+    });
+    it('asTextResponse marks error responses when requested', () => {
+        const res = asTextResponse('bad', true);
+        expect(res.isError).toBe(true);
+        expect(res.content[0]?.text).toBe('bad');
+    });
+    it('asJsonResponse formats JSON content', () => {
+        const res = asJsonResponse({ a: 1, b: 'x' });
+        expect(res.content[0]?.text).toBe('{\n  "a": 1,\n  "b": "x"\n}');
+    });
+    it('asErrorResponse uses message from Error instances', () => {
+        const res = asErrorResponse(new Error('boom'));
+        expect(res.isError).toBe(true);
+        expect(res.content[0]?.text).toBe('Error: boom');
+    });
+    it('asErrorResponse stringifies non-Error values', () => {
+        const res = asErrorResponse({ code: 500 });
+        expect(res.content[0]?.text).toContain('Error: [object Object]');
+    });
+    it('serializeError returns normalized error object', () => {
+        expect(serializeError(new Error('fail'))).toEqual({
+            success: false,
+            error: 'fail',
+        });
+        expect(serializeError(404)).toEqual({
+            success: false,
+            error: '404',
+        });
+    });
+});

package/dist/tests/server/domains/sourcemap/common.test.d.ts

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

package/dist/tests/server/domains/sourcemap/common.test.js

@@ -0,0 +1,240 @@
+import { describe, expect, it } from 'vitest';
+import { SourcemapToolHandlersCommon } from '../../../../src/server/domains/sourcemap/handlers.impl.sourcemap-common.js';
+class TestableCommon extends SourcemapToolHandlersCommon {
+    constructor() {
+        super(null);
+    }
+    testCombineSourceRoot(root, path) {
+        return this.combineSourceRoot(root, path);
+    }
+    testNormalizeSourcePath(path, index) {
+        return this.normalizeSourcePath(path, index);
+    }
+    testSanitizePathSegment(seg) {
+        return this.sanitizePathSegment(seg);
+    }
+    testSafeTarget(value) {
+        return this.safeTarget(value);
+    }
+    testHasProtocol(value) {
+        return this.hasProtocol(value);
+    }
+    testParseBooleanArg(value, def) {
+        return this.parseBooleanArg(value, def);
+    }
+    testRequiredStringArg(value, name) {
+        return this.requiredStringArg(value, name);
+    }
+    testOptionalStringArg(value) {
+        return this.optionalStringArg(value);
+    }
+    testAsRecord(value) {
+        return this.asRecord(value);
+    }
+    testAsString(value) {
+        return this.asString(value);
+    }
+    testJson(payload) {
+        return this.json(payload);
+    }
+    testFail(tool, error) {
+        return this.fail(tool, error);
+    }
+}
+const handlers = new TestableCommon();
+function getText(response) {
+    return response?.content?.[0]?.text ?? '';
+}
+function parseTextJson(response) {
+    return JSON.parse(getText(response));
+}
+describe('SourcemapToolHandlersCommon', () => {
+    describe('combineSourceRoot', () => {
+        it('returns sourcePath when sourceRoot is undefined', () => {
+            expect(handlers.testCombineSourceRoot(undefined, 'a.js')).toBe('a.js');
+        });
+        it('returns sourceRoot when sourcePath is empty', () => {
+            expect(handlers.testCombineSourceRoot('root', '')).toBe('root');
+        });
+        it('returns sourcePath when it has a protocol (ignores sourceRoot)', () => {
+            expect(handlers.testCombineSourceRoot('https://example.com/root', 'http://other.test/a.js')).toBe('http://other.test/a.js');
+        });
+        it('returns sourcePath when it starts with "/" (ignores sourceRoot)', () => {
+            expect(handlers.testCombineSourceRoot('root', '/abs/path.js')).toBe('/abs/path.js');
+        });
+        it('resolves relative paths against protocol sourceRoot (directory semantics via trailing slash)', () => {
+            expect(handlers.testCombineSourceRoot('https://example.com/root', 'a.js')).toBe('https://example.com/root/a.js');
+        });
+        it('handles protocol sourceRoot that already ends with "/"', () => {
+            expect(handlers.testCombineSourceRoot('https://example.com/root/', 'a.js')).toBe('https://example.com/root/a.js');
+        });
+        it('joins sourceRoot and sourcePath when sourceRoot has no protocol', () => {
+            expect(handlers.testCombineSourceRoot('foo/', 'bar.js')).toBe('foo/bar.js');
+            expect(handlers.testCombineSourceRoot('foo///', 'bar.js')).toBe('foo/bar.js');
+        });
+        it('falls back to string join when URL resolution throws (invalid URL base)', () => {
+            expect(handlers.testCombineSourceRoot('http://[invalid', 'a.js')).toBe('http://[invalid/a.js');
+        });
+    });
+    describe('normalizeSourcePath', () => {
+        it('falls back to default name for empty/whitespace input', () => {
+            expect(handlers.testNormalizeSourcePath('   ', 0)).toBe('source_1.js');
+            expect(handlers.testNormalizeSourcePath('\n\t', 4)).toBe('source_5.js');
+        });
+        it('strips webpack:// prefix', () => {
+            expect(handlers.testNormalizeSourcePath('webpack://src/app.js', 0)).toBe('src/app.js');
+            expect(handlers.testNormalizeSourcePath('webpack:///src/app.js', 0)).toBe('src/app.js');
+        });
+        it('maps data: URIs to inline file placeholders', () => {
+            expect(handlers.testNormalizeSourcePath('data:application/json;base64,eyJ4IjoxfQ==', 1)).toBe('inline/source_2.txt');
+        });
+        it('normalizes full URLs into hostname + pathname', () => {
+            expect(handlers.testNormalizeSourcePath('https://example.com/path/file.js?x=1#hash', 0)).toBe('example.com/path/file.js');
+        });
+        it('strips query and hash fragments from non-URL paths', () => {
+            expect(handlers.testNormalizeSourcePath('src/app.js?foo=1#bar', 0)).toBe('src/app.js');
+        });
+        it('strips Windows drive letter and normalizes separators', () => {
+            const result = handlers.testNormalizeSourcePath('C:\\src\\app.js', 0);
+            expect(result).toContain('src/app.js');
+        });
+        it('strips leading slashes', () => {
+            expect(handlers.testNormalizeSourcePath('/src/app.js', 0)).toBe('src/app.js');
+            expect(handlers.testNormalizeSourcePath('///src/app.js', 0)).toBe('src/app.js');
+        });
+        it('filters empty segments from repeated separators', () => {
+            expect(handlers.testNormalizeSourcePath('a//b///c', 0)).toBe('a/b/c');
+        });
+    });
+    describe('sanitizePathSegment', () => {
+        it('returns normal text unchanged', () => {
+            expect(handlers.testSanitizePathSegment('hello-world')).toBe('hello-world');
+            expect(handlers.testSanitizePathSegment('foo_bar-baz')).toBe('foo_bar-baz');
+        });
+        it('replaces control characters with "_"', () => {
+            expect(handlers.testSanitizePathSegment(`a\u0000b`)).toBe('a_b');
+            expect(handlers.testSanitizePathSegment(`x\u001Fy`)).toBe('x_y');
+        });
+        it('replaces special characters (<>:"|?*) with "_"', () => {
+            expect(handlers.testSanitizePathSegment('a<>:"|?*b')).toBe('a_______b');
+        });
+        it('collapses whitespace and trims', () => {
+            expect(handlers.testSanitizePathSegment('  a    b   c  ')).toBe('a b c');
+            expect(handlers.testSanitizePathSegment('  a \t  b   c  ')).toBe('a _ b c');
+        });
+        it('returns "_" for "." and ".."', () => {
+            expect(handlers.testSanitizePathSegment('.')).toBe('_');
+            expect(handlers.testSanitizePathSegment('..')).toBe('_');
+        });
+        it('returns "_" for empty or whitespace-only segments', () => {
+            expect(handlers.testSanitizePathSegment('')).toBe('_');
+            expect(handlers.testSanitizePathSegment('   ')).toBe('_');
+        });
+    });
+    describe('safeTarget', () => {
+        it('strips protocol and replaces non-alnum with "_"', () => {
+            expect(handlers.testSafeTarget('https://example.com/path/file.js')).toBe('example_com_path_file_js');
+        });
+        it('collapses underscores and trims leading/trailing underscores', () => {
+            expect(handlers.testSafeTarget('___a..b___')).toBe('a_b');
+        });
+        it('truncates to 48 characters', () => {
+            const value = `https://example.com/${'a'.repeat(100)}`;
+            const result = handlers.testSafeTarget(value);
+            expect(result.length).toBeLessThanOrEqual(48);
+        });
+    });
+    describe('hasProtocol', () => {
+        it('returns true for common and custom protocols', () => {
+            expect(handlers.testHasProtocol('http://a')).toBe(true);
+            expect(handlers.testHasProtocol('https://a')).toBe(true);
+            expect(handlers.testHasProtocol('ftp://a')).toBe(true);
+            expect(handlers.testHasProtocol('custom:thing')).toBe(true);
+        });
+        it('returns false when no protocol prefix is present', () => {
+            expect(handlers.testHasProtocol('example.com/path')).toBe(false);
+            expect(handlers.testHasProtocol('/absolute/path')).toBe(false);
+            expect(handlers.testHasProtocol('relative/path')).toBe(false);
+        });
+    });
+    describe('parseBooleanArg', () => {
+        it('returns boolean values unchanged', () => {
+            expect(handlers.testParseBooleanArg(true, false)).toBe(true);
+            expect(handlers.testParseBooleanArg(false, true)).toBe(false);
+        });
+        it('returns defaultValue for non-boolean inputs', () => {
+            expect(handlers.testParseBooleanArg('true', true)).toBe(true);
+            expect(handlers.testParseBooleanArg(0, false)).toBe(false);
+            expect(handlers.testParseBooleanArg(null, true)).toBe(true);
+        });
+    });
+    describe('requiredStringArg', () => {
+        it('returns trimmed string for valid input', () => {
+            expect(handlers.testRequiredStringArg('  hello  ', 'field')).toBe('hello');
+        });
+        it('throws for empty strings', () => {
+            expect(() => handlers.testRequiredStringArg('   ', 'field')).toThrow('field is required');
+        });
+        it('throws for non-string values', () => {
+            expect(() => handlers.testRequiredStringArg(123, 'field')).toThrow('field is required');
+        });
+    });
+    describe('optionalStringArg', () => {
+        it('returns trimmed string for valid input', () => {
+            expect(handlers.testOptionalStringArg('  hello  ')).toBe('hello');
+        });
+        it('returns undefined for empty strings', () => {
+            expect(handlers.testOptionalStringArg('   ')).toBeUndefined();
+        });
+        it('returns undefined for non-string values', () => {
+            expect(handlers.testOptionalStringArg(123)).toBeUndefined();
+            expect(handlers.testOptionalStringArg(null)).toBeUndefined();
+        });
+    });
+    describe('json', () => {
+        it('wraps JSON.stringify(payload, null, 2) into a TextToolResponse', () => {
+            const payload = { a: 1 };
+            expect(handlers.testJson(payload)).toEqual({
+                content: [
+                    {
+                        type: 'text',
+                        text: '{\n  "a": 1\n}',
+                    },
+                ],
+            });
+        });
+    });
+    describe('fail', () => {
+        it('uses Error.message when given an Error instance', () => {
+            const response = handlers.testFail('my_tool', new Error('boom'));
+            expect(parseTextJson(response)).toEqual({
+                success: false,
+                tool: 'my_tool',
+                error: 'boom',
+            });
+        });
+        it('uses the string when given a string', () => {
+            const response = handlers.testFail('my_tool', 'bad');
+            expect(parseTextJson(response)).toEqual({
+                success: false,
+                tool: 'my_tool',
+                error: 'bad',
+            });
+        });
+        it('stringifies non-Error, non-string values', () => {
+            const response = handlers.testFail('my_tool', 123);
+            expect(parseTextJson(response)).toEqual({
+                success: false,
+                tool: 'my_tool',
+                error: '123',
+            });
+        });
+        it('always returns a pretty-printed JSON text payload', () => {
+            const response = handlers.testFail('tool', 'x');
+            const text = getText(response);
+            expect(text).toContain('\n  "success": false');
+            expect(text).toContain('\n  "tool": "tool"');
+            expect(text).toContain('\n  "error": "x"');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SourcemapToolHandlers } from '../../../../src/server/domains/sourcemap/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('SourcemapToolHandlers', () => {
+    const session = {
+        send: vi.fn(),
+        on: vi.fn(),
+        off: vi.fn(),
+        detach: vi.fn(),
+    };
+    const page = {
+        createCDPSession: vi.fn(async () => session),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new SourcemapToolHandlers(collector);
+    });
+    it('returns error when sourceMapUrl is missing in fetch_and_parse', async () => {
+        const body = parseJson(await handlers.handleSourcemapFetchAndParse({}));
+        expect(body.success).toBe(false);
+        expect(body.tool).toBe('sourcemap_fetch_and_parse');
+        expect(body.error).toContain('sourceMapUrl');
+    });
+    it('returns parsed source map summary', async () => {
+        vi.spyOn(handlers, 'parseSourceMap').mockResolvedValue({
+            resolvedUrl: 'https://a.map',
+            map: { sources: ['a.ts'], sourcesContent: ['const a=1;'] },
+            mappings: [],
+            mappingsCount: 2,
+            segmentCount: 3,
+        });
+        const body = parseJson(await handlers.handleSourcemapFetchAndParse({ sourceMapUrl: 'https://a.map' }));
+        expect(body.sources).toEqual(['a.ts']);
+        expect(body.mappingsCount).toBe(2);
+        expect(body.sourcesContent).toEqual(['const a=1;']);
+    });
+    it('lists installed extensions from extension targets', async () => {
+        vi.spyOn(handlers, 'getExtensionTargets').mockResolvedValue([
+            { extensionId: 'ext1', name: 'A', type: 'service_worker', url: 'chrome-extension://ext1/bg', targetId: 't1' },
+        ]);
+        const body = parseJson(await handlers.handleExtensionListInstalled({}));
+        expect(body).toEqual([
+            {
+                extensionId: 'ext1',
+                name: 'A',
+                type: 'service_worker',
+                url: 'chrome-extension://ext1/bg',
+            },
+        ]);
+        expect(session.detach).toHaveBeenCalledOnce();
+    });
+    it('returns failure when extension target is not found', async () => {
+        vi.spyOn(handlers, 'getExtensionTargets').mockResolvedValue([]);
+        const body = parseJson(await handlers.handleExtensionExecuteInContext({
+            extensionId: 'missing',
+            code: '1+1',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.tool).toBe('extension_execute_in_context');
+        expect(body.error).toContain('No background target found');
+    });
+    it('executes code in extension context and returns result', async () => {
+        vi.spyOn(handlers, 'getExtensionTargets').mockResolvedValue([
+            { extensionId: 'ext1', name: 'A', type: 'service_worker', url: 'x', targetId: 'tid' },
+        ]);
+        vi.spyOn(handlers, 'evaluateInAttachedTarget').mockResolvedValue({
+            result: { value: 42 },
+            exceptionDetails: null,
+        });
+        session.send.mockResolvedValue({ sessionId: 'sid-1' });
+        const body = parseJson(await handlers.handleExtensionExecuteInContext({
+            extensionId: 'ext1',
+            code: '(() => 42)()',
+        }));
+        expect(body.extensionId).toBe('ext1');
+        expect(body.result).toEqual({ value: 42 });
+        expect(session.send).toHaveBeenCalledWith('Target.attachToTarget', {
+            targetId: 'tid',
+            flatten: true,
+        });
+    });
+    it('throws immediately when extensionId is missing', async () => {
+        await expect(handlers.handleExtensionExecuteInContext({ code: '1' })).rejects.toThrow(/extensionId/);
+    });
+});

package/dist/tests/server/domains/sourcemap/parse-base.test.d.ts

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