@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/encoding/runtime.test.js

@@ -0,0 +1,428 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EncodingToolHandlers } from '../../../../src/server/domains/encoding/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('EncodingToolHandlers (handlers.impl.core.runtime)', () => {
+    const collector = {
+        getActivePage: vi.fn(),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new EncodingToolHandlers(collector);
+    });
+    describe('handleBinaryDetectFormat', () => {
+        it('returns error for invalid source', async () => {
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'invalid', data: 'aa' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid source');
+        });
+        it('returns error when data is missing for non-file source', async () => {
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'raw' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+        it('detects base64 source and returns analysis', async () => {
+            const data = Buffer.from('Hello, World!').toString('base64');
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('base64');
+            expect(body.byteLength).toBeGreaterThan(0);
+            expect(body.encodingSignals).toContain('base64');
+            expect(typeof body.entropy).toBe('number');
+            expect(typeof body.assessment).toBe('string');
+            expect(body.previewHex).toBeTruthy();
+        });
+        it('detects hex source and returns analysis', async () => {
+            const data = '48656c6c6f';
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'hex', data }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('hex');
+            expect(body.byteLength).toBe(5);
+            expect(body.encodingSignals).toContain('hex');
+        });
+        it('defaults source to raw', async () => {
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ data: '48656c6c6f' }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('raw');
+        });
+        it('detects magic formats for PNG header', async () => {
+            const pngHeader = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+            const data = pngHeader.toString('base64');
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(body.magicFormats).toContain('png');
+        });
+        it('returns topBytes in frequency analysis', async () => {
+            const data = Buffer.from('aaabbc').toString('base64');
+            const body = parseJson(await handlers.handleBinaryDetectFormat({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(Array.isArray(body.topBytes)).toBe(true);
+        });
+        it('reports requestBodyUsed as false when no requestId is provided', async () => {
+            const body = parseJson(await handlers.handleBinaryDetectFormat({
+                source: 'base64',
+                data: Buffer.from('test').toString('base64'),
+            }));
+            expect(body.requestBodyUsed).toBe(false);
+            expect(body.requestId).toBeNull();
+        });
+    });
+    describe('handleBinaryDecode', () => {
+        it('returns error when data is missing', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({ encoding: 'base64' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+        it('returns error for invalid encoding', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({ data: 'aaa', encoding: 'invalid' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid encoding');
+        });
+        it('returns error for invalid outputFormat', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: 'aGVsbG8=',
+                encoding: 'base64',
+                outputFormat: 'invalid',
+            }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid outputFormat');
+        });
+        it('decodes base64 to hex output', async () => {
+            const data = Buffer.from('hello').toString('base64');
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data,
+                encoding: 'base64',
+                outputFormat: 'hex',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.encoding).toBe('base64');
+            expect(body.outputFormat).toBe('hex');
+            expect(body.result).toBe(Buffer.from('hello').toString('hex'));
+        });
+        it('decodes base64 to utf8 output', async () => {
+            const data = Buffer.from('hello').toString('base64');
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data,
+                encoding: 'base64',
+                outputFormat: 'utf8',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.outputFormat).toBe('utf8');
+        });
+        it('decodes hex input to hex output', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: '48656c6c6f',
+                encoding: 'hex',
+                outputFormat: 'hex',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.encoding).toBe('hex');
+        });
+        it('decodes url encoding to utf8', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: 'hello%20world',
+                encoding: 'url',
+                outputFormat: 'utf8',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.encoding).toBe('url');
+            expect(body.outputFormat).toBe('utf8');
+            expect(body.result).toBe('hello world');
+        });
+        it('decodes url encoding to hex', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: 'hello',
+                encoding: 'url',
+                outputFormat: 'hex',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.encoding).toBe('url');
+            expect(body.outputFormat).toBe('hex');
+            expect(body.byteLength).toBeGreaterThan(0);
+            expect(typeof body.hexDump).toBe('string');
+        });
+        it('decodes url encoding to json for JSON content', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: '%7B%22ok%22%3Atrue%7D',
+                encoding: 'url',
+                outputFormat: 'json',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.result).toEqual({ ok: true });
+        });
+        it('decodes url encoding to json with text fallback for non-JSON', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: 'plain+text',
+                encoding: 'url',
+                outputFormat: 'json',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.result).toEqual({ text: 'plain text' });
+        });
+        it('defaults outputFormat to hex', async () => {
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data: Buffer.from('hi').toString('base64'),
+                encoding: 'base64',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.outputFormat).toBe('hex');
+        });
+        it('decodes protobuf data', async () => {
+            const proto = Buffer.from([0x08, 0x96, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleBinaryDecode({
+                data,
+                encoding: 'protobuf',
+                outputFormat: 'json',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.encoding).toBe('protobuf');
+        });
+    });
+    describe('handleBinaryEncode', () => {
+        it('returns error when data is missing', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({ inputFormat: 'utf8', outputEncoding: 'base64' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+        it('returns error for invalid inputFormat', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'hello',
+                inputFormat: 'invalid',
+                outputEncoding: 'base64',
+            }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid inputFormat');
+        });
+        it('returns error for invalid outputEncoding', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'hello',
+                inputFormat: 'utf8',
+                outputEncoding: 'invalid',
+            }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid outputEncoding');
+        });
+        it('encodes utf8 to base64', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'hello',
+                inputFormat: 'utf8',
+                outputEncoding: 'base64',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.inputFormat).toBe('utf8');
+            expect(body.outputEncoding).toBe('base64');
+            expect(body.output).toBe(Buffer.from('hello').toString('base64'));
+            expect(body.byteLength).toBe(5);
+        });
+        it('encodes utf8 to hex', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'hello',
+                inputFormat: 'utf8',
+                outputEncoding: 'hex',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.output).toBe(Buffer.from('hello').toString('hex'));
+        });
+        it('encodes utf8 to url', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'hello world',
+                inputFormat: 'utf8',
+                outputEncoding: 'url',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.output).toContain('hello');
+            expect(body.output).toContain('%20');
+        });
+        it('encodes hex input to base64', async () => {
+            const hexData = Buffer.from('hello').toString('hex');
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: hexData,
+                inputFormat: 'hex',
+                outputEncoding: 'base64',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.output).toBe(Buffer.from('hello').toString('base64'));
+        });
+        it('encodes json input to base64', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: '{"key":"value"}',
+                inputFormat: 'json',
+                outputEncoding: 'base64',
+            }));
+            expect(body.success).toBe(true);
+            expect(body.inputFormat).toBe('json');
+            const decoded = Buffer.from(body.output, 'base64').toString('utf8');
+            expect(JSON.parse(decoded)).toEqual({ key: 'value' });
+        });
+        it('returns error for invalid JSON in json inputFormat', async () => {
+            const body = parseJson(await handlers.handleBinaryEncode({
+                data: 'not-valid-json{',
+                inputFormat: 'json',
+                outputEncoding: 'base64',
+            }));
+            expect(body.success).toBe(false);
+            expect(body.tool).toBe('binary_encode');
+        });
+    });
+    describe('handleBinaryEntropyAnalysis', () => {
+        it('returns error for invalid source', async () => {
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'invalid' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('Invalid source');
+        });
+        it('returns error when data is missing for non-file source', async () => {
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'raw' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+        it('defaults source to raw', async () => {
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ data: 'some data here' }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('raw');
+        });
+        it('analyzes entropy for base64 data', async () => {
+            const data = Buffer.from('Hello, World! This is a test string.').toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('base64');
+            expect(typeof body.overallEntropy).toBe('number');
+            expect(body.overallEntropy).toBeGreaterThanOrEqual(0);
+            expect(body.overallEntropy).toBeLessThanOrEqual(8);
+            expect(typeof body.assessment).toBe('string');
+            expect(Array.isArray(body.blockEntropies)).toBe(true);
+            expect(Array.isArray(body.byteFrequency)).toBe(true);
+            expect(body.byteLength).toBeGreaterThan(0);
+        });
+        it('analyzes entropy for hex data', async () => {
+            const data = '48656c6c6f20576f726c64';
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'hex', data }));
+            expect(body.success).toBe(true);
+            expect(body.source).toBe('hex');
+        });
+        it('uses custom blockSize', async () => {
+            const data = Buffer.from('a'.repeat(100)).toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({
+                source: 'base64',
+                data,
+                blockSize: 32,
+            }));
+            expect(body.success).toBe(true);
+            expect(body.blockSize).toBe(32);
+        });
+        it('clamps blockSize to minimum 16', async () => {
+            const data = Buffer.from('test data').toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({
+                source: 'base64',
+                data,
+                blockSize: 1,
+            }));
+            expect(body.success).toBe(true);
+            expect(body.blockSize).toBe(16);
+        });
+        it('clamps blockSize to maximum 8192', async () => {
+            const data = Buffer.from('test data').toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({
+                source: 'base64',
+                data,
+                blockSize: 99999,
+            }));
+            expect(body.success).toBe(true);
+            expect(body.blockSize).toBe(8192);
+        });
+        it('defaults blockSize to 256', async () => {
+            const data = Buffer.from('test data').toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(body.blockSize).toBe(256);
+        });
+        it('returns byteFrequency limited to top 20', async () => {
+            const bytes = Array.from({ length: 256 }, (_, i) => i);
+            const data = Buffer.from(bytes).toString('base64');
+            const body = parseJson(await handlers.handleBinaryEntropyAnalysis({ source: 'base64', data }));
+            expect(body.success).toBe(true);
+            expect(body.byteFrequency.length).toBeLessThanOrEqual(20);
+        });
+    });
+    describe('handleProtobufDecodeRaw', () => {
+        it('returns error when data is missing', async () => {
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({}));
+            expect(body.success).toBe(false);
+            expect(body.tool).toBe('protobuf_decode_raw');
+            expect(body.error).toContain('data is required');
+        });
+        it('returns error when data is empty string', async () => {
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data: '' }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+        it('decodes valid protobuf data', async () => {
+            const proto = Buffer.from([0x08, 0x96, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data }));
+            expect(body.success).toBe(true);
+            expect(body.byteLength).toBe(3);
+            expect(body.parsedBytes).toBe(3);
+            expect(body.fields).toHaveLength(1);
+            expect(body.fields[0].fieldNumber).toBe(1);
+            expect(body.fields[0].wireType).toBe(0);
+            expect(body.fields[0].value).toBe(150);
+            expect(body.error).toBeNull();
+        });
+        it('defaults maxDepth to 5', async () => {
+            const proto = Buffer.from([0x08, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data }));
+            expect(body.maxDepth).toBe(5);
+        });
+        it('respects custom maxDepth', async () => {
+            const proto = Buffer.from([0x08, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data, maxDepth: 10 }));
+            expect(body.maxDepth).toBe(10);
+        });
+        it('falls back to default maxDepth of 5 when maxDepth is 0 (falsy)', async () => {
+            const proto = Buffer.from([0x08, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data, maxDepth: 0 }));
+            expect(body.maxDepth).toBe(5);
+        });
+        it('clamps negative maxDepth to minimum 1', async () => {
+            const proto = Buffer.from([0x08, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data, maxDepth: -5 }));
+            expect(body.maxDepth).toBe(1);
+        });
+        it('clamps maxDepth to maximum 20', async () => {
+            const proto = Buffer.from([0x08, 0x01]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data, maxDepth: 100 }));
+            expect(body.maxDepth).toBe(20);
+        });
+        it('decodes multiple fields', async () => {
+            const proto = Buffer.from([0x08, 0x01, 0x10, 0x02]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data }));
+            expect(body.success).toBe(true);
+            expect(body.fields).toHaveLength(2);
+            expect(body.fields[0].value).toBe(1);
+            expect(body.fields[1].value).toBe(2);
+        });
+        it('reports error for malformed protobuf while returning partial fields', async () => {
+            const proto = Buffer.from([0x08, 0x01, 0x0b]);
+            const data = proto.toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data }));
+            expect(body.success).toBe(false);
+            expect(body.fields).toHaveLength(1);
+            expect(body.error).toBeTruthy();
+        });
+        it('returns error for empty base64 data (resolves to empty string)', async () => {
+            const data = Buffer.alloc(0).toString('base64');
+            const body = parseJson(await handlers.handleProtobufDecodeRaw({ data }));
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('data is required');
+        });
+    });
+});

package/dist/tests/server/domains/graphql/definitions.test.d.ts

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

package/dist/tests/server/domains/graphql/definitions.test.js

@@ -0,0 +1,223 @@
+import { describe, expect, it, vi } from 'vitest';
+const isSsrfTargetMock = vi.fn(async () => false);
+vi.mock('@src/server/domains/network/replay', () => ({
+    isSsrfTarget: vi.fn(async () => isSsrfTargetMock()),
+}));
+import { graphqlTools } from '../../../../src/server/domains/graphql/definitions.js';
+describe('graphql definitions', () => {
+    describe('tool array structure', () => {
+        it('exports a non-empty array of tools', () => {
+            expect(Array.isArray(graphqlTools)).toBe(true);
+            expect(graphqlTools.length).toBeGreaterThan(0);
+        });
+        it('contains exactly 5 tools', () => {
+            expect(graphqlTools).toHaveLength(5);
+        });
+        it('every tool has a name and description', () => {
+            for (const tool of graphqlTools) {
+                expect(typeof tool.name).toBe('string');
+                expect(tool.name.length).toBeGreaterThan(0);
+                expect(typeof tool.description).toBe('string');
+                expect(tool.description.length).toBeGreaterThan(0);
+            }
+        });
+        it('every tool has an inputSchema', () => {
+            for (const tool of graphqlTools) {
+                expect(tool.inputSchema).toBeDefined();
+                expect(tool.inputSchema.type).toBe('object');
+            }
+        });
+        it('tool names are unique', () => {
+            const names = graphqlTools.map((t) => t.name);
+            expect(new Set(names).size).toBe(names.length);
+        });
+    });
+    describe('call_graph_analyze tool', () => {
+        const tool = graphqlTools.find((t) => t.name === 'call_graph_analyze');
+        it('exists', () => {
+            expect(tool).toBeDefined();
+        });
+        it('has maxDepth property', () => {
+            expect(tool.inputSchema.properties).toHaveProperty('maxDepth');
+            expect(tool.inputSchema.properties.maxDepth.type).toBe('number');
+            expect(tool.inputSchema.properties.maxDepth.default).toBe(5);
+        });
+        it('has filterPattern property', () => {
+            expect(tool.inputSchema.properties).toHaveProperty('filterPattern');
+            expect(tool.inputSchema.properties.filterPattern.type).toBe('string');
+        });
+        it('has no required fields', () => {
+            expect(tool.inputSchema.required).toBeUndefined();
+        });
+    });
+    describe('script_replace_persist tool', () => {
+        const tool = graphqlTools.find((t) => t.name === 'script_replace_persist');
+        it('exists', () => {
+            expect(tool).toBeDefined();
+        });
+        it('has url and replacement as required', () => {
+            expect(tool.inputSchema.required).toEqual(['url', 'replacement']);
+        });
+        it('has url property', () => {
+            expect(tool.inputSchema.properties).toHaveProperty('url');
+        });
+        it('has replacement property', () => {
+            expect(tool.inputSchema.properties).toHaveProperty('replacement');
+        });
+        it('has matchType property with enum', () => {
+            const matchType = tool.inputSchema.properties.matchType;
+            expect(matchType).toBeDefined();
+            expect(matchType.enum).toEqual(['exact', 'contains', 'regex']);
+            expect(matchType.default).toBe('contains');
+        });
+    });
+    describe('graphql_introspect tool', () => {
+        const tool = graphqlTools.find((t) => t.name === 'graphql_introspect');
+        it('exists', () => {
+            expect(tool).toBeDefined();
+        });
+        it('has endpoint as required', () => {
+            expect(tool.inputSchema.required).toEqual(['endpoint']);
+        });
+        it('has headers property with additionalProperties string', () => {
+            const headers = tool.inputSchema.properties.headers;
+            expect(headers).toBeDefined();
+            expect(headers.type).toBe('object');
+            expect(headers.additionalProperties.type).toBe('string');
+        });
+    });
+    describe('graphql_extract_queries tool', () => {
+        const tool = graphqlTools.find((t) => t.name === 'graphql_extract_queries');
+        it('exists', () => {
+            expect(tool).toBeDefined();
+        });
+        it('has limit property', () => {
+            const limit = tool.inputSchema.properties.limit;
+            expect(limit).toBeDefined();
+            expect(limit.type).toBe('number');
+            expect(limit.default).toBe(50);
+        });
+        it('has no required fields', () => {
+            expect(tool.inputSchema.required).toBeUndefined();
+        });
+    });
+    describe('graphql_replay tool', () => {
+        const tool = graphqlTools.find((t) => t.name === 'graphql_replay');
+        it('exists', () => {
+            expect(tool).toBeDefined();
+        });
+        it('has endpoint and query as required', () => {
+            expect(tool.inputSchema.required).toEqual(['endpoint', 'query']);
+        });
+        it('has variables property', () => {
+            const variables = tool.inputSchema.properties.variables;
+            expect(variables).toBeDefined();
+            expect(variables.type).toBe('object');
+            expect(variables.additionalProperties).toBe(true);
+        });
+        it('has operationName property', () => {
+            const operationName = tool.inputSchema.properties.operationName;
+            expect(operationName).toBeDefined();
+            expect(operationName.type).toBe('string');
+        });
+        it('has headers property', () => {
+            const headers = tool.inputSchema.properties.headers;
+            expect(headers).toBeDefined();
+            expect(headers.type).toBe('object');
+        });
+    });
+});
+describe('graphql barrel/re-export chain', () => {
+    it('handlers.ts re-exports GraphQLToolHandlers', async () => {
+        const handlers = await import('../../../../src/server/domains/graphql/handlers.js');
+        expect(handlers.GraphQLToolHandlers).toBeDefined();
+        expect(typeof handlers.GraphQLToolHandlers).toBe('function');
+    });
+    it('index.ts re-exports graphqlTools and GraphQLToolHandlers', async () => {
+        const indexModule = await import('../../../../src/server/domains/graphql/index.js');
+        expect(indexModule.graphqlTools).toBeDefined();
+        expect(indexModule.GraphQLToolHandlers).toBeDefined();
+        expect(Array.isArray(indexModule.graphqlTools)).toBe(true);
+    });
+    it('GraphQLToolHandlers from handlers.ts is the same class as from index.ts', async () => {
+        const fromHandlers = await import('../../../../src/server/domains/graphql/handlers.js');
+        const fromIndex = await import('../../../../src/server/domains/graphql/index.js');
+        expect(fromHandlers.GraphQLToolHandlers).toBe(fromIndex.GraphQLToolHandlers);
+    });
+});
+describe('graphql manifest', () => {
+    it('exports a valid domain manifest', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        expect(manifest).toBeDefined();
+        expect(manifest.kind).toBe('domain-manifest');
+        expect(manifest.version).toBe(1);
+        expect(manifest.domain).toBe('graphql');
+        expect(manifest.depKey).toBe('graphqlHandlers');
+    });
+    it('includes workflow and full profiles', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        expect(manifest.profiles).toEqual(['workflow', 'full']);
+    });
+    it('has registrations for all 5 tools', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        expect(manifest.registrations).toHaveLength(5);
+        const toolNames = manifest.registrations.map((r) => r.tool.name);
+        expect(toolNames).toContain('call_graph_analyze');
+        expect(toolNames).toContain('script_replace_persist');
+        expect(toolNames).toContain('graphql_introspect');
+        expect(toolNames).toContain('graphql_extract_queries');
+        expect(toolNames).toContain('graphql_replay');
+    });
+    it('all registrations have domain set to graphql', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        for (const reg of manifest.registrations) {
+            expect(reg.domain).toBe('graphql');
+        }
+    });
+    it('all registrations have a bind function', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        for (const reg of manifest.registrations) {
+            expect(typeof reg.bind).toBe('function');
+        }
+    });
+    it('ensure function creates handlers when called', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        const ctx = {
+            config: { puppeteer: {} },
+            registerCaches: vi.fn(async () => { }),
+        };
+        const result = manifest.ensure(ctx);
+        expect(result).toBeDefined();
+        expect(ctx.graphqlHandlers).toBe(result);
+        expect(ctx.collector).toBeDefined();
+    });
+    it('ensure function reuses existing handlers', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        const ctx = {
+            config: { puppeteer: {} },
+            registerCaches: vi.fn(async () => { }),
+        };
+        const first = manifest.ensure(ctx);
+        const second = manifest.ensure(ctx);
+        expect(first).toBe(second);
+    });
+    it('ensure function reuses existing collector', async () => {
+        const manifestModule = await import('../../../../src/server/domains/graphql/manifest.js');
+        const manifest = manifestModule.default;
+        const existingCollector = { existing: true };
+        const ctx = {
+            config: { puppeteer: {} },
+            collector: existingCollector,
+            registerCaches: vi.fn(async () => { }),
+        };
+        manifest.ensure(ctx);
+        expect(ctx.collector).toBe(existingCollector);
+    });
+});

package/dist/tests/server/domains/graphql/exports.test.d.ts

@@ -0,0 +1 @@
+import '../shared/manifest-test-mocks.js';