@jshookmcp/jshook 0.2.1 → 0.2.3

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

@@ -1,22 +0,0 @@
-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/hooks exports', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-    });
-    it('exposes hook tool definitions and a matching manifest', async () => {
-        expect.hasAssertions();
-        await assertDomainExportContract({
-            expectedDomain: 'hooks',
-            definitionExportNames: ['aiHookTools', 'hookPresetTools'],
-            loadDefinitions: () => import('../../../../src/server/domains/hooks/definitions.js'),
-            getToolArrays: (module) => [
-                module.aiHookTools,
-                module.hookPresetTools,
-            ],
-            loadManifest: () => import('../../../../src/server/domains/hooks/manifest.js'),
-        });
-    });
-});

package/dist/tests/server/domains/hooks/preset-builder.test.d.ts

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

package/dist/tests/server/domains/hooks/preset-builder.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildHookCode } from '../../../../src/server/domains/hooks/preset-builder.js';
-describe('buildHookCode', () => {
-    const SAMPLE_BODY = `
-  const _orig = window.eval;
-  window.eval = function(code) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:eval] code=' + String(code).substring(0, 200);
-    {{LOG_FN}}
-    window.__aiHooks['preset-eval'].push({ code: String(code).substring(0, 500), stack: __stack, ts: Date.now() });
-    return _orig.call(this, code);
-  };`;
-    it('returns a string wrapped in an IIFE', () => {
-        const code = buildHookCode('test-hook', SAMPLE_BODY, false, false);
-        expect(code).toContain('(function() {');
-        expect(code).toContain('})();');
-    });
-    it('sets up the __hookPresets idempotency guard', () => {
-        const code = buildHookCode('test-hook', SAMPLE_BODY, false, false);
-        expect(code).toContain("if (window.__hookPresets === undefined) window.__hookPresets = {};");
-        expect(code).toContain("if (window.__hookPresets['test-hook']) return;");
-    });
-    it('marks the preset as installed at the end', () => {
-        const code = buildHookCode('my-preset', SAMPLE_BODY, false, false);
-        expect(code).toContain("window.__hookPresets['my-preset'] = true;");
-    });
-    it('initialises the __aiHooks collection for the preset', () => {
-        const code = buildHookCode('my-preset', SAMPLE_BODY, false, false);
-        expect(code).toContain("window.__aiHooks = window.__aiHooks || {};");
-        expect(code).toContain("window.__aiHooks['preset-my-preset'] = window.__aiHooks['preset-my-preset'] || [];");
-    });
-    describe('captureStack parameter', () => {
-        it('emits stack-capture code when captureStack is true', () => {
-            const code = buildHookCode('test', SAMPLE_BODY, true, false);
-            expect(code).toContain("const __stack = new Error().stack?.split('\\n').slice(1,4).join(' | ') || '';");
-            expect(code).not.toContain('{{STACK_CODE}}');
-        });
-        it('emits empty-stack assignment when captureStack is false', () => {
-            const code = buildHookCode('test', SAMPLE_BODY, false, false);
-            expect(code).toContain("const __stack = '';");
-            expect(code).not.toContain('new Error().stack');
-            expect(code).not.toContain('{{STACK_CODE}}');
-        });
-    });
-    describe('logToConsole parameter', () => {
-        it('emits console.log call when logToConsole is true', () => {
-            const code = buildHookCode('test', SAMPLE_BODY, false, true);
-            expect(code).toContain("console.log(__msg + (__stack ? ' | Stack: ' + __stack : ''));");
-            expect(code).not.toContain('{{LOG_FN}}');
-        });
-        it('omits console.log call when logToConsole is false', () => {
-            const code = buildHookCode('test', SAMPLE_BODY, false, false);
-            expect(code).not.toContain('console.log');
-            expect(code).not.toContain('{{LOG_FN}}');
-        });
-    });
-    describe('combined captureStack + logToConsole', () => {
-        it('emits both stack capture and console.log when both are true', () => {
-            const code = buildHookCode('combo', SAMPLE_BODY, true, true);
-            expect(code).toContain("const __stack = new Error().stack?.split('\\n').slice(1,4).join(' | ') || '';");
-            expect(code).toContain('console.log');
-        });
-        it('emits neither stack capture nor console.log when both are false', () => {
-            const code = buildHookCode('combo', SAMPLE_BODY, false, false);
-            expect(code).toContain("const __stack = '';");
-            expect(code).not.toContain('console.log');
-        });
-    });
-    it('replaces all {{STACK_CODE}} and {{LOG_FN}} placeholders in multi-occurrence body', () => {
-        const multiBody = `
-    fn1() { {{STACK_CODE}} {{LOG_FN}} }
-    fn2() { {{STACK_CODE}} {{LOG_FN}} }`;
-        const code = buildHookCode('multi', multiBody, true, true);
-        expect(code).not.toContain('{{STACK_CODE}}');
-        expect(code).not.toContain('{{LOG_FN}}');
-        const stackMatches = code.match(/const __stack = new Error\(\)/g);
-        expect(stackMatches).toHaveLength(2);
-        const logMatches = code.match(/console\.log\(__msg/g);
-        expect(logMatches).toHaveLength(2);
-    });
-    it('embeds the preset name correctly into generated code', () => {
-        const code = buildHookCode('my-custom-name', '{{STACK_CODE}} {{LOG_FN}}', false, false);
-        expect(code).toContain("window.__hookPresets['my-custom-name']");
-        expect(code).toContain("window.__aiHooks['preset-my-custom-name']");
-    });
-    it('preserves the body content beyond placeholders', () => {
-        const body = `
-    {{STACK_CODE}}
-    const __msg = 'unique-marker-string';
-    {{LOG_FN}}
-    doSomething();`;
-        const code = buildHookCode('preserve', body, false, false);
-        expect(code).toContain('unique-marker-string');
-        expect(code).toContain('doSomething();');
-    });
-});
-describe('PresetEntry type contract', () => {
-    it('accepts an object conforming to the PresetEntry shape', () => {
-        const entry = {
-            description: 'A test preset',
-            buildCode: (captureStack, logToConsole) => buildHookCode('type-check', '{{STACK_CODE}} {{LOG_FN}}', captureStack, logToConsole),
-        };
-        expect(entry.description).toBe('A test preset');
-        expect(typeof entry.buildCode).toBe('function');
-        const code = entry.buildCode(true, false);
-        expect(typeof code).toBe('string');
-        expect(code).toContain('type-check');
-    });
-});

package/dist/tests/server/domains/hooks/preset-definitions.core.test.d.ts

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

package/dist/tests/server/domains/hooks/preset-definitions.core.test.js

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockBuildHookCode = vi.hoisted(() => vi.fn((name, _body, cs, lc) => `[mock:${name}:cs=${cs}:lc=${lc}]`));
-vi.mock('@server/domains/hooks/preset-builder', () => ({
-    buildHookCode: mockBuildHookCode,
-}));
-import { CORE_PRESETS } from '../../../../src/server/domains/hooks/preset-definitions.core.js';
-const EXPECTED_CORE_IDS = [
-    'eval',
-    'function-constructor',
-    'atob-btoa',
-    'crypto-subtle',
-    'json-stringify',
-    'object-defineproperty',
-    'settimeout',
-    'setinterval',
-    'addeventlistener',
-    'postmessage',
-    'webassembly',
-    'proxy',
-    'reflect',
-    'history-pushstate',
-    'location-href',
-    'navigator-useragent',
-    'eventsource',
-    'window-open',
-    'mutationobserver',
-    'formdata',
-];
-describe('CORE_PRESETS', () => {
-    beforeEach(() => {
-        mockBuildHookCode.mockClear();
-    });
-    it('exports a Record<string, PresetEntry>', () => {
-        expect(CORE_PRESETS).toBeDefined();
-        expect(typeof CORE_PRESETS).toBe('object');
-        expect(CORE_PRESETS).not.toBeNull();
-    });
-    it('contains all expected preset IDs', () => {
-        const ids = Object.keys(CORE_PRESETS);
-        for (const expectedId of EXPECTED_CORE_IDS) {
-            expect(ids).toContain(expectedId);
-        }
-    });
-    it('does not contain unexpected extra entries beyond the known set', () => {
-        const ids = Object.keys(CORE_PRESETS);
-        for (const id of ids) {
-            expect(EXPECTED_CORE_IDS).toContain(id);
-        }
-    });
-    it('has unique preset IDs (no duplicates in object keys)', () => {
-        const ids = Object.keys(CORE_PRESETS);
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(ids.length);
-    });
-    describe('entry structure', () => {
-        it.each(EXPECTED_CORE_IDS)('"%s" has a description string', (id) => {
-            const entry = CORE_PRESETS[id];
-            expect(entry).toBeDefined();
-            expect(typeof entry.description).toBe('string');
-            expect(entry.description.length).toBeGreaterThan(0);
-        });
-        it.each(EXPECTED_CORE_IDS)('"%s" has a buildCode function', (id) => {
-            const entry = CORE_PRESETS[id];
-            expect(entry).toBeDefined();
-            expect(typeof entry.buildCode).toBe('function');
-        });
-    });
-    describe('buildCode delegation to buildHookCode', () => {
-        it('eval preset calls buildHookCode with name "eval"', () => {
-            const result = CORE_PRESETS['eval'].buildCode(true, false);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('eval', expect.any(String), true, false);
-            expect(result).toBe('[mock:eval:cs=true:lc=false]');
-        });
-        it('function-constructor preset calls buildHookCode correctly', () => {
-            const result = CORE_PRESETS['function-constructor'].buildCode(false, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('function-constructor', expect.any(String), false, true);
-            expect(result).toBe('[mock:function-constructor:cs=false:lc=true]');
-        });
-        it('atob-btoa preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['atob-btoa'].buildCode(true, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('atob-btoa', expect.any(String), true, true);
-        });
-        it('crypto-subtle preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['crypto-subtle'].buildCode(false, false);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('crypto-subtle', expect.any(String), false, false);
-        });
-        it('settimeout preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['settimeout'].buildCode(true, false);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('settimeout', expect.any(String), true, false);
-        });
-        it('addeventlistener preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['addeventlistener'].buildCode(false, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('addeventlistener', expect.any(String), false, true);
-        });
-        it('postmessage preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['postmessage'].buildCode(true, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('postmessage', expect.any(String), true, true);
-        });
-        it('history-pushstate preset calls buildHookCode correctly', () => {
-            CORE_PRESETS['history-pushstate'].buildCode(false, false);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('history-pushstate', expect.any(String), false, false);
-        });
-    });
-    describe('buildCode passes captureStack and logToConsole faithfully', () => {
-        it.each([
-            [true, true],
-            [true, false],
-            [false, true],
-            [false, false],
-        ])('eval preset with captureStack=%s, logToConsole=%s', (cs, lc) => {
-            mockBuildHookCode.mockClear();
-            CORE_PRESETS['eval'].buildCode(cs, lc);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('eval', expect.any(String), cs, lc);
-        });
-    });
-    describe('body templates contain expected placeholder tokens', () => {
-        it.each(EXPECTED_CORE_IDS)('"%s" body passed to buildHookCode contains STACK_CODE and LOG_FN placeholders', (id) => {
-            mockBuildHookCode.mockClear();
-            CORE_PRESETS[id].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain('{{STACK_CODE}}');
-            expect(bodyArg).toContain('{{LOG_FN}}');
-        });
-    });
-    describe('body templates reference the correct __aiHooks key', () => {
-        it.each(EXPECTED_CORE_IDS)('"%s" body contains its __aiHooks collection key', (id) => {
-            mockBuildHookCode.mockClear();
-            CORE_PRESETS[id].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain(`preset-${id}`);
-        });
-    });
-    describe('description content', () => {
-        it('eval description mentions eval()', () => {
-            expect(CORE_PRESETS['eval'].description).toContain('eval');
-        });
-        it('crypto-subtle description mentions WebCrypto', () => {
-            expect(CORE_PRESETS['crypto-subtle'].description).toContain('WebCrypto');
-        });
-        it('webassembly description mentions WASM', () => {
-            expect(CORE_PRESETS['webassembly'].description).toContain('WASM');
-        });
-        it('addeventlistener description mentions event listener', () => {
-            expect(CORE_PRESETS['addeventlistener'].description).toContain('event listener');
-        });
-        it('postmessage description mentions postMessage', () => {
-            expect(CORE_PRESETS['postmessage'].description).toContain('postMessage');
-        });
-    });
-});

package/dist/tests/server/domains/hooks/preset-definitions.security.test.d.ts

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

package/dist/tests/server/domains/hooks/preset-definitions.security.test.js

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockBuildHookCode = vi.hoisted(() => vi.fn((name, _body, cs, lc) => `[mock:${name}:cs=${cs}:lc=${lc}]`));
-vi.mock('@server/domains/hooks/preset-builder', () => ({
-    buildHookCode: mockBuildHookCode,
-}));
-import { SECURITY_PRESETS } from '../../../../src/server/domains/hooks/preset-definitions.security.js';
-const EXPECTED_SECURITY_IDS = [
-    'anti-debug-bypass',
-    'crypto-key-capture',
-    'webassembly-full',
-];
-describe('SECURITY_PRESETS', () => {
-    beforeEach(() => {
-        mockBuildHookCode.mockClear();
-    });
-    it('exports a Record<string, PresetEntry>', () => {
-        expect(SECURITY_PRESETS).toBeDefined();
-        expect(typeof SECURITY_PRESETS).toBe('object');
-        expect(SECURITY_PRESETS).not.toBeNull();
-    });
-    it('contains all expected preset IDs', () => {
-        const ids = Object.keys(SECURITY_PRESETS);
-        for (const expectedId of EXPECTED_SECURITY_IDS) {
-            expect(ids).toContain(expectedId);
-        }
-    });
-    it('does not contain unexpected extra entries beyond the known set', () => {
-        const ids = Object.keys(SECURITY_PRESETS);
-        for (const id of ids) {
-            expect(EXPECTED_SECURITY_IDS).toContain(id);
-        }
-    });
-    it('has unique preset IDs (no duplicates in object keys)', () => {
-        const ids = Object.keys(SECURITY_PRESETS);
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(ids.length);
-    });
-    describe('entry structure', () => {
-        it.each(EXPECTED_SECURITY_IDS)('"%s" has a description string', (id) => {
-            const entry = SECURITY_PRESETS[id];
-            expect(entry).toBeDefined();
-            expect(typeof entry.description).toBe('string');
-            expect(entry.description.length).toBeGreaterThan(0);
-        });
-        it.each(EXPECTED_SECURITY_IDS)('"%s" has a buildCode function', (id) => {
-            const entry = SECURITY_PRESETS[id];
-            expect(entry).toBeDefined();
-            expect(typeof entry.buildCode).toBe('function');
-        });
-    });
-    describe('buildCode delegation to buildHookCode', () => {
-        it('anti-debug-bypass preset calls buildHookCode with correct name', () => {
-            const result = SECURITY_PRESETS['anti-debug-bypass'].buildCode(true, false);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('anti-debug-bypass', expect.any(String), true, false);
-            expect(result).toBe('[mock:anti-debug-bypass:cs=true:lc=false]');
-        });
-        it('crypto-key-capture preset calls buildHookCode with correct name', () => {
-            const result = SECURITY_PRESETS['crypto-key-capture'].buildCode(false, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('crypto-key-capture', expect.any(String), false, true);
-            expect(result).toBe('[mock:crypto-key-capture:cs=false:lc=true]');
-        });
-        it('webassembly-full preset calls buildHookCode with correct name', () => {
-            const result = SECURITY_PRESETS['webassembly-full'].buildCode(true, true);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('webassembly-full', expect.any(String), true, true);
-            expect(result).toBe('[mock:webassembly-full:cs=true:lc=true]');
-        });
-    });
-    describe('buildCode passes captureStack and logToConsole faithfully', () => {
-        it.each([
-            [true, true],
-            [true, false],
-            [false, true],
-            [false, false],
-        ])('anti-debug-bypass preset with captureStack=%s, logToConsole=%s', (cs, lc) => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS['anti-debug-bypass'].buildCode(cs, lc);
-            expect(mockBuildHookCode).toHaveBeenCalledWith('anti-debug-bypass', expect.any(String), cs, lc);
-        });
-    });
-    describe('body templates contain expected placeholder tokens', () => {
-        const PRESETS_WITH_PLACEHOLDERS = ['crypto-key-capture', 'webassembly-full'];
-        it.each(PRESETS_WITH_PLACEHOLDERS)('"%s" body passed to buildHookCode contains STACK_CODE and LOG_FN placeholders', (id) => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS[id].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain('{{STACK_CODE}}');
-            expect(bodyArg).toContain('{{LOG_FN}}');
-        });
-        it('anti-debug-bypass body does not use standard placeholders', () => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS['anti-debug-bypass'].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).not.toContain('{{STACK_CODE}}');
-            expect(bodyArg).not.toContain('{{LOG_FN}}');
-        });
-    });
-    describe('body templates reference the correct __aiHooks key', () => {
-        it.each(EXPECTED_SECURITY_IDS)('"%s" body contains its __aiHooks collection key', (id) => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS[id].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain(`preset-${id}`);
-        });
-    });
-    describe('description content', () => {
-        it('anti-debug-bypass description mentions anti-debugging', () => {
-            expect(SECURITY_PRESETS['anti-debug-bypass'].description).toContain('anti-debug');
-        });
-        it('anti-debug-bypass description mentions debugger traps', () => {
-            expect(SECURITY_PRESETS['anti-debug-bypass'].description).toContain('debugger');
-        });
-        it('crypto-key-capture description mentions extractable', () => {
-            expect(SECURITY_PRESETS['crypto-key-capture'].description).toContain('extractable');
-        });
-        it('crypto-key-capture description mentions WebCrypto', () => {
-            expect(SECURITY_PRESETS['crypto-key-capture'].description).toContain('WebCrypto');
-        });
-        it('webassembly-full description mentions WebAssembly', () => {
-            expect(SECURITY_PRESETS['webassembly-full'].description).toContain('WebAssembly');
-        });
-        it('webassembly-full description mentions import calls', () => {
-            expect(SECURITY_PRESETS['webassembly-full'].description).toContain('import calls');
-        });
-    });
-    describe('security preset body content characteristics', () => {
-        it('anti-debug-bypass body contains debugger detection logic', () => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS['anti-debug-bypass'].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain('debugger');
-            expect(bodyArg).toContain('console.clear');
-            expect(bodyArg).toContain('performance.now');
-            expect(bodyArg).toContain('outerWidth');
-        });
-        it('crypto-key-capture body forces extractable:true', () => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS['crypto-key-capture'].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain('importKey');
-            expect(bodyArg).toContain('true');
-        });
-        it('webassembly-full body hooks WebAssembly.Memory', () => {
-            mockBuildHookCode.mockClear();
-            SECURITY_PRESETS['webassembly-full'].buildCode(false, false);
-            const bodyArg = mockBuildHookCode.mock.calls[0][1];
-            expect(bodyArg).toContain('WebAssembly.Memory');
-            expect(bodyArg).toContain('memory_created');
-        });
-    });
-});

package/dist/tests/server/domains/hooks/preset-definitions.test.d.ts

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

package/dist/tests/server/domains/hooks/preset-definitions.test.js

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockBuildHookCode = vi.hoisted(() => vi.fn((name, _body, cs, lc) => `[mock:${name}:cs=${cs}:lc=${lc}]`));
-vi.mock('@server/domains/hooks/preset-builder', () => ({
-    buildHookCode: mockBuildHookCode,
-}));
-import { PRESETS, PRESET_LIST } from '../../../../src/server/domains/hooks/preset-definitions.js';
-import { CORE_PRESETS } from '../../../../src/server/domains/hooks/preset-definitions.core.js';
-import { SECURITY_PRESETS } from '../../../../src/server/domains/hooks/preset-definitions.security.js';
-describe('PRESETS (combined)', () => {
-    beforeEach(() => {
-        mockBuildHookCode.mockClear();
-    });
-    it('exports a Record<string, PresetEntry>', () => {
-        expect(PRESETS).toBeDefined();
-        expect(typeof PRESETS).toBe('object');
-        expect(PRESETS).not.toBeNull();
-    });
-    it('contains all core preset IDs', () => {
-        const presetIds = Object.keys(PRESETS);
-        for (const coreId of Object.keys(CORE_PRESETS)) {
-            expect(presetIds).toContain(coreId);
-        }
-    });
-    it('contains all security preset IDs', () => {
-        const presetIds = Object.keys(PRESETS);
-        for (const securityId of Object.keys(SECURITY_PRESETS)) {
-            expect(presetIds).toContain(securityId);
-        }
-    });
-    it('has a size equal to the sum of core and security presets', () => {
-        const coreCount = Object.keys(CORE_PRESETS).length;
-        const securityCount = Object.keys(SECURITY_PRESETS).length;
-        const totalCount = Object.keys(PRESETS).length;
-        expect(totalCount).toBe(coreCount + securityCount);
-    });
-    it('has no duplicate IDs across core and security presets', () => {
-        const coreIds = Object.keys(CORE_PRESETS);
-        const securityIds = Object.keys(SECURITY_PRESETS);
-        const overlap = coreIds.filter((id) => securityIds.includes(id));
-        expect(overlap).toEqual([]);
-    });
-    it('entries from PRESETS match their source (core)', () => {
-        for (const [id, entry] of Object.entries(CORE_PRESETS)) {
-            expect(PRESETS[id]).toBe(entry);
-        }
-    });
-    it('entries from PRESETS match their source (security)', () => {
-        for (const [id, entry] of Object.entries(SECURITY_PRESETS)) {
-            expect(PRESETS[id]).toBe(entry);
-        }
-    });
-    it('every entry has a description and buildCode function', () => {
-        for (const entry of Object.values(PRESETS)) {
-            expect(typeof entry.description).toBe('string');
-            expect(entry.description.length).toBeGreaterThan(0);
-            expect(typeof entry.buildCode).toBe('function');
-        }
-    });
-});
-describe('PRESET_LIST', () => {
-    it('is an array', () => {
-        expect(Array.isArray(PRESET_LIST)).toBe(true);
-    });
-    it('has the same length as PRESETS', () => {
-        expect(PRESET_LIST.length).toBe(Object.keys(PRESETS).length);
-    });
-    it('each element has only id and description fields', () => {
-        for (const item of PRESET_LIST) {
-            expect(item).toHaveProperty('id');
-            expect(item).toHaveProperty('description');
-            expect(typeof item.id).toBe('string');
-            expect(typeof item.description).toBe('string');
-            const keys = Object.keys(item);
-            expect(keys).toEqual(expect.arrayContaining(['id', 'description']));
-            expect(keys.length).toBe(2);
-        }
-    });
-    it('does not include buildCode in list items', () => {
-        for (const item of PRESET_LIST) {
-            expect(item).not.toHaveProperty('buildCode');
-        }
-    });
-    it('contains IDs for all PRESETS entries', () => {
-        const listIds = PRESET_LIST.map((p) => p.id);
-        for (const presetId of Object.keys(PRESETS)) {
-            expect(listIds).toContain(presetId);
-        }
-    });
-    it('has no duplicate IDs', () => {
-        const ids = PRESET_LIST.map((p) => p.id);
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(ids.length);
-    });
-    it('descriptions in PRESET_LIST match descriptions in PRESETS', () => {
-        for (const item of PRESET_LIST) {
-            const presetEntry = PRESETS[item.id];
-            expect(presetEntry).toBeDefined();
-            expect(item.description).toBe(presetEntry.description);
-        }
-    });
-    it('contains specific known entries', () => {
-        const ids = PRESET_LIST.map((p) => p.id);
-        expect(ids).toContain('eval');
-        expect(ids).toContain('anti-debug-bypass');
-        expect(ids).toContain('crypto-key-capture');
-        expect(ids).toContain('webassembly-full');
-    });
-});

package/dist/tests/server/domains/hooks/preset-handlers.test.d.ts

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

package/dist/tests/server/domains/hooks/preset-handlers.test.js

@@ -1,66 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { HookPresetToolHandlers } from '../../../../src/server/domains/hooks/preset-handlers.js';
-function parseJson(response) {
-    return JSON.parse(response.content[0].text);
-}
-describe('HookPresetToolHandlers', () => {
-    const page = {
-        evaluateOnNewDocument: vi.fn(),
-        evaluate: vi.fn(),
-    };
-    const pageController = {
-        getPage: vi.fn(async () => page),
-    };
-    let handlers;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        handlers = new HookPresetToolHandlers(pageController);
-    });
-    it('lists built-in and inline custom presets together', async () => {
-        const body = parseJson(await handlers.handleHookPreset({
-            listPresets: true,
-            customTemplate: {
-                id: 'deobfuscation-sinks',
-                description: 'Trace deobfuscation sinks',
-                body: 'window.__aiHooks[\'preset-deobfuscation-sinks\'].push({ ts: Date.now() });',
-            },
-        }));
-        expect(body.success).toBe(true);
-        expect(body.presets.some((preset) => preset.id === 'eval')).toBe(true);
-        expect(body.presets.some((preset) => preset.id === 'deobfuscation-sinks')).toBe(true);
-    });
-    it('injects an inline custom template through evaluate', async () => {
-        const body = parseJson(await handlers.handleHookPreset({
-            preset: 'zero-trust-fetch',
-            customTemplate: {
-                id: 'zero-trust-fetch',
-                description: 'Trace custom fetch headers',
-                body: `
-  const _fetch = window.fetch.bind(window);
-  window.fetch = function(input, init) {
-    {{STACK_CODE}}
-    const __msg = '[Hook:zero-trust-fetch]';
-    {{LOG_FN}}
-    window.__aiHooks['preset-zero-trust-fetch'].push({ input: String(input), headers: JSON.stringify(init?.headers || {}), stack: __stack, ts: Date.now() });
-    return _fetch(input, init);
-  };`,
-            },
-            method: 'evaluate',
-        }));
-        expect(body.success).toBe(true);
-        expect(body.injected).toEqual(['zero-trust-fetch']);
-        expect(page.evaluate).toHaveBeenCalledOnce();
-        expect(page.evaluate.mock.calls[0][0]).toContain('preset-zero-trust-fetch');
-    });
-    it('rejects custom template ids that collide with built-in presets', async () => {
-        const body = parseJson(await handlers.handleHookPreset({
-            preset: 'eval',
-            customTemplate: {
-                id: 'eval',
-                body: 'console.log(1);',
-            },
-        }));
-        expect(body.success).toBe(false);
-        expect(body.error).toContain('conflicts with built-in preset');
-    });
-});

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

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

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

@@ -1,29 +0,0 @@
-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/maintenance exports', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-    });
-    it('exposes maintenance tool definitions and a matching manifest', async () => {
-        expect.hasAssertions();
-        await assertDomainExportContract({
-            expectedDomain: 'maintenance',
-            definitionExportNames: [
-                'artifactTools',
-                'cacheTools',
-                'extensionTools',
-                'tokenBudgetTools',
-            ],
-            loadDefinitions: () => import('../../../../src/server/domains/maintenance/definitions.js'),
-            getToolArrays: (module) => [
-                module.tokenBudgetTools,
-                module.cacheTools,
-                module.artifactTools,
-                module.extensionTools,
-            ],
-            loadManifest: () => import('../../../../src/server/domains/maintenance/manifest.js'),
-        });
-    });
-});

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

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