@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { advancedTools } from '../../../../src/server/domains/network/definitions.js';
+function findTool(name) {
+    const tool = advancedTools.find((candidate) => candidate.name === name);
+    expect(tool, `Expected tool "${name}" to exist`).toBeDefined();
+    return tool;
+}
+function getProperties(tool) {
+    expect(tool.inputSchema.properties, `${tool.name} should define inputSchema.properties`).toBeDefined();
+    return (tool.inputSchema.properties ?? {});
+}
+describe('network tool definitions', () => {
+    it('exports a non-empty array of tool definitions', () => {
+        expect(Array.isArray(advancedTools)).toBe(true);
+        expect(advancedTools.length).toBeGreaterThan(0);
+    });
+    it('every tool has a name, description, and inputSchema', () => {
+        for (const tool of advancedTools) {
+            expect(tool.name).toEqual(expect.any(String));
+            expect(tool.name.length).toBeGreaterThan(0);
+            expect(tool.description).toEqual(expect.any(String));
+            expect((tool.description ?? '').length).toBeGreaterThan(0);
+            expect(tool.inputSchema).toBeDefined();
+            expect(tool.inputSchema.type).toBe('object');
+            expect(tool.inputSchema.properties).toBeDefined();
+        }
+    });
+    it('has no duplicate tool names', () => {
+        const names = advancedTools.map((t) => t.name);
+        const unique = new Set(names);
+        expect(unique.size).toBe(names.length);
+    });
+    it('tool names use snake_case convention', () => {
+        for (const tool of advancedTools) {
+            expect(tool.name).toMatch(/^[a-z][a-z0-9_]*$/);
+        }
+    });
+    it('contains expected core network tools', () => {
+        const names = new Set(advancedTools.map((t) => t.name));
+        expect(names.has('network_enable')).toBe(true);
+        expect(names.has('network_disable')).toBe(true);
+        expect(names.has('network_get_status')).toBe(true);
+        expect(names.has('network_get_requests')).toBe(true);
+        expect(names.has('network_get_response_body')).toBe(true);
+        expect(names.has('network_get_stats')).toBe(true);
+    });
+    it('contains expected performance tools', () => {
+        const names = new Set(advancedTools.map((t) => t.name));
+        expect(names.has('performance_get_metrics')).toBe(true);
+        expect(names.has('performance_start_coverage')).toBe(true);
+        expect(names.has('performance_stop_coverage')).toBe(true);
+        expect(names.has('performance_take_heap_snapshot')).toBe(true);
+        expect(names.has('performance_trace_start')).toBe(true);
+        expect(names.has('performance_trace_stop')).toBe(true);
+    });
+    it('contains expected profiler tools', () => {
+        const names = new Set(advancedTools.map((t) => t.name));
+        expect(names.has('profiler_cpu_start')).toBe(true);
+        expect(names.has('profiler_cpu_stop')).toBe(true);
+        expect(names.has('profiler_heap_sampling_start')).toBe(true);
+        expect(names.has('profiler_heap_sampling_stop')).toBe(true);
+    });
+    it('contains expected console tools', () => {
+        const names = new Set(advancedTools.map((t) => t.name));
+        expect(names.has('console_get_exceptions')).toBe(true);
+        expect(names.has('console_inject_script_monitor')).toBe(true);
+        expect(names.has('console_inject_xhr_interceptor')).toBe(true);
+        expect(names.has('console_inject_fetch_interceptor')).toBe(true);
+        expect(names.has('console_clear_injected_buffers')).toBe(true);
+        expect(names.has('console_reset_injected_interceptors')).toBe(true);
+        expect(names.has('console_inject_function_tracer')).toBe(true);
+    });
+    it('contains expected analysis tools', () => {
+        const names = new Set(advancedTools.map((t) => t.name));
+        expect(names.has('network_extract_auth')).toBe(true);
+        expect(names.has('network_export_har')).toBe(true);
+        expect(names.has('network_replay_request')).toBe(true);
+    });
+    it('network_get_response_body requires requestId', () => {
+        const tool = findTool('network_get_response_body');
+        expect(tool.inputSchema.required).toContain('requestId');
+    });
+    it('network_replay_request requires requestId', () => {
+        const tool = findTool('network_replay_request');
+        expect(tool.inputSchema.required).toContain('requestId');
+    });
+    it('console_inject_function_tracer requires functionName', () => {
+        const tool = findTool('console_inject_function_tracer');
+        expect(tool.inputSchema.required).toContain('functionName');
+    });
+    it('network_get_requests has expected filter properties', () => {
+        const tool = findTool('network_get_requests');
+        const props = getProperties(tool);
+        expect(props.url).toBeDefined();
+        expect(props.urlRegex).toBeDefined();
+        expect(props.method).toBeDefined();
+        expect(props.sinceTimestamp).toBeDefined();
+        expect(props.sinceRequestId).toBeDefined();
+        expect(props.tail).toBeDefined();
+        expect(props.limit).toBeDefined();
+        expect(props.offset).toBeDefined();
+        expect(props.autoEnable).toBeDefined();
+        expect(props.enableExceptions).toBeDefined();
+    });
+    it('performance_trace_start has categories and screenshots properties', () => {
+        const tool = findTool('performance_trace_start');
+        const props = getProperties(tool);
+        expect(props.categories).toBeDefined();
+        expect(props.categories?.type).toBe('array');
+        expect(props.screenshots).toBeDefined();
+        expect(props.screenshots?.type).toBe('boolean');
+    });
+    it('profiler_heap_sampling_start has samplingInterval property', () => {
+        const tool = findTool('profiler_heap_sampling_start');
+        const props = getProperties(tool);
+        expect(props.samplingInterval).toBeDefined();
+        expect(props.samplingInterval?.type).toBe('number');
+    });
+    it('all inputSchema.properties entries have a type field', () => {
+        for (const tool of advancedTools) {
+            const props = getProperties(tool);
+            for (const [key, value] of Object.entries(props)) {
+                expect(value.type, `${tool.name}.properties.${key} should have a type`).toBeDefined();
+            }
+        }
+    });
+    it('all inputSchema.properties entries have a description field', () => {
+        for (const tool of advancedTools) {
+            const props = getProperties(tool);
+            for (const [key, value] of Object.entries(props)) {
+                expect(value.description, `${tool.name}.properties.${key} should have a description`).toBeDefined();
+                expect(typeof value.description).toBe('string');
+            }
+        }
+    });
+    it('required fields reference properties that exist in the schema', () => {
+        for (const tool of advancedTools) {
+            const required = tool.inputSchema.required;
+            if (!required)
+                continue;
+            const propNames = Object.keys(getProperties(tool));
+            for (const field of required) {
+                expect(propNames, `${tool.name}: required field "${field}" must exist in properties`).toContain(field);
+            }
+        }
+    });
+});

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

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

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

package/dist/tests/server/domains/network/har.test.d.ts

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

package/dist/tests/server/domains/network/har.test.js

@@ -0,0 +1,464 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { buildHar } from '../../../../src/server/domains/network/har.js';
+function makeRequest(overrides = {}) {
+    return {
+        requestId: 'req-1',
+        url: 'https://example.com/api/data',
+        method: 'GET',
+        headers: {},
+        timestamp: 1700000000,
+        ...overrides,
+    };
+}
+function makeResponse(overrides = {}) {
+    return {
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'application/json' },
+        mimeType: 'application/json',
+        timing: { receiveHeadersEnd: 120 },
+        ...overrides,
+    };
+}
+function getEntry(har, index = 0) {
+    const entry = har.log.entries[index];
+    expect(entry).toBeDefined();
+    if (!entry) {
+        throw new Error(`Expected HAR to contain an entry at index ${index}`);
+    }
+    return entry;
+}
+describe('buildHar', () => {
+    let getResponseMock;
+    let getResponseBodyMock;
+    beforeEach(() => {
+        getResponseMock = vi.fn();
+        getResponseBodyMock = vi.fn();
+    });
+    it('returns a valid HAR 1.2 envelope with creator metadata', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+            creatorVersion: '1.2.3',
+        });
+        expect(har.log.version).toBe('1.2');
+        expect(har.log.creator).toEqual({ name: 'jshookmcp', version: '1.2.3' });
+        expect(har.log.entries).toHaveLength(1);
+    });
+    it('uses "unknown" as default creator version when not specified', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(har.log.creator.version).toBe('unknown');
+    });
+    it('returns an empty entries array when no requests are provided', async () => {
+        const har = await buildHar({
+            requests: [],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(har.log.entries).toEqual([]);
+        expect(getResponseMock).not.toHaveBeenCalled();
+        expect(getResponseBodyMock).not.toHaveBeenCalled();
+    });
+    it('maps request method, URL, and httpVersion correctly', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ method: 'POST', url: 'https://api.test/v1/submit' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const entry = getEntry(har);
+        expect(entry.request.method).toBe('POST');
+        expect(entry.request.url).toBe('https://api.test/v1/submit');
+        expect(entry.request.httpVersion).toBe('HTTP/1.1');
+    });
+    it('converts headers from Record to name/value pairs', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: { 'accept': 'text/html', 'x-custom': 'abc' } })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const headers = getEntry(har).request.headers;
+        expect(headers).toContainEqual({ name: 'accept', value: 'text/html' });
+        expect(headers).toContainEqual({ name: 'x-custom', value: 'abc' });
+    });
+    it('handles undefined request headers as empty array', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: undefined })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.headers).toEqual([]);
+    });
+    it('extracts query string parameters from the URL', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ url: 'https://example.com/api?foo=bar&baz=42' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const qs = getEntry(har).request.queryString;
+        expect(qs).toContainEqual({ name: 'foo', value: 'bar' });
+        expect(qs).toContainEqual({ name: 'baz', value: '42' });
+    });
+    it('returns empty queryString for URLs without query parameters', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ url: 'https://example.com/plain' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.queryString).toEqual([]);
+    });
+    it('returns empty queryString for malformed URLs', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ url: 'not-a-valid-url' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.queryString).toEqual([]);
+    });
+    it('parses request cookies from the Cookie header', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: { cookie: 'session=abc123; lang=en' } })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const cookies = getEntry(har).request.cookies;
+        expect(cookies).toContainEqual({ name: 'session', value: 'abc123' });
+        expect(cookies).toContainEqual({ name: 'lang', value: 'en' });
+    });
+    it('handles cookie values containing equals signs', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: { cookie: 'data=val=ue=test' } })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const cookies = getEntry(har).request.cookies;
+        expect(cookies).toContainEqual({ name: 'data', value: 'val=ue=test' });
+    });
+    it('handles cookies without an equals sign', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: { cookie: 'flag' } })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const cookies = getEntry(har).request.cookies;
+        expect(cookies).toContainEqual({ name: 'flag', value: '' });
+    });
+    it('parses response cookies from Set-Cookie header', async () => {
+        getResponseMock.mockReturnValue(makeResponse({ headers: { 'set-cookie': 'token=xyz789; sid=aaa' } }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const cookies = getEntry(har).response.cookies;
+        expect(cookies).toContainEqual({ name: 'token', value: 'xyz789' });
+    });
+    it('returns empty cookies when no cookie header is present', async () => {
+        getResponseMock.mockReturnValue(makeResponse({ headers: {} }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ headers: {} })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.cookies).toEqual([]);
+        expect(getEntry(har).response.cookies).toEqual([]);
+    });
+    it('includes postData when the request has a body', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [
+                makeRequest({
+                    method: 'POST',
+                    postData: '{"key":"value"}',
+                    headers: { 'content-type': 'application/json' },
+                }),
+            ],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const entry = getEntry(har);
+        expect(entry.request.postData).toEqual({
+            mimeType: 'application/json',
+            text: '{"key":"value"}',
+        });
+        expect(entry.request.bodySize).toBe(15);
+    });
+    it('uses application/octet-stream when content-type header is missing for postData', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ method: 'POST', postData: 'rawbody', headers: {} })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.postData.mimeType).toBe('application/octet-stream');
+    });
+    it('omits postData when request has no body', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ method: 'GET' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).request.postData).toBeUndefined();
+        expect(getEntry(har).request.bodySize).toBe(0);
+    });
+    it('maps response status, statusText, and headers', async () => {
+        getResponseMock.mockReturnValue(makeResponse({
+            status: 404,
+            statusText: 'Not Found',
+            headers: { 'x-powered-by': 'test' },
+        }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const resp = getEntry(har).response;
+        expect(resp.status).toBe(404);
+        expect(resp.statusText).toBe('Not Found');
+        expect(resp.headers).toContainEqual({ name: 'x-powered-by', value: 'test' });
+    });
+    it('handles missing response gracefully (undefined)', async () => {
+        getResponseMock.mockReturnValue(undefined);
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const resp = getEntry(har).response;
+        expect(resp.status).toBe(0);
+        expect(resp.statusText).toBe('');
+        expect(resp.headers).toEqual([]);
+        expect(resp.redirectURL).toBe('');
+    });
+    it('extracts redirect URL from location header', async () => {
+        getResponseMock.mockReturnValue(makeResponse({
+            status: 302,
+            headers: { location: 'https://example.com/redirected' },
+        }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).response.redirectURL).toBe('https://example.com/redirected');
+    });
+    it('populates timings from response timing data', async () => {
+        getResponseMock.mockReturnValue(makeResponse({ timing: { receiveHeadersEnd: 250 } }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const entry = getEntry(har);
+        expect(entry.time).toBe(250);
+        expect(entry.timings.wait).toBe(250);
+        expect(entry.timings.send).toBe(0);
+        expect(entry.timings.receive).toBe(0);
+    });
+    it('defaults timings to 0 when response has no timing data', async () => {
+        getResponseMock.mockReturnValue(makeResponse({ timing: undefined }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).time).toBe(0);
+        expect(getEntry(har).timings.wait).toBe(0);
+    });
+    it('converts request timestamp to ISO 8601 startedDateTime', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ timestamp: 1700000000 })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const expected = new Date(1700000000 * 1000).toISOString();
+        expect(getEntry(har).startedDateTime).toBe(expected);
+    });
+    it('uses current time when request has no timestamp', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const before = new Date().toISOString();
+        const har = await buildHar({
+            requests: [makeRequest({ timestamp: undefined })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        const after = new Date().toISOString();
+        const started = getEntry(har).startedDateTime;
+        expect(started >= before).toBe(true);
+        expect(started <= after).toBe(true);
+    });
+    it('fetches and includes response bodies when includeBodies is true', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue({ body: '{"result":42}', base64Encoded: false });
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: true,
+        });
+        const content = getEntry(har).response.content;
+        expect(content.text).toBe('{"result":42}');
+        expect(content.size).toBe(13);
+        expect(content._bodyUnavailable).toBeUndefined();
+    });
+    it('does not fetch bodies when includeBodies is false', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getResponseBodyMock).not.toHaveBeenCalled();
+        expect(getEntry(har).response.content.text).toBeUndefined();
+    });
+    it('marks body as unavailable when getResponseBody returns null', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: true,
+        });
+        expect(getEntry(har).response.content._bodyUnavailable).toBe(true);
+    });
+    it('marks body as unavailable when getResponseBody throws', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockRejectedValue(new Error('CDP error'));
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: true,
+        });
+        expect(getEntry(har).response.content._bodyUnavailable).toBe(true);
+    });
+    it('processes multiple requests and preserves order', async () => {
+        const requests = [
+            makeRequest({ requestId: 'r1', url: 'https://a.com/1', method: 'GET' }),
+            makeRequest({ requestId: 'r2', url: 'https://b.com/2', method: 'POST', postData: 'x' }),
+            makeRequest({ requestId: 'r3', url: 'https://c.com/3', method: 'PUT' }),
+        ];
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests,
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(har.log.entries).toHaveLength(3);
+        expect(getEntry(har)._requestId).toBe('r1');
+        expect(getEntry(har, 1)._requestId).toBe('r2');
+        expect(getEntry(har, 2)._requestId).toBe('r3');
+    });
+    it('fetches bodies in batches of 8 to limit concurrency', async () => {
+        const requests = Array.from({ length: 20 }, (_, i) => makeRequest({ requestId: `r-${i}`, url: `https://example.com/${i}` }));
+        getResponseMock.mockReturnValue(makeResponse());
+        let concurrentCalls = 0;
+        let maxConcurrent = 0;
+        getResponseBodyMock.mockImplementation(async () => {
+            concurrentCalls++;
+            maxConcurrent = Math.max(maxConcurrent, concurrentCalls);
+            await new Promise((r) => setTimeout(r, 10));
+            concurrentCalls--;
+            return { body: 'data', base64Encoded: false };
+        });
+        await buildHar({
+            requests,
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: true,
+        });
+        expect(getResponseBodyMock).toHaveBeenCalledTimes(20);
+        expect(maxConcurrent).toBeLessThanOrEqual(8);
+    });
+    it('includes _requestId in each entry for correlation', async () => {
+        getResponseMock.mockReturnValue(makeResponse());
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest({ requestId: 'my-special-id' })],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har)._requestId).toBe('my-special-id');
+    });
+    it('defaults content mimeType to application/octet-stream when response has no mimeType', async () => {
+        getResponseMock.mockReturnValue(makeResponse({ mimeType: undefined }));
+        getResponseBodyMock.mockResolvedValue(null);
+        const har = await buildHar({
+            requests: [makeRequest()],
+            getResponse: getResponseMock,
+            getResponseBody: getResponseBodyMock,
+            includeBodies: false,
+        });
+        expect(getEntry(har).response.content.mimeType).toBe('application/octet-stream');
+    });
+});

package/dist/tests/server/domains/network/replay-additional.test.d.ts

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