@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/native/Win32API.js

@@ -213,6 +213,19 @@ export function GetModuleBaseName(hProcess, hModule, maxSize = 260) {
     }
     return buffer.toString('utf8', 0, len);
 }
+export function GetModuleFileNameEx(hProcess, hModule, maxSize = 32_768) {
+    const fn = getPsapi().func('uint32 GetModuleFileNameExA(void *, void *, _Out_ char[], uint32)');
+    const buffer = Buffer.alloc(maxSize);
+    const result = fn(hProcess, hModule, buffer, maxSize);
+    if (typeof result !== 'number' || result <= 0) {
+        return null;
+    }
+    let len = 0;
+    while (len < maxSize && buffer[len] !== 0) {
+        len++;
+    }
+    return len > 0 ? buffer.toString('utf8', 0, len) : null;
+}
 export function GetModuleInformation(hProcess, hModule) {
     const fn = getPsapi().func('int GetModuleInformation(void *, void *, _Out_ uint8_t[24], uint32)');
     const buffer = Buffer.alloc(24);

package/dist/src/native/Win32Debug.js

@@ -1,6 +1,6 @@
 import koffi from 'koffi';
 import { logger } from '../utils/logger.js';
-import { GetLastError } from './Win32API.js';
+import { GetLastError, CloseHandle } from './Win32API.js';
 export const THREAD_ACCESS = {
     TERMINATE: 0x0001,
     SUSPEND_RESUME: 0x0002,
@@ -70,18 +70,18 @@ export function parseContext(buf) {
         rdx: buf.readBigUInt64LE(0x88),
         rbx: buf.readBigUInt64LE(0x90),
         rsp: buf.readBigUInt64LE(0x98),
-        rbp: buf.readBigUInt64LE(0xA0),
-        rsi: buf.readBigUInt64LE(0xA8),
-        rdi: buf.readBigUInt64LE(0xB0),
-        r8: buf.readBigUInt64LE(0xB8),
-        r9: buf.readBigUInt64LE(0xC0),
-        r10: buf.readBigUInt64LE(0xC8),
-        r11: buf.readBigUInt64LE(0xD0),
-        r12: buf.readBigUInt64LE(0xD8),
-        r13: buf.readBigUInt64LE(0xE0),
-        r14: buf.readBigUInt64LE(0xE8),
-        r15: buf.readBigUInt64LE(0xF0),
-        rip: buf.readBigUInt64LE(0xF8),
+        rbp: buf.readBigUInt64LE(0xa0),
+        rsi: buf.readBigUInt64LE(0xa8),
+        rdi: buf.readBigUInt64LE(0xb0),
+        r8: buf.readBigUInt64LE(0xb8),
+        r9: buf.readBigUInt64LE(0xc0),
+        r10: buf.readBigUInt64LE(0xc8),
+        r11: buf.readBigUInt64LE(0xd0),
+        r12: buf.readBigUInt64LE(0xd8),
+        r13: buf.readBigUInt64LE(0xe0),
+        r14: buf.readBigUInt64LE(0xe8),
+        r15: buf.readBigUInt64LE(0xf0),
+        rip: buf.readBigUInt64LE(0xf8),
     };
 }
 export function writeContext(buf, ctx) {
@@ -102,7 +102,7 @@ export function writeContext(buf, ctx) {
     if (ctx.dr7 !== undefined)
         buf.writeBigUInt64LE(ctx.dr7, 0x70);
     if (ctx.rip !== undefined)
-        buf.writeBigUInt64LE(ctx.rip, 0xF8);
+        buf.writeBigUInt64LE(ctx.rip, 0xf8);
 }
 let kernel32Debug = null;
 function getKernel32() {
@@ -119,7 +119,7 @@ export function OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId) {
 export function SuspendThread(hThread) {
     const fn = getKernel32().func('uint32 SuspendThread(void *)');
     const result = fn(hThread);
-    if (result === 0xFFFFFFFF) {
+    if (result === 0xffffffff) {
         throw new Error(`SuspendThread failed. Error: 0x${GetLastError().toString(16)}`);
     }
     return result;
@@ -127,7 +127,7 @@ export function SuspendThread(hThread) {
 export function ResumeThread(hThread) {
     const fn = getKernel32().func('uint32 ResumeThread(void *)');
     const result = fn(hThread);
-    if (result === 0xFFFFFFFF) {
+    if (result === 0xffffffff) {
         throw new Error(`ResumeThread failed. Error: 0x${GetLastError().toString(16)}`);
     }
     return result;
@@ -209,10 +209,9 @@ export function EnumerateProcessThreads(pid) {
     const entry = Buffer.alloc(28);
     entry.writeUInt32LE(28, 0);
     try {
-        const { CloseHandle } = require('./Win32API.js');
         if (fnFirst(snapshot, entry) !== 0) {
             do {
-                const ownerPid = entry.readUInt32LE(0x0C);
+                const ownerPid = entry.readUInt32LE(0x0c);
                 if (ownerPid === pid) {
                     threads.push(entry.readUInt32LE(0x08));
                 }
@@ -221,7 +220,8 @@ export function EnumerateProcessThreads(pid) {
         }
         CloseHandle(snapshot);
     }
-    catch {
+    catch (e) {
+        console.error('[EnumerateProcessThreads] cleanup error:', e);
     }
     return threads;
 }

package/dist/src/native/platform/darwin/DarwinAPI.d.ts

@@ -115,6 +115,8 @@ export declare function machVmAllocate(task: number, size: bigint, flags: number
     address: bigint;
 };
 export declare function machVmDeallocate(task: number, address: bigint, size: bigint): number;
+export declare function taskSuspend(task: number): number;
+export declare function taskResume(task: number): number;
 export declare function dyldImageCount(): number;
 export declare function dyldGetImageName(index: number): string;
 export declare function dyldGetImageVmaddrSlide(index: number): bigint;

package/dist/src/native/platform/darwin/DarwinAPI.js

@@ -198,6 +198,14 @@ export function machVmDeallocate(task, address, size) {
     const fn = getLibSystem().func('int32 mach_vm_deallocate(uint32, uint64, uint64)');
     return fn(task, address, size);
 }
+export function taskSuspend(task) {
+    const fn = getLibSystem().func('int32 task_suspend(uint32)');
+    return fn(task);
+}
+export function taskResume(task) {
+    const fn = getLibSystem().func('int32 task_resume(uint32)');
+    return fn(task);
+}
 export function dyldImageCount() {
     const fn = getLibSystem().func('uint32 _dyld_image_count()');
     return fn();

package/dist/src/native/platform/darwin/DarwinMemoryProvider.js

@@ -68,9 +68,14 @@ export class DarwinMemoryProvider {
             }
         }
         catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isCrash = /signal|bus error|segfault|abort/i.test(message);
             return {
                 available: false,
-                reason: `task_for_pid permission check failed: ${err instanceof Error ? err.message : String(err)}`,
+                reason: isCrash
+                    ? `Mach API call crashed (${message}). This may be caused by SIP (System Integrity Protection) on ARM64 macOS. ` +
+                        'Disable SIP or use a code-signed binary with com.apple.security.cs.debugger entitlement.'
+                    : `task_for_pid permission check failed: ${message}. Run with sudo or add debugger entitlement.`,
                 platform: 'darwin',
             };
         }

package/dist/src/server/MCPServer.context.d.ts

@@ -61,7 +61,6 @@ export interface DomainInstances {
     debuggerManager?: import('../modules/debugger/DebuggerManager.js').DebuggerManager;
     runtimeInspector?: import('../modules/debugger/RuntimeInspector.js').RuntimeInspector;
     consoleMonitor?: import('../modules/monitor/ConsoleMonitor.js').ConsoleMonitor;
-    llm?: import('../services/LLMService.js').LLMService;
     browserHandlers?: import('./domains/browser/index.js').BrowserToolHandlers;
     debuggerHandlers?: import('./domains/debugger/index.js').DebuggerToolHandlers;
     advancedHandlers?: import('./domains/network/index.js').AdvancedToolHandlers;
@@ -90,6 +89,8 @@ export interface DomainInstances {
     coordinationHandlers?: import('./domains/coordination/index.js').CoordinationHandlers;
     traceRecorder?: import('../modules/trace/TraceRecorder.js').TraceRecorder;
     traceHandlers?: import('./domains/trace/index.js').TraceToolHandlers;
+    evidenceHandlers?: import('./domains/evidence/index.js').EvidenceHandlers;
+    instrumentationHandlers?: import('./domains/instrumentation/index.js').InstrumentationHandlers | undefined;
 }
 export interface ServerMethods {
     registerCaches(): Promise<void>;

package/dist/src/server/MCPServer.d.ts

@@ -55,7 +55,6 @@ export declare class MCPServer implements MCPServerContext {
     debuggerManager: import('../modules/debugger/DebuggerManager.js').DebuggerManager | undefined;
     runtimeInspector: import('../modules/debugger/RuntimeInspector.js').RuntimeInspector | undefined;
     consoleMonitor: import('../modules/monitor/ConsoleMonitor.js').ConsoleMonitor | undefined;
-    llm: import('../services/LLMService.js').LLMService | undefined;
     browserHandlers: import('./domains/browser/index.js').BrowserToolHandlers | undefined;
     debuggerHandlers: import('./domains/debugger/index.js').DebuggerToolHandlers | undefined;
     advancedHandlers: import('./domains/network/index.js').AdvancedToolHandlers | undefined;
@@ -82,6 +81,8 @@ export declare class MCPServer implements MCPServerContext {
     sourcemapHandlers: import('./domains/sourcemap/index.js').SourcemapToolHandlers | undefined;
     transformHandlers: import('./domains/transform/index.js').TransformToolHandlers | undefined;
     coordinationHandlers: import('./domains/coordination/index.js').CoordinationHandlers | undefined;
+    evidenceHandlers: import('./domains/evidence/index.js').EvidenceHandlers | undefined;
+    instrumentationHandlers: import('./domains/instrumentation/index.js').InstrumentationHandlers | undefined;
     constructor(config: Config);
     resolveEnabledDomains(tools: Tool[]): Set<string>;
     registerSingleTool(toolDef: Tool): RegisteredTool;

package/dist/src/server/MCPServer.domain.d.ts

@@ -1,4 +1,4 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { MCPServerContext } from './MCPServer.context.js';
 export declare function resolveEnabledDomains(tools: Tool[]): Set<string>;
-export declare function createDomainProxy<T extends object>(ctx: MCPServerContext, domain: string, label: string, factory: () => T): T;
+export declare function createDomainProxy<T extends object>(ctx: MCPServerContext, domain: string, label: string, factory: () => T | Promise<T>): T;

package/dist/src/server/MCPServer.domain.js

@@ -1,6 +1,11 @@
 import { logger } from '../utils/logger.js';
 import { getToolDomain } from './ToolCatalog.js';
 import { ToolError } from '../errors/ToolError.js';
+function isPromiseLike(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        typeof value.then === 'function');
+}
 export function resolveEnabledDomains(tools) {
     const domains = new Set();
     for (const tool of tools) {
@@ -12,30 +17,90 @@ export function resolveEnabledDomains(tools) {
     return domains;
 }
 export function createDomainProxy(ctx, domain, label, factory) {
+    const errorDetails = { domain, label };
+    let initPromise;
     let instance;
-    let initializing = false;
+    let factoryKind = 'unknown';
+    let factoryDepth = 0;
+    function bindPropertyValue(targetInstance, prop) {
+        const value = targetInstance[prop];
+        return typeof value === 'function' ? value.bind(targetInstance) : value;
+    }
+    function initialize() {
+        if (instance)
+            return instance;
+        if (initPromise)
+            return initPromise;
+        if (factoryDepth > 0) {
+            throw new ToolError('RUNTIME', `${label}: circular initialization detected for domain "${domain}"`, { details: errorDetails });
+        }
+        logger.info(`Lazy-initializing ${label} for domain "${domain}"`);
+        factoryDepth++;
+        try {
+            const created = factory();
+            if (isPromiseLike(created)) {
+                factoryKind = 'async';
+                initPromise = Promise.resolve(created).then((resolvedInstance) => {
+                    instance = resolvedInstance;
+                    return resolvedInstance;
+                });
+                return initPromise;
+            }
+            factoryKind = 'sync';
+            instance = created;
+            initPromise = Promise.resolve(created);
+            return created;
+        }
+        finally {
+            factoryDepth--;
+        }
+    }
+    async function getOrCreateInstance() {
+        const created = initialize();
+        return isPromiseLike(created) ? await created : created;
+    }
+    function createAsyncPropertyAccessor(prop) {
+        const resolveProperty = () => getOrCreateInstance().then((resolvedInstance) => bindPropertyValue(resolvedInstance, prop));
+        const accessor = (...args) => getOrCreateInstance().then((resolvedInstance) => {
+            const value = resolvedInstance[prop];
+            if (typeof value === 'function') {
+                return value.call(resolvedInstance, ...args);
+            }
+            return value;
+        });
+        return new Proxy(accessor, {
+            get: (target, asyncProp, receiver) => {
+                if (asyncProp === 'then') {
+                    return (...args) => resolveProperty().then(...args);
+                }
+                if (asyncProp === 'catch') {
+                    return (...args) => resolveProperty().catch(...args);
+                }
+                if (asyncProp === 'finally') {
+                    return (...args) => resolveProperty().finally(...args);
+                }
+                return Reflect.get(target, asyncProp, receiver);
+            },
+        });
+    }
     return new Proxy({}, {
         get: (_target, prop) => {
             if (!ctx.enabledDomains.has(domain)) {
                 return () => {
-                    throw new ToolError('PREREQUISITE', `${label} is unavailable: domain "${domain}" not enabled by current tool profile`, { details: { domain, label } });
+                    throw new ToolError('PREREQUISITE', `${label} is unavailable: domain "${domain}" not enabled by current tool profile`, { details: errorDetails });
                 };
             }
-            if (!instance) {
-                if (initializing) {
-                    throw new ToolError('RUNTIME', `${label}: circular initialization detected for domain "${domain}"`, { details: { domain, label } });
-                }
-                initializing = true;
-                try {
-                    logger.info(`Lazy-initializing ${label} for domain "${domain}"`);
-                    instance = factory();
-                }
-                finally {
-                    initializing = false;
-                }
+            if (prop === 'then' || prop === 'catch' || prop === Symbol.toStringTag) {
+                return undefined;
+            }
+            if (instance && factoryKind === 'sync') {
+                return bindPropertyValue(instance, prop);
+            }
+            const created = initialize();
+            if (isPromiseLike(created)) {
+                return createAsyncPropertyAccessor(prop);
             }
-            const value = instance[prop];
-            return typeof value === 'function' ? value.bind(instance) : value;
+            return bindPropertyValue(created, prop);
         },
     });
 }

package/dist/src/server/MCPServer.js

@@ -13,8 +13,10 @@ import { resolveToolsForRegistration } from './MCPServer.registration.js';
 import { createDomainProxy, resolveEnabledDomains } from './MCPServer.domain.js';
 import { refreshDomainTtlForTool } from './MCPServer.activation.ttl.js';
 import { closeServer, startHttpTransport, startStdioTransport } from './MCPServer.transport.js';
+import { ActivationController } from './activation/ActivationController.js';
 import { registerSingleTool as registerSingleToolImpl } from './MCPServer.tools.js';
 import { registerSearchMetaTools } from './MCPServer.search.js';
+import { registerServerResources } from './MCPServer.resources.js';
 import { createServerEventBus } from './EventBus.js';
 import { getAllManifests } from './registry/index.js';
 import { listExtensions as listExtensionsImpl, reloadExtensions as reloadExtensionsImpl, } from './extensions/ExtensionManager.js';
@@ -81,8 +83,8 @@ export class MCPServer {
                     if (!depsEntries.some(([k]) => k === key)) {
                         depsEntries.push([
                             key,
-                            createDomainProxy(this, m.domain, `${m.domain}:${key}`, () => {
-                                m.ensure(this);
+                            createDomainProxy(this, m.domain, `${m.domain}:${key}`, async () => {
+                                await m.ensure(this);
                                 return this[key];
                             }),
                         ]);
@@ -101,6 +103,7 @@ export class MCPServer {
             return null;
         });
         this.server = new McpServer({ name: config.mcp.name, version: config.mcp.version }, { capabilities: { tools: { listChanged: true }, logging: {} } });
+        this.setDomainInstance('activationController', new ActivationController(this.eventBus, this));
         this.registerTools();
     }
     resolveEnabledDomains(tools) {
@@ -153,6 +156,7 @@ export class MCPServer {
     async executeToolWithTracking(name, args) {
         try {
             const response = await this.router.execute(name, args);
+            this.contextGuard.recordCall(name);
             const enriched = this.contextGuard.enrichResponse(name, response);
             try {
                 this.tokenBudget.recordToolCall(name, args, enriched);
@@ -209,22 +213,46 @@ export class MCPServer {
             this.registerSingleTool(toolDef);
         }
         registerSearchMetaTools(this);
+        registerServerResources(this);
         logger.info(`Registered ${this.selectedTools.length} tools + meta tools with McpServer`);
     }
 }
 const DOMAIN_INSTANCE_KEYS = [
-    'collector', 'pageController', 'domInspector',
-    'scriptManager', 'debuggerManager', 'runtimeInspector',
-    'consoleMonitor', 'llm',
-    'browserHandlers', 'debuggerHandlers', 'advancedHandlers',
-    'aiHookHandlers', 'hookPresetHandlers',
-    'deobfuscator', 'advancedDeobfuscator', 'astOptimizer',
-    'obfuscationDetector', 'analyzer', 'cryptoDetector', 'hookManager',
-    'coreAnalysisHandlers', 'coreMaintenanceHandlers', 'extensionManagementHandlers',
-    'processHandlers', 'workflowHandlers', 'wasmHandlers',
-    'streamingHandlers', 'encodingHandlers', 'antidebugHandlers',
-    'graphqlHandlers', 'platformHandlers', 'sourcemapHandlers',
-    'transformHandlers', 'coordinationHandlers',
+    'collector',
+    'pageController',
+    'domInspector',
+    'scriptManager',
+    'debuggerManager',
+    'runtimeInspector',
+    'consoleMonitor',
+    'browserHandlers',
+    'debuggerHandlers',
+    'advancedHandlers',
+    'aiHookHandlers',
+    'hookPresetHandlers',
+    'deobfuscator',
+    'advancedDeobfuscator',
+    'astOptimizer',
+    'obfuscationDetector',
+    'analyzer',
+    'cryptoDetector',
+    'hookManager',
+    'coreAnalysisHandlers',
+    'coreMaintenanceHandlers',
+    'extensionManagementHandlers',
+    'processHandlers',
+    'workflowHandlers',
+    'wasmHandlers',
+    'streamingHandlers',
+    'encodingHandlers',
+    'antidebugHandlers',
+    'graphqlHandlers',
+    'platformHandlers',
+    'sourcemapHandlers',
+    'transformHandlers',
+    'coordinationHandlers',
+    'evidenceHandlers',
+    'instrumentationHandlers',
 ];
 for (const key of DOMAIN_INSTANCE_KEYS) {
     if (key === 'domainInstanceMap' || key === 'getDomainInstance' || key === 'setDomainInstance')

package/dist/src/server/MCPServer.resources.d.ts

@@ -0,0 +1,2 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+export declare function registerServerResources(ctx: MCPServerContext): void;

package/dist/src/server/MCPServer.resources.js

@@ -0,0 +1,91 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+function asJsonResource(uri, payload) {
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: 'application/json',
+                text: JSON.stringify(payload, null, 2),
+            },
+        ],
+    };
+}
+function asTextResource(uri, text, mimeType) {
+    return {
+        contents: [
+            {
+                uri,
+                mimeType,
+                text,
+            },
+        ],
+    };
+}
+function getEvidenceGraph(ctx) {
+    return ctx.getDomainInstance('evidenceGraph');
+}
+function getSessionManager(ctx) {
+    return ctx.getDomainInstance('instrumentationSessionManager');
+}
+export function registerServerResources(ctx) {
+    ctx.server.registerResource('evidence_graph_json', 'jshook://evidence/graph', {
+        title: 'Evidence Graph JSON',
+        description: 'Serializable snapshot of the current reverse evidence graph.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const graph = getEvidenceGraph(ctx);
+        return asJsonResource(uri.toString(), graph
+            ? graph.exportJson()
+            : { version: 1, nodes: [], edges: [], exportedAt: new Date().toISOString() });
+    });
+    ctx.server.registerResource('evidence_graph_markdown', 'jshook://evidence/graph.md', {
+        title: 'Evidence Graph Markdown',
+        description: 'Markdown report for the current reverse evidence graph.',
+        mimeType: 'text/markdown',
+    }, async (uri) => {
+        const graph = getEvidenceGraph(ctx);
+        return asTextResource(uri.toString(), graph
+            ? graph.exportMarkdown()
+            : '# Reverse Evidence Graph Report\n\nNo evidence graph is available.\n', 'text/markdown');
+    });
+    ctx.server.registerResource('instrumentation_sessions', 'jshook://instrumentation/sessions', {
+        title: 'Instrumentation Sessions',
+        description: 'Expanded snapshots for all active instrumentation sessions.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const manager = getSessionManager(ctx);
+        return asJsonResource(uri.toString(), manager ? manager.listSessionSnapshots() : []);
+    });
+    const sessionTemplate = new ResourceTemplate('jshook://instrumentation/session/{sessionId}', {
+        list: async () => {
+            const manager = getSessionManager(ctx);
+            return {
+                resources: (manager?.listSessions() ?? []).map((session) => ({
+                    name: session.name || `Instrumentation Session ${session.id}`,
+                    uri: `jshook://instrumentation/session/${session.id}`,
+                    mimeType: 'application/json',
+                    description: `operations=${session.operationCount}, artifacts=${session.artifactCount}, status=${session.status}`,
+                })),
+            };
+        },
+        complete: {
+            sessionId: async () => {
+                const manager = getSessionManager(ctx);
+                return (manager?.listSessions() ?? []).map((session) => session.id);
+            },
+        },
+    });
+    ctx.server.registerResource('instrumentation_session_snapshot', sessionTemplate, {
+        title: 'Instrumentation Session Snapshot',
+        description: 'Expanded snapshot for a single instrumentation session.',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const sessionId = String(variables['sessionId'] ?? '');
+        const manager = getSessionManager(ctx);
+        const snapshot = manager?.getSessionSnapshot(sessionId);
+        return asJsonResource(uri.toString(), snapshot ?? {
+            success: false,
+            error: `Instrumentation session "${sessionId}" not found`,
+        });
+    });
+}

package/dist/src/server/MCPServer.search.handlers.call.js

@@ -76,7 +76,8 @@ export async function handleCallTool(ctx, args) {
             const engine = getSearchEngine(ctx);
             engine.recordToolCallFeedback(name, '');
         }
-        catch { }
+        catch {
+        }
         return attachCallToolMetadata(response, callMetadata);
     }
     catch (error) {

package/dist/src/server/MCPServer.search.helpers.js

@@ -37,7 +37,7 @@ export function buildSearchSignature(ctx) {
 export function getSearchEngine(ctx) {
     const signature = buildSearchSignature(ctx);
     const cached = searchEngineCache.get(ctx);
-    if (cached && cached.signature === signature)
+    if (cached?.signature === signature)
         return cached.engine;
     const tools = getCombinedTools(ctx);
     const extensionDomains = getExtensionDomainMap(ctx);
@@ -65,7 +65,7 @@ export function buildDomainDescription(ctx) {
     }
     const totalTools = getAllRegistrations().length + ctx.extensionToolsByName.size;
     const parts = Object.entries(groups)
-        .sort((a, b) => b[1] - a[1])
+        .toSorted((a, b) => b[1] - a[1])
         .map(([domain, count]) => `${domain} (${count})`)
         .join(' | ');
     return (`Search ${totalTools} tools across ${Object.keys(groups).length} capability domains. ` +

package/dist/src/server/MCPServer.tools.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import {} from 'zod';
 import { logger } from '../utils/logger.js';
 import { asErrorResponse, toolErrorToResponse } from './domains/shared/response.js';
 import { ToolError } from '../errors/ToolError.js';

package/dist/src/server/MCPServer.transport.js

@@ -119,6 +119,18 @@ export async function closeServer(ctx) {
     }
     ctx.domainTtlEntries.clear();
     ctx.detailedData.shutdown();
+    const activationController = typeof ctx.getDomainInstance === 'function'
+        ? ctx.getDomainInstance('activationController')
+        : (ctx
+            .activationController ?? undefined);
+    if (activationController && typeof activationController.dispose === 'function') {
+        try {
+            activationController.dispose();
+        }
+        catch (error) {
+            logger.warn('activationController cleanup failed:', error);
+        }
+    }
     if (ctx.httpServer) {
         const httpServer = ctx.httpServer;
         const closePromise = new Promise((resolve) => httpServer.close(() => resolve()));

package/dist/src/server/ToolCallContextGuard.d.ts

@@ -9,12 +9,17 @@ interface TabContextProvider {
 export declare class ToolCallContextGuard {
     private getProvider;
     private readonly contextSensitiveCache;
+    private lastToolName;
+    private consecutiveCount;
     constructor(getProvider: () => TabContextProvider | null);
     isContextSensitive(toolName: string): boolean;
+    recordCall(toolName: string): number;
+    isRepeatLoop(): boolean;
     enrichResponse<T extends {
         content?: unknown[];
         isError?: boolean;
     }>(toolName: string, response: T): T;
     private spliceTabContext;
+    private injectRepeatWarning;
 }
 export {};