@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/native/NativeMemoryManager.utils.extended.test.js

@@ -0,0 +1,229 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const state = vi.hoisted(() => ({
+    PAGE: {
+        NOACCESS: 0x01,
+        READONLY: 0x02,
+        READWRITE: 0x04,
+        WRITECOPY: 0x08,
+        EXECUTE: 0x10,
+        EXECUTE_READ: 0x20,
+        EXECUTE_READWRITE: 0x40,
+        GUARD: 0x100,
+    },
+    MEM: {
+        COMMIT: 0x1000,
+        RESERVE: 0x2000,
+        FREE: 0x10000,
+    },
+    MEM_TYPE: {
+        IMAGE: 0x1000000,
+        MAPPED: 0x40000,
+        PRIVATE: 0x20000,
+    },
+    isWin32KoffiAvailable: vi.fn(),
+}));
+vi.mock('@native/Win32API', () => ({
+    PAGE: state.PAGE,
+    MEM: state.MEM,
+    MEM_TYPE: state.MEM_TYPE,
+    isKoffiAvailable: state.isWin32KoffiAvailable,
+}));
+import { findPatternInBuffer, getProtectionString, getStateString, getTypeString, isExecutable, isReadable, isWritable, parsePattern, } from '../../src/native/NativeMemoryManager.utils.js';
+describe('NativeMemoryManager.utils edge cases', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('parsePattern extended', () => {
+        it('parses hex pattern with ** wildcard', () => {
+            expect(parsePattern('AA ** CC', 'hex')).toEqual({
+                patternBytes: [0xaa, 0, 0xcc],
+                mask: [1, 0, 1],
+            });
+        });
+        it('returns empty for invalid hex digits', () => {
+            const result = parsePattern('ZZ', 'hex');
+            expect(result.patternBytes).toEqual([]);
+            expect(result.mask).toEqual([]);
+        });
+        it('returns empty for NaN int32', () => {
+            const result = parsePattern('notanumber', 'int32');
+            expect(result.patternBytes).toEqual([]);
+        });
+        it('parses int64 pattern', () => {
+            const result = parsePattern('0', 'int64');
+            expect(result.patternBytes).toEqual([0, 0, 0, 0, 0, 0, 0, 0]);
+            expect(result.mask).toEqual([1, 1, 1, 1, 1, 1, 1, 1]);
+        });
+        it('parses float pattern', () => {
+            const result = parsePattern('0', 'float');
+            expect(result.patternBytes).toEqual([0, 0, 0, 0]);
+        });
+        it('returns empty for NaN float', () => {
+            const result = parsePattern('notanumber', 'float');
+            expect(result.patternBytes).toEqual([]);
+        });
+        it('parses double pattern', () => {
+            const result = parsePattern('0', 'double');
+            expect(result.patternBytes).toEqual([0, 0, 0, 0, 0, 0, 0, 0]);
+        });
+        it('returns empty for NaN double', () => {
+            const result = parsePattern('notanumber', 'double');
+            expect(result.patternBytes).toEqual([]);
+        });
+        it('parses multi-byte UTF-8 string', () => {
+            const result = parsePattern('AB', 'string');
+            expect(result.patternBytes).toEqual([0x41, 0x42]);
+            expect(result.mask).toEqual([1, 1]);
+        });
+    });
+    describe('findPatternInBuffer edge cases', () => {
+        it('returns empty for empty pattern', () => {
+            expect(findPatternInBuffer(Buffer.from([0xaa]), [], [])).toEqual([]);
+        });
+        it('returns empty when buffer is shorter than pattern', () => {
+            expect(findPatternInBuffer(Buffer.from([0xaa]), [0xaa, 0xbb], [1, 1])).toEqual([]);
+        });
+        it('finds overlapping exact matches', () => {
+            expect(findPatternInBuffer(Buffer.from([0xaa, 0xaa, 0xaa, 0xaa]), [0xaa, 0xaa], [1, 1])).toEqual([0, 1, 2]);
+        });
+        it('handles single-byte pattern', () => {
+            expect(findPatternInBuffer(Buffer.from([0x00, 0xff, 0x00]), [0xff], [1])).toEqual([1]);
+        });
+        it('returns all positions for all-wildcard mask', () => {
+            const result = findPatternInBuffer(Buffer.from([0xaa, 0xbb, 0xcc]), [0, 0], [0, 0]);
+            expect(result).toEqual([0, 1]);
+        });
+        it('handles exact pattern using BMH path (all mask=1)', () => {
+            const buf = Buffer.from([0x01, 0x02, 0x03, 0x01, 0x02]);
+            expect(findPatternInBuffer(buf, [0x01, 0x02], [1, 1])).toEqual([0, 3]);
+        });
+    });
+    describe('getStateString', () => {
+        it('returns RESERVE', () => {
+            expect(getStateString(state.MEM.RESERVE)).toBe('RESERVE');
+        });
+        it('returns FREE', () => {
+            expect(getStateString(state.MEM.FREE)).toBe('FREE');
+        });
+        it('returns UNKNOWN for unrecognized state', () => {
+            expect(getStateString(0xDEAD)).toBe('UNKNOWN');
+        });
+    });
+    describe('getProtectionString', () => {
+        it('returns NOACCESS for zero protection', () => {
+            expect(getProtectionString(0)).toBe('NOACCESS');
+        });
+        it('returns NOACCESS flag', () => {
+            expect(getProtectionString(state.PAGE.NOACCESS)).toBe('NOACCESS');
+        });
+        it('returns combined protection flags', () => {
+            expect(getProtectionString(state.PAGE.READWRITE | state.PAGE.EXECUTE)).toBe('RW X');
+        });
+        it('returns UNKNOWN for unrecognized non-zero protection', () => {
+            expect(getProtectionString(0x8000)).toBe('UNKNOWN');
+        });
+        it('returns R for readonly', () => {
+            expect(getProtectionString(state.PAGE.READONLY)).toBe('R');
+        });
+        it('returns WC for writecopy', () => {
+            expect(getProtectionString(state.PAGE.WRITECOPY)).toBe('WC');
+        });
+        it('returns RWX for execute_readwrite', () => {
+            expect(getProtectionString(state.PAGE.EXECUTE_READWRITE)).toBe('RWX');
+        });
+        it('returns RX for execute_read', () => {
+            expect(getProtectionString(state.PAGE.EXECUTE_READ)).toBe('RX');
+        });
+    });
+    describe('getTypeString', () => {
+        it('returns IMAGE', () => {
+            expect(getTypeString(state.MEM_TYPE.IMAGE)).toBe('IMAGE');
+        });
+        it('returns MAPPED', () => {
+            expect(getTypeString(state.MEM_TYPE.MAPPED)).toBe('MAPPED');
+        });
+        it('returns UNKNOWN for unrecognized type', () => {
+            expect(getTypeString(0xDEAD)).toBe('UNKNOWN');
+        });
+    });
+    describe('isReadable', () => {
+        it('returns false when state is not COMMIT', () => {
+            expect(isReadable({
+                BaseAddress: 0n,
+                AllocationBase: 0n,
+                AllocationProtect: 0,
+                RegionSize: 0n,
+                State: state.MEM.FREE,
+                Protect: state.PAGE.READWRITE,
+                Type: 0,
+            })).toBe(false);
+        });
+        it('returns true for WRITECOPY protection', () => {
+            expect(isReadable({
+                BaseAddress: 0n,
+                AllocationBase: 0n,
+                AllocationProtect: 0,
+                RegionSize: 0n,
+                State: state.MEM.COMMIT,
+                Protect: state.PAGE.WRITECOPY,
+                Type: 0,
+            })).toBe(true);
+        });
+        it('returns true for EXECUTE_READWRITE', () => {
+            expect(isReadable({
+                BaseAddress: 0n,
+                AllocationBase: 0n,
+                AllocationProtect: 0,
+                RegionSize: 0n,
+                State: state.MEM.COMMIT,
+                Protect: state.PAGE.EXECUTE_READWRITE,
+                Type: 0,
+            })).toBe(true);
+        });
+        it('returns false for NOACCESS with COMMIT state', () => {
+            expect(isReadable({
+                BaseAddress: 0n,
+                AllocationBase: 0n,
+                AllocationProtect: 0,
+                RegionSize: 0n,
+                State: state.MEM.COMMIT,
+                Protect: state.PAGE.NOACCESS,
+                Type: 0,
+            })).toBe(false);
+        });
+    });
+    describe('isWritable', () => {
+        it('returns true for READWRITE', () => {
+            expect(isWritable(state.PAGE.READWRITE)).toBe(true);
+        });
+        it('returns true for WRITECOPY', () => {
+            expect(isWritable(state.PAGE.WRITECOPY)).toBe(true);
+        });
+        it('returns true for EXECUTE_READWRITE', () => {
+            expect(isWritable(state.PAGE.EXECUTE_READWRITE)).toBe(true);
+        });
+        it('returns false for READONLY', () => {
+            expect(isWritable(state.PAGE.READONLY)).toBe(false);
+        });
+        it('returns false for EXECUTE_READ', () => {
+            expect(isWritable(state.PAGE.EXECUTE_READ)).toBe(false);
+        });
+    });
+    describe('isExecutable', () => {
+        it('returns true for EXECUTE', () => {
+            expect(isExecutable(state.PAGE.EXECUTE)).toBe(true);
+        });
+        it('returns true for EXECUTE_READ', () => {
+            expect(isExecutable(state.PAGE.EXECUTE_READ)).toBe(true);
+        });
+        it('returns true for EXECUTE_READWRITE', () => {
+            expect(isExecutable(state.PAGE.EXECUTE_READWRITE)).toBe(true);
+        });
+        it('returns false for READONLY', () => {
+            expect(isExecutable(state.PAGE.READONLY)).toBe(false);
+        });
+        it('returns false for READWRITE', () => {
+            expect(isExecutable(state.PAGE.READWRITE)).toBe(false);
+        });
+    });
+});

package/dist/tests/native/NativeMemoryManager.utils.test.d.ts

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

package/dist/tests/native/NativeMemoryManager.utils.test.js

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const state = vi.hoisted(() => ({
+    PAGE: {
+        NOACCESS: 0x01,
+        READONLY: 0x02,
+        READWRITE: 0x04,
+        WRITECOPY: 0x08,
+        EXECUTE: 0x10,
+        EXECUTE_READ: 0x20,
+        EXECUTE_READWRITE: 0x40,
+        GUARD: 0x100,
+    },
+    MEM: {
+        COMMIT: 0x1000,
+        RESERVE: 0x2000,
+        FREE: 0x10000,
+    },
+    MEM_TYPE: {
+        IMAGE: 0x1000000,
+        MAPPED: 0x40000,
+        PRIVATE: 0x20000,
+    },
+    isWin32KoffiAvailable: vi.fn(),
+}));
+vi.mock('@native/Win32API', () => ({
+    PAGE: state.PAGE,
+    MEM: state.MEM,
+    MEM_TYPE: state.MEM_TYPE,
+    isKoffiAvailable: state.isWin32KoffiAvailable,
+}));
+import { findPatternInBuffer, getProtectionString, getStateString, getTypeString, isExecutable, isKoffiAvailable, isReadable, isWritable, parsePattern, } from '../../src/native/NativeMemoryManager.utils.js';
+describe('NativeMemoryManager.utils', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('parses hex patterns with wildcard bytes', () => {
+        expect(parsePattern('AA ?? ? CC', 'hex')).toEqual({
+            patternBytes: [0xaa, 0x00, 0x00, 0xcc],
+            mask: [1, 0, 0, 1],
+        });
+    });
+    it('parses scalar and string patterns into byte arrays', () => {
+        expect(parsePattern('258', 'int32')).toEqual({
+            patternBytes: [2, 1, 0, 0],
+            mask: [1, 1, 1, 1],
+        });
+        expect(parsePattern('AB', 'string')).toEqual({
+            patternBytes: [65, 66],
+            mask: [1, 1],
+        });
+    });
+    it('finds exact and wildcard matches in buffers', () => {
+        expect(findPatternInBuffer(Buffer.from([0xaa, 0xbb, 0xaa, 0xbb]), [0xaa, 0xbb], [1, 1])).toEqual([
+            0,
+            2,
+        ]);
+        expect(findPatternInBuffer(Buffer.from([0xaa, 0xff, 0xcc]), [0xaa, 0x00, 0xcc], [1, 0, 1])).toEqual([
+            0,
+        ]);
+    });
+    it('maps region metadata and protection flags', () => {
+        const info = {
+            BaseAddress: 0x1000n,
+            AllocationBase: 0x1000n,
+            AllocationProtect: state.PAGE.READWRITE,
+            RegionSize: 0x200n,
+            State: state.MEM.COMMIT,
+            Protect: state.PAGE.READWRITE | state.PAGE.GUARD,
+            Type: state.MEM_TYPE.PRIVATE,
+        };
+        expect(getStateString(info.State)).toBe('COMMIT');
+        expect(getProtectionString(info.Protect)).toBe('RW GUARD');
+        expect(getTypeString(info.Type)).toBe('PRIVATE');
+        expect(isReadable(info)).toBe(true);
+        expect(isWritable(info.Protect)).toBe(true);
+        expect(isExecutable(info.Protect)).toBe(false);
+    });
+    it('delegates koffi availability checks to the Win32 bridge module', () => {
+        state.isWin32KoffiAvailable.mockReturnValue(true);
+        expect(isKoffiAvailable()).toBe(true);
+        expect(state.isWin32KoffiAvailable).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/native/ScriptLoader.test.d.ts

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

package/dist/tests/native/ScriptLoader.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join, resolve } from 'node:path';
+const state = vi.hoisted(() => ({
+    existsSync: vi.fn(),
+    readFile: vi.fn(),
+    platform: vi.fn(),
+}));
+vi.mock('fs', () => ({
+    promises: {
+        readFile: state.readFile,
+    },
+    existsSync: state.existsSync,
+}));
+vi.mock('os', () => ({
+    platform: state.platform,
+}));
+describe('ScriptLoader', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        state.platform.mockReturnValue('win32');
+        state.readFile.mockResolvedValue('Write-Host "ok"');
+        state.existsSync.mockImplementation((path) => path.endsWith(join('dist', 'native', 'scripts')));
+    });
+    it('prefers dist/native scripts when they exist', async () => {
+        const { ScriptLoader } = await import('../../src/native/ScriptLoader.js');
+        const loader = new ScriptLoader();
+        expect(loader.getScriptPath('read-memory.ps1')).toBe(join(resolve(process.cwd(), 'dist', 'native'), 'scripts', 'windows', 'read-memory.ps1'));
+    });
+    it('falls back to src/native scripts when dist scripts are missing', async () => {
+        state.existsSync.mockImplementation((path) => path.endsWith(join('src', 'native', 'scripts')));
+        const { ScriptLoader } = await import('../../src/native/ScriptLoader.js');
+        const loader = new ScriptLoader();
+        expect(loader.getScriptPath('inject.ps1')).toBe(join(resolve(process.cwd(), 'src', 'native'), 'scripts', 'windows', 'inject.ps1'));
+    });
+    it('caches loaded scripts until the cache is cleared', async () => {
+        const { ScriptLoader } = await import('../../src/native/ScriptLoader.js');
+        const loader = new ScriptLoader();
+        await expect(loader.loadScript('scan.ps1')).resolves.toBe('Write-Host "ok"');
+        await expect(loader.loadScript('scan.ps1')).resolves.toBe('Write-Host "ok"');
+        expect(state.readFile).toHaveBeenCalledTimes(1);
+        loader.clearCache();
+        await loader.loadScript('scan.ps1');
+        expect(state.readFile).toHaveBeenCalledTimes(2);
+    });
+    it('uses the current OS platform when resolving script file paths', async () => {
+        state.platform.mockReturnValue('darwin');
+        const { ScriptLoader } = await import('../../src/native/ScriptLoader.js');
+        const loader = new ScriptLoader();
+        await loader.loadScript('probe.sh');
+        expect(state.readFile).toHaveBeenCalledWith(join(resolve(process.cwd(), 'dist', 'native'), 'scripts', 'macos', 'probe.sh'), 'utf-8');
+    });
+});

package/dist/tests/server/ExtensionManager.test.js

@@ -22,7 +22,7 @@ const { reloadExtensions } = await import('../../src/server/extensions/Extension
 function createMockCtx(overrides = {}) {
     return {
         config: { mcp: { version: '0.1.0' } },
-        currentTier: 'full',
+        baseTier: 'full',
         extensionToolsByName: new Map(),
         extensionPluginsById: new Map(),
         extensionPluginRuntimeById: new Map(),
@@ -31,7 +31,7 @@ function createMockCtx(overrides = {}) {
         lastExtensionReloadAt: undefined,
         activatedToolNames: new Set(),
         activatedRegisteredTools: new Map(),
-        boostedExtensionToolNames: new Set(),
+        domainTtlEntries: new Map(),
         handlerDeps: {},
         router: {
             addHandlers: vi.fn(),

package/dist/tests/server/MCPServer.activation.ttl.test.d.ts

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

package/dist/tests/server/MCPServer.activation.ttl.test.js

@@ -0,0 +1,248 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('@server/ToolCatalog', () => ({
+    getToolDomain: vi.fn((name) => {
+        const map = {
+            page_navigate: 'browser',
+            page_evaluate: 'browser',
+            page_click: 'browser',
+            debugger_pause: 'debugger',
+            debugger_resume: 'debugger',
+            network_get_requests: 'network',
+        };
+        return map[name] ?? null;
+    }),
+}));
+import { startDomainTtl, refreshDomainTtl, refreshDomainTtlForTool, clearDomainTtl, deactivateDomainOnExpiry, } from '../../src/server/MCPServer.activation.ttl.js';
+function createMockCtx(overrides = {}) {
+    return {
+        domainTtlEntries: new Map(),
+        activatedToolNames: new Set(),
+        activatedRegisteredTools: new Map(),
+        extensionToolsByName: new Map(),
+        enabledDomains: new Set(),
+        selectedTools: [],
+        router: { removeHandler: vi.fn() },
+        server: { sendToolListChanged: vi.fn(async () => { }) },
+        ...overrides,
+    };
+}
+describe('MCPServer.activation.ttl', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('startDomainTtl', () => {
+        it('creates a TTL entry with correct ttlMs and toolNames', () => {
+            const ctx = createMockCtx();
+            startDomainTtl(ctx, 'browser', 30, ['page_navigate', 'page_evaluate']);
+            expect(ctx.domainTtlEntries.has('browser')).toBe(true);
+            const entry = ctx.domainTtlEntries.get('browser');
+            expect(entry.ttlMs).toBe(30 * 60 * 1000);
+            expect(entry.toolNames).toEqual(new Set(['page_navigate', 'page_evaluate']));
+        });
+        it('does not create timer when ttlMinutes is 0', () => {
+            const ctx = createMockCtx();
+            startDomainTtl(ctx, 'browser', 0, ['page_navigate']);
+            expect(ctx.domainTtlEntries.has('browser')).toBe(false);
+        });
+        it('does not create timer when ttlMinutes is negative', () => {
+            const ctx = createMockCtx();
+            startDomainTtl(ctx, 'browser', -1, ['page_navigate']);
+            expect(ctx.domainTtlEntries.has('browser')).toBe(false);
+        });
+        it('replaces existing TTL entry for the same domain', () => {
+            const ctx = createMockCtx();
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            const firstEntry = ctx.domainTtlEntries.get('browser');
+            startDomainTtl(ctx, 'browser', 20, ['page_navigate', 'page_evaluate']);
+            const secondEntry = ctx.domainTtlEntries.get('browser');
+            expect(secondEntry.ttlMs).toBe(20 * 60 * 1000);
+            expect(secondEntry.toolNames.size).toBe(2);
+            expect(secondEntry.timer).not.toBe(firstEntry.timer);
+        });
+        it('triggers deactivation on expiry', async () => {
+            const removeFn = vi.fn();
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: removeFn });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 1, ['page_navigate']);
+            await vi.advanceTimersByTimeAsync(60 * 1000 + 100);
+            expect(removeFn).toHaveBeenCalledOnce();
+            expect(ctx.activatedToolNames.has('page_navigate')).toBe(false);
+            expect(ctx.server.sendToolListChanged).toHaveBeenCalled();
+        });
+    });
+    describe('refreshDomainTtl', () => {
+        it('resets the timer keeping the same duration', async () => {
+            const removeFn = vi.fn();
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: removeFn });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 1, ['page_navigate']);
+            await vi.advanceTimersByTimeAsync(50 * 1000);
+            expect(removeFn).not.toHaveBeenCalled();
+            refreshDomainTtl(ctx, 'browser');
+            await vi.advanceTimersByTimeAsync(50 * 1000);
+            expect(removeFn).not.toHaveBeenCalled();
+            await vi.advanceTimersByTimeAsync(11 * 1000);
+            expect(removeFn).toHaveBeenCalledOnce();
+        });
+        it('is a no-op for domains without TTL entries', () => {
+            const ctx = createMockCtx();
+            refreshDomainTtl(ctx, 'nonexistent');
+            expect(ctx.domainTtlEntries.size).toBe(0);
+        });
+    });
+    describe('refreshDomainTtlForTool', () => {
+        it('refreshes TTL when tool belongs to a domain with active TTL', async () => {
+            const removeFn = vi.fn();
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: removeFn });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 1, ['page_navigate']);
+            await vi.advanceTimersByTimeAsync(50 * 1000);
+            refreshDomainTtlForTool(ctx, 'page_navigate');
+            await vi.advanceTimersByTimeAsync(50 * 1000);
+            expect(removeFn).not.toHaveBeenCalled();
+            await vi.advanceTimersByTimeAsync(11 * 1000);
+            expect(removeFn).toHaveBeenCalledOnce();
+        });
+        it('refreshes TTL for extension tools', async () => {
+            const ctx = createMockCtx();
+            ctx.extensionToolsByName.set('custom_ext_tool', { domain: 'browser' });
+            startDomainTtl(ctx, 'browser', 5, ['custom_ext_tool']);
+            const entryBefore = ctx.domainTtlEntries.get('browser');
+            const timerBefore = entryBefore.timer;
+            refreshDomainTtlForTool(ctx, 'custom_ext_tool');
+            const entryAfter = ctx.domainTtlEntries.get('browser');
+            expect(entryAfter.timer).not.toBe(timerBefore);
+        });
+        it('is a no-op for tools without a known domain', () => {
+            const ctx = createMockCtx();
+            startDomainTtl(ctx, 'browser', 5, ['page_navigate']);
+            const timerBefore = ctx.domainTtlEntries.get('browser').timer;
+            refreshDomainTtlForTool(ctx, 'unknown_tool');
+            expect(ctx.domainTtlEntries.get('browser').timer).toBe(timerBefore);
+        });
+    });
+    describe('clearDomainTtl', () => {
+        it('clears timer and removes entry without deactivating tools', () => {
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            expect(ctx.domainTtlEntries.has('browser')).toBe(true);
+            clearDomainTtl(ctx, 'browser');
+            expect(ctx.domainTtlEntries.has('browser')).toBe(false);
+            expect(ctx.activatedToolNames.has('page_navigate')).toBe(true);
+        });
+        it('is a no-op for domains without TTL entries', () => {
+            const ctx = createMockCtx();
+            clearDomainTtl(ctx, 'nonexistent');
+            expect(ctx.domainTtlEntries.size).toBe(0);
+        });
+    });
+    describe('deactivateDomainOnExpiry', () => {
+        it('removes all domain tools from activated sets', async () => {
+            const removeFn1 = vi.fn();
+            const removeFn2 = vi.fn();
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedToolNames.add('page_evaluate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: removeFn1 });
+            ctx.activatedRegisteredTools.set('page_evaluate', { remove: removeFn2 });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate', 'page_evaluate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(removeFn1).toHaveBeenCalledOnce();
+            expect(removeFn2).toHaveBeenCalledOnce();
+            expect(ctx.activatedToolNames.has('page_navigate')).toBe(false);
+            expect(ctx.activatedToolNames.has('page_evaluate')).toBe(false);
+            expect(ctx.activatedRegisteredTools.has('page_navigate')).toBe(false);
+            expect(ctx.activatedRegisteredTools.has('page_evaluate')).toBe(false);
+            expect(ctx.router.removeHandler).toHaveBeenCalledWith('page_navigate');
+            expect(ctx.router.removeHandler).toHaveBeenCalledWith('page_evaluate');
+        });
+        it('sends toolListChanged notification after deactivation', async () => {
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: vi.fn() });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(ctx.server.sendToolListChanged).toHaveBeenCalledOnce();
+        });
+        it('skips already-deactivated tools', async () => {
+            const removeFn = vi.fn();
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_evaluate');
+            ctx.activatedRegisteredTools.set('page_evaluate', { remove: removeFn });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate', 'page_evaluate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(removeFn).toHaveBeenCalledOnce();
+            expect(ctx.router.removeHandler).toHaveBeenCalledTimes(1);
+            expect(ctx.router.removeHandler).toHaveBeenCalledWith('page_evaluate');
+        });
+        it('clears extension tool registration state', async () => {
+            const ctx = createMockCtx();
+            const extRecord = { domain: 'browser', registeredTool: { remove: vi.fn() } };
+            ctx.extensionToolsByName.set('ext_tool', extRecord);
+            ctx.activatedToolNames.add('ext_tool');
+            ctx.activatedRegisteredTools.set('ext_tool', extRecord.registeredTool);
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['ext_tool']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(extRecord.registeredTool).toBeUndefined();
+        });
+        it('removes domain from enabledDomains when no tools remain', async () => {
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: vi.fn() });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(ctx.enabledDomains.has('browser')).toBe(false);
+        });
+        it('keeps domain in enabledDomains when base-profile tools remain', async () => {
+            const ctx = createMockCtx({
+                selectedTools: [{ name: 'page_click' }],
+            });
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', { remove: vi.fn() });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(ctx.enabledDomains.has('browser')).toBe(true);
+        });
+        it('is a no-op when domain has no TTL entry', async () => {
+            const ctx = createMockCtx();
+            await deactivateDomainOnExpiry(ctx, 'nonexistent');
+            expect(ctx.server.sendToolListChanged).not.toHaveBeenCalled();
+        });
+        it('handles registeredTool.remove() throwing gracefully', async () => {
+            const ctx = createMockCtx();
+            ctx.activatedToolNames.add('page_navigate');
+            ctx.activatedRegisteredTools.set('page_navigate', {
+                remove: vi.fn(() => { throw new Error('SDK removal failed'); }),
+            });
+            ctx.enabledDomains.add('browser');
+            startDomainTtl(ctx, 'browser', 10, ['page_navigate']);
+            await deactivateDomainOnExpiry(ctx, 'browser');
+            expect(ctx.activatedToolNames.has('page_navigate')).toBe(false);
+            expect(ctx.server.sendToolListChanged).toHaveBeenCalled();
+        });
+    });
+});

package/dist/tests/server/MCPServer.context.test.d.ts

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