@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,109 @@
+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

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

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

@@ -0,0 +1,150 @@
+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

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

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

@@ -0,0 +1,150 @@
+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

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

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

@@ -0,0 +1,108 @@
+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/maintenance/exports.test.d.ts

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

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

@@ -0,0 +1,29 @@
+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.js

@@ -76,4 +76,75 @@ describe('CoreMaintenanceHandlers', () => {
         expect(body.success).toBe(true);
         expect(body.recommendations).toEqual(['ok']);
     });
+    it('returns error when manual cleanup fails', async () => {
+        tokenBudget.getStats.mockImplementation(() => {
+            throw new Error('cleanup-crash');
+        });
+        const body = parseJson(await handlers.handleManualTokenCleanup());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('cleanup-crash');
+    });
+    it('returns error when reset fails', async () => {
+        tokenBudget.reset.mockImplementation(() => {
+            throw new Error('reset-fail');
+        });
+        const body = parseJson(await handlers.handleResetTokenBudget());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('reset-fail');
+    });
+    it('resetTokenBudget returns zeroed state on success', async () => {
+        const body = parseJson(await handlers.handleResetTokenBudget());
+        expect(body.success).toBe(true);
+        expect(body.currentUsage).toBe(0);
+        expect(body.maxTokens).toBe(200000);
+        expect(body.usagePercentage).toBe(0);
+        expect(tokenBudget.reset).toHaveBeenCalledOnce();
+    });
+    it('returns error when cache stats fail', async () => {
+        unifiedCache.getGlobalStats.mockRejectedValue(new Error('stats-err'));
+        const body = parseJson(await handlers.handleGetCacheStats());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('stats-err');
+    });
+    it('smart cache cleanup forwards targetSize', async () => {
+        unifiedCache.smartCleanup.mockResolvedValue({ freed: 1024 });
+        const body = parseJson(await handlers.handleSmartCacheCleanup(5000));
+        expect(unifiedCache.smartCleanup).toHaveBeenCalledWith(5000);
+        expect(body.success).toBe(true);
+        expect(body.freed).toBe(1024);
+    });
+    it('returns error when smart cache cleanup fails', async () => {
+        unifiedCache.smartCleanup.mockRejectedValue(new Error('smart-fail'));
+        const body = parseJson(await handlers.handleSmartCacheCleanup());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('smart-fail');
+    });
+    it('clearAllCaches returns success', async () => {
+        unifiedCache.clearAll.mockResolvedValue(undefined);
+        const body = parseJson(await handlers.handleClearAllCaches());
+        expect(body.success).toBe(true);
+        expect(body.message).toBe('All caches cleared');
+    });
+    it('returns error when artifact cleanup fails', async () => {
+        artifactCleanup.mockRejectedValue(new Error('artifact-err'));
+        const body = parseJson(await handlers.handleCleanupArtifacts({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('artifact-err');
+    });
+    it('returns error when environment doctor fails', async () => {
+        environmentDoctor.mockRejectedValue(new Error('doctor-err'));
+        const body = parseJson(await handlers.handleEnvironmentDoctor({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('doctor-err');
+    });
+    it('artifact cleanup passes all args', async () => {
+        artifactCleanup.mockResolvedValue({ success: true });
+        await handlers.handleCleanupArtifacts({ retentionDays: 3, maxTotalBytes: 1000, dryRun: false });
+        expect(artifactCleanup).toHaveBeenCalledWith({ retentionDays: 3, maxTotalBytes: 1000, dryRun: false });
+    });
+    it('environment doctor with bridge health enabled', async () => {
+        environmentDoctor.mockResolvedValue({ success: true });
+        await handlers.handleEnvironmentDoctor({ includeBridgeHealth: true });
+        expect(environmentDoctor).toHaveBeenCalledWith({ includeBridgeHealth: true });
+    });
 });