@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/server/domains/graphql/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/graphql exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes GraphQL tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'graphql',
+            definitionExportNames: ['graphqlTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/graphql/definitions.js'),
+            getToolArrays: (module) => [
+                module.graphqlTools,
+            ],
+            loadManifest: () => import('../../../../src/server/domains/graphql/manifest.js'),
+        });
+    });
+});

package/dist/tests/server/domains/graphql/runtime-base.test.d.ts

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

package/dist/tests/server/domains/graphql/runtime-base.test.js

@@ -0,0 +1,608 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/server/domains/network/replay', () => ({
+    isSsrfTarget: vi.fn(async () => isSsrfTargetMock()),
+}));
+const isSsrfTargetMock = vi.fn(async () => false);
+import { GraphQLToolHandlersBase } from '../../../../src/server/domains/graphql/handlers.impl.core.runtime.base.js';
+class TestableBase extends GraphQLToolHandlersBase {
+    toResponse(payload) {
+        return super.toResponse(payload);
+    }
+    toError(error, context) {
+        return super.toError(error, context);
+    }
+    getErrorMessage(error) {
+        return super.getErrorMessage(error);
+    }
+    getStringArg(args, key) {
+        return super.getStringArg(args, key);
+    }
+    getNumberArg(args, key, defaultValue, min, max) {
+        return super.getNumberArg(args, key, defaultValue, min, max);
+    }
+    getObjectArg(args, key) {
+        return super.getObjectArg(args, key);
+    }
+    normalizeHeaders(value) {
+        return super.normalizeHeaders(value);
+    }
+    async validateExternalEndpoint(endpoint) {
+        return super.validateExternalEndpoint(endpoint);
+    }
+    createPreview(text, maxChars) {
+        return super.createPreview(text, maxChars);
+    }
+    serializeForPreview(value, maxChars) {
+        return super.serializeForPreview(value, maxChars);
+    }
+    parseMatchType(value) {
+        return super.parseMatchType(value);
+    }
+    generateRuleId() {
+        return super.generateRuleId();
+    }
+    isRequestInterceptHandled(request) {
+        return super.isRequestInterceptHandled(request);
+    }
+    async continueRequest(request) {
+        return super.continueRequest(request);
+    }
+    ruleMatchesUrl(rule, targetUrl) {
+        return super.ruleMatchesUrl(rule, targetUrl);
+    }
+    findMatchingRule(url) {
+        return super.findMatchingRule(url);
+    }
+    async handleInterceptedRequest(request) {
+        return super.handleInterceptedRequest(request);
+    }
+    async ensureScriptInterception(page) {
+        return super.ensureScriptInterception(page);
+    }
+    get rules() {
+        return this.scriptReplaceRules;
+    }
+}
+function getFirstTextContent(response) {
+    const firstContent = response.content[0];
+    if (!firstContent) {
+        throw new Error('Expected response.content[0] to be present');
+    }
+    return firstContent.text;
+}
+function parseJson(response) {
+    return JSON.parse(getFirstTextContent(response));
+}
+function getFirstRule(base) {
+    const firstRule = base.rules[0];
+    if (!firstRule) {
+        throw new Error('Expected at least one script replacement rule');
+    }
+    return firstRule;
+}
+describe('GraphQLToolHandlersBase', () => {
+    const collector = { getActivePage: vi.fn() };
+    let base;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        base = new TestableBase(collector);
+    });
+    describe('toResponse', () => {
+        it('wraps payload as JSON text content', () => {
+            const result = base.toResponse({ hello: 'world' });
+            expect(result.content).toHaveLength(1);
+            const firstContent = result.content[0];
+            expect(firstContent).toBeDefined();
+            if (!firstContent) {
+                throw new Error('Expected response.content[0] to be present');
+            }
+            expect(firstContent.type).toBe('text');
+            const parsed = JSON.parse(firstContent.text);
+            expect(parsed).toEqual({ hello: 'world' });
+        });
+        it('handles null payload', () => {
+            const parsed = parseJson(base.toResponse(null));
+            expect(parsed).toBeNull();
+        });
+        it('handles numeric payload', () => {
+            const parsed = parseJson(base.toResponse(42));
+            expect(parsed).toBe(42);
+        });
+    });
+    describe('toError', () => {
+        it('wraps error string with isError flag', () => {
+            const result = base.toError('something broke');
+            expect(result.isError).toBe(true);
+            const parsed = parseJson(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toBe('something broke');
+        });
+        it('extracts message from Error instances', () => {
+            const result = base.toError(new Error('test error'));
+            const parsed = parseJson(result);
+            expect(parsed.error).toBe('test error');
+        });
+        it('includes optional context', () => {
+            const result = base.toError('fail', { detail: 'extra' });
+            const parsed = parseJson(result);
+            expect(parsed.context).toEqual({ detail: 'extra' });
+        });
+        it('omits context when not provided', () => {
+            const result = base.toError('fail');
+            const parsed = parseJson(result);
+            expect(parsed.context).toBeUndefined();
+        });
+    });
+    describe('getErrorMessage', () => {
+        it('returns message from Error', () => {
+            expect(base.getErrorMessage(new Error('msg'))).toBe('msg');
+        });
+        it('stringifies non-Error values', () => {
+            expect(base.getErrorMessage(42)).toBe('42');
+            expect(base.getErrorMessage(null)).toBe('null');
+            expect(base.getErrorMessage(undefined)).toBe('undefined');
+        });
+    });
+    describe('getStringArg', () => {
+        it('returns string values', () => {
+            expect(base.getStringArg({ key: 'val' }, 'key')).toBe('val');
+        });
+        it('returns null for non-string values', () => {
+            expect(base.getStringArg({ key: 42 }, 'key')).toBeNull();
+            expect(base.getStringArg({ key: true }, 'key')).toBeNull();
+            expect(base.getStringArg({ key: null }, 'key')).toBeNull();
+        });
+        it('returns null for missing keys', () => {
+            expect(base.getStringArg({}, 'key')).toBeNull();
+        });
+    });
+    describe('getNumberArg', () => {
+        it('returns the number when valid and in range', () => {
+            expect(base.getNumberArg({ n: 5 }, 'n', 10, 1, 20)).toBe(5);
+        });
+        it('clamps to min', () => {
+            expect(base.getNumberArg({ n: -5 }, 'n', 10, 0, 100)).toBe(0);
+        });
+        it('clamps to max', () => {
+            expect(base.getNumberArg({ n: 999 }, 'n', 10, 0, 100)).toBe(100);
+        });
+        it('uses default for missing key', () => {
+            expect(base.getNumberArg({}, 'n', 7, 1, 20)).toBe(7);
+        });
+        it('parses string numbers', () => {
+            expect(base.getNumberArg({ n: '15' }, 'n', 10, 1, 20)).toBe(15);
+        });
+        it('uses default for non-numeric string', () => {
+            expect(base.getNumberArg({ n: 'abc' }, 'n', 10, 1, 20)).toBe(10);
+        });
+        it('truncates to integer', () => {
+            expect(base.getNumberArg({ n: 5.9 }, 'n', 10, 1, 20)).toBe(5);
+        });
+        it('uses default for NaN', () => {
+            expect(base.getNumberArg({ n: NaN }, 'n', 10, 1, 20)).toBe(10);
+        });
+        it('uses default for Infinity', () => {
+            expect(base.getNumberArg({ n: Infinity }, 'n', 10, 1, 20)).toBe(10);
+        });
+    });
+    describe('getObjectArg', () => {
+        it('returns objects', () => {
+            const obj = { a: 1 };
+            expect(base.getObjectArg({ data: obj }, 'data')).toBe(obj);
+        });
+        it('returns null for arrays', () => {
+            expect(base.getObjectArg({ data: [1, 2] }, 'data')).toBeNull();
+        });
+        it('returns null for primitives', () => {
+            expect(base.getObjectArg({ data: 'str' }, 'data')).toBeNull();
+            expect(base.getObjectArg({ data: 42 }, 'data')).toBeNull();
+        });
+        it('returns null for null values', () => {
+            expect(base.getObjectArg({ data: null }, 'data')).toBeNull();
+        });
+        it('returns null for missing keys', () => {
+            expect(base.getObjectArg({}, 'data')).toBeNull();
+        });
+    });
+    describe('normalizeHeaders', () => {
+        it('passes through string values', () => {
+            expect(base.normalizeHeaders({ 'x-foo': 'bar' })).toEqual({ 'x-foo': 'bar' });
+        });
+        it('stringifies numeric header values', () => {
+            expect(base.normalizeHeaders({ 'content-length': 42 })).toEqual({
+                'content-length': '42',
+            });
+        });
+        it('stringifies boolean header values', () => {
+            expect(base.normalizeHeaders({ 'x-flag': true })).toEqual({
+                'x-flag': 'true',
+            });
+        });
+        it('skips non-scalar header values', () => {
+            const result = base.normalizeHeaders({ nested: { a: 1 } });
+            expect(result).toEqual({});
+        });
+        it('returns empty object for null/undefined', () => {
+            expect(base.normalizeHeaders(null)).toEqual({});
+            expect(base.normalizeHeaders(undefined)).toEqual({});
+        });
+        it('returns empty object for arrays', () => {
+            expect(base.normalizeHeaders(['a', 'b'])).toEqual({});
+        });
+        it('skips dangerous prototype pollution keys', () => {
+            const result = base.normalizeHeaders({
+                __proto__: 'evil',
+                constructor: 'bad',
+                prototype: 'nope',
+                'x-safe': 'ok',
+            });
+            expect(result).toEqual({ 'x-safe': 'ok' });
+            expect(result.__proto__).toBeUndefined();
+            expect(result.constructor).toBeUndefined();
+        });
+    });
+    describe('validateExternalEndpoint', () => {
+        it('returns null for valid https URL', async () => {
+            isSsrfTargetMock.mockResolvedValueOnce(false);
+            const result = await base.validateExternalEndpoint('https://example.com/graphql');
+            expect(result).toBeNull();
+        });
+        it('returns null for valid http URL', async () => {
+            isSsrfTargetMock.mockResolvedValueOnce(false);
+            const result = await base.validateExternalEndpoint('http://example.com/graphql');
+            expect(result).toBeNull();
+        });
+        it('returns error for invalid URL', async () => {
+            const result = await base.validateExternalEndpoint('not-a-url');
+            expect(result).toContain('Invalid endpoint URL');
+        });
+        it('returns error for unsupported protocol', async () => {
+            const result = await base.validateExternalEndpoint('ftp://example.com/graphql');
+            expect(result).toContain('Unsupported endpoint protocol');
+        });
+        it('returns error for SSRF targets', async () => {
+            isSsrfTargetMock.mockResolvedValueOnce(true);
+            const result = await base.validateExternalEndpoint('http://127.0.0.1/graphql');
+            expect(result).toContain('Blocked');
+            expect(result).toContain('private/reserved');
+        });
+    });
+    describe('createPreview', () => {
+        it('returns full text when under limit', () => {
+            const result = base.createPreview('short', 100);
+            expect(result.preview).toBe('short');
+            expect(result.truncated).toBe(false);
+            expect(result.totalLength).toBe(5);
+        });
+        it('returns full text when exactly at limit', () => {
+            const text = 'x'.repeat(10);
+            const result = base.createPreview(text, 10);
+            expect(result.truncated).toBe(false);
+            expect(result.preview).toBe(text);
+        });
+        it('truncates text exceeding limit', () => {
+            const text = 'x'.repeat(20);
+            const result = base.createPreview(text, 10);
+            expect(result.truncated).toBe(true);
+            expect(result.totalLength).toBe(20);
+            expect(result.preview).toContain('... (truncated)');
+            expect(result.preview.startsWith('x'.repeat(10))).toBe(true);
+        });
+    });
+    describe('serializeForPreview', () => {
+        it('serializes objects to JSON', () => {
+            const result = base.serializeForPreview({ a: 1 }, 1000);
+            expect(result.truncated).toBe(false);
+            expect(JSON.parse(result.preview)).toEqual({ a: 1 });
+        });
+        it('passes strings through directly', () => {
+            const result = base.serializeForPreview('hello', 1000);
+            expect(result.preview).toBe('hello');
+        });
+        it('truncates large serialized objects', () => {
+            const large = { data: 'x'.repeat(200) };
+            const result = base.serializeForPreview(large, 50);
+            expect(result.truncated).toBe(true);
+        });
+        it('handles circular-reference-like values gracefully', () => {
+            const badValue = {
+                toJSON() {
+                    throw new Error('cannot serialize');
+                },
+            };
+            const result = base.serializeForPreview(badValue, 1000);
+            expect(result.truncated).toBe(false);
+        });
+    });
+    describe('parseMatchType', () => {
+        it('returns exact for "exact"', () => {
+            expect(base.parseMatchType('exact')).toBe('exact');
+        });
+        it('returns contains for "contains"', () => {
+            expect(base.parseMatchType('contains')).toBe('contains');
+        });
+        it('returns regex for "regex"', () => {
+            expect(base.parseMatchType('regex')).toBe('regex');
+        });
+        it('defaults to contains for unknown values', () => {
+            expect(base.parseMatchType('unknown')).toBe('contains');
+            expect(base.parseMatchType(null)).toBe('contains');
+            expect(base.parseMatchType(123)).toBe('contains');
+            expect(base.parseMatchType(undefined)).toBe('contains');
+        });
+    });
+    describe('generateRuleId', () => {
+        it('starts with script_rule_ prefix', () => {
+            expect(base.generateRuleId()).toMatch(/^script_rule_/);
+        });
+        it('generates unique IDs', () => {
+            const ids = new Set(Array.from({ length: 20 }, () => base.generateRuleId()));
+            expect(ids.size).toBe(20);
+        });
+    });
+    describe('isRequestInterceptHandled', () => {
+        it('returns true when handler reports handled', () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => true,
+            };
+            expect(base.isRequestInterceptHandled(request)).toBe(true);
+        });
+        it('returns false when handler reports not handled', () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => false,
+            };
+            expect(base.isRequestInterceptHandled(request)).toBe(false);
+        });
+        it('returns false when isInterceptResolutionHandled is not a function', () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+            };
+            expect(base.isRequestInterceptHandled(request)).toBe(false);
+        });
+        it('returns false when isInterceptResolutionHandled throws', () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => {
+                    throw new Error('oops');
+                },
+            };
+            expect(base.isRequestInterceptHandled(request)).toBe(false);
+        });
+    });
+    describe('continueRequest', () => {
+        it('calls continue when not already handled', async () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn().mockResolvedValue(undefined),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.continueRequest(request);
+            expect(request.continue).toHaveBeenCalled();
+        });
+        it('skips continue when already handled', async () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => true,
+            };
+            await base.continueRequest(request);
+            expect(request.continue).not.toHaveBeenCalled();
+        });
+        it('swallows errors from continue', async () => {
+            const request = {
+                url: () => '',
+                resourceType: () => 'script',
+                continue: vi.fn().mockRejectedValue(new Error('race condition')),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => false,
+            };
+            await expect(base.continueRequest(request)).resolves.toBeUndefined();
+        });
+    });
+    describe('ruleMatchesUrl', () => {
+        const makeRule = (url, matchType) => ({
+            id: 'test',
+            url,
+            replacement: '',
+            matchType,
+            createdAt: 0,
+            hits: 0,
+        });
+        it('matches exact URLs', () => {
+            const rule = makeRule('https://example.com/main.js', 'exact');
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/main.js')).toBe(true);
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/other.js')).toBe(false);
+        });
+        it('matches contained substrings', () => {
+            const rule = makeRule('main.js', 'contains');
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/main.js')).toBe(true);
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/other.js')).toBe(false);
+        });
+        it('matches regex patterns', () => {
+            const rule = makeRule('main\\.js$', 'regex');
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/main.js')).toBe(true);
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/main.jsx')).toBe(false);
+        });
+        it('returns false for invalid regex', () => {
+            const rule = makeRule('[invalid', 'regex');
+            expect(base.ruleMatchesUrl(rule, 'https://example.com/main.js')).toBe(false);
+        });
+    });
+    describe('findMatchingRule', () => {
+        it('returns null when no rules exist', () => {
+            expect(base.findMatchingRule('https://example.com/main.js')).toBeNull();
+        });
+        it('returns last matching rule (highest priority)', () => {
+            base.rules.push({ id: 'r1', url: 'main.js', replacement: 'a', matchType: 'contains', createdAt: 0, hits: 0 }, { id: 'r2', url: 'main.js', replacement: 'b', matchType: 'contains', createdAt: 0, hits: 0 });
+            const match = base.findMatchingRule('https://example.com/main.js');
+            expect(match?.id).toBe('r2');
+        });
+        it('returns null when no rules match', () => {
+            base.rules.push({
+                id: 'r1', url: 'other.js', replacement: 'a', matchType: 'exact', createdAt: 0, hits: 0,
+            });
+            expect(base.findMatchingRule('https://example.com/main.js')).toBeNull();
+        });
+    });
+    describe('handleInterceptedRequest', () => {
+        it('continues non-script requests', async () => {
+            const request = {
+                url: () => 'https://example.com/style.css',
+                resourceType: () => 'stylesheet',
+                continue: vi.fn().mockResolvedValue(undefined),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.handleInterceptedRequest(request);
+            expect(request.continue).toHaveBeenCalled();
+            expect(request.respond).not.toHaveBeenCalled();
+        });
+        it('continues script requests with no matching rules', async () => {
+            const request = {
+                url: () => 'https://example.com/main.js',
+                resourceType: () => 'script',
+                continue: vi.fn().mockResolvedValue(undefined),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.handleInterceptedRequest(request);
+            expect(request.continue).toHaveBeenCalled();
+        });
+        it('responds with replacement for matching script requests', async () => {
+            base.rules.push({
+                id: 'r1',
+                url: 'main.js',
+                replacement: 'console.log("replaced")',
+                matchType: 'contains',
+                createdAt: 0,
+                hits: 0,
+            });
+            const request = {
+                url: () => 'https://example.com/main.js',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn().mockResolvedValue(undefined),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.handleInterceptedRequest(request);
+            expect(request.respond).toHaveBeenCalledWith(expect.objectContaining({
+                status: 200,
+                body: 'console.log("replaced")',
+            }));
+            expect(getFirstRule(base).hits).toBe(1);
+        });
+        it('increments hits counter on each match', async () => {
+            base.rules.push({
+                id: 'r1',
+                url: 'main.js',
+                replacement: 'x',
+                matchType: 'contains',
+                createdAt: 0,
+                hits: 0,
+            });
+            const request = {
+                url: () => 'https://example.com/main.js',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn().mockResolvedValue(undefined),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.handleInterceptedRequest(request);
+            await base.handleInterceptedRequest(request);
+            expect(getFirstRule(base).hits).toBe(2);
+        });
+        it('falls back to continue if respond throws', async () => {
+            base.rules.push({
+                id: 'r1',
+                url: 'main.js',
+                replacement: 'x',
+                matchType: 'contains',
+                createdAt: 0,
+                hits: 0,
+            });
+            const request = {
+                url: () => 'https://example.com/main.js',
+                resourceType: () => 'script',
+                continue: vi.fn().mockResolvedValue(undefined),
+                respond: vi.fn().mockRejectedValue(new Error('respond failed')),
+                isInterceptResolutionHandled: () => false,
+            };
+            await base.handleInterceptedRequest(request);
+            expect(request.continue).toHaveBeenCalled();
+        });
+        it('does nothing when already handled', async () => {
+            const request = {
+                url: () => 'https://example.com/main.js',
+                resourceType: () => 'script',
+                continue: vi.fn(),
+                respond: vi.fn(),
+                isInterceptResolutionHandled: () => true,
+            };
+            await base.handleInterceptedRequest(request);
+            expect(request.continue).not.toHaveBeenCalled();
+            expect(request.respond).not.toHaveBeenCalled();
+        });
+    });
+    describe('ensureScriptInterception', () => {
+        it('sets up request interception on first call', async () => {
+            const page = {
+                setRequestInterception: vi.fn().mockResolvedValue(undefined),
+                on: vi.fn(),
+            };
+            await base.ensureScriptInterception(page);
+            expect(page.setRequestInterception).toHaveBeenCalledWith(true);
+            expect(page.on).toHaveBeenCalledWith('request', expect.any(Function));
+        });
+        it('uses prependListener when available', async () => {
+            const page = {
+                setRequestInterception: vi.fn().mockResolvedValue(undefined),
+                on: vi.fn(),
+                prependListener: vi.fn(),
+            };
+            await base.ensureScriptInterception(page);
+            expect(page.prependListener).toHaveBeenCalledWith('request', expect.any(Function));
+            expect(page.on).not.toHaveBeenCalled();
+        });
+        it('does not re-install on second call for same page', async () => {
+            const page = {
+                setRequestInterception: vi.fn().mockResolvedValue(undefined),
+                on: vi.fn(),
+            };
+            await base.ensureScriptInterception(page);
+            await base.ensureScriptInterception(page);
+            expect(page.setRequestInterception).toHaveBeenCalledTimes(1);
+        });
+        it('installs separately for different pages', async () => {
+            const page1 = {
+                setRequestInterception: vi.fn().mockResolvedValue(undefined),
+                on: vi.fn(),
+            };
+            const page2 = {
+                setRequestInterception: vi.fn().mockResolvedValue(undefined),
+                on: vi.fn(),
+            };
+            await base.ensureScriptInterception(page1);
+            await base.ensureScriptInterception(page2);
+            expect(page1.setRequestInterception).toHaveBeenCalledTimes(1);
+            expect(page2.setRequestInterception).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/tests/server/domains/graphql/runtime-callgraph-additional.test.d.ts

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