@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,97 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { asTextResponse } from './domains/shared/response.js';
-import { SEARCH_AUTO_ACTIVATE_DOMAINS, ACTIVATION_TTL_MINUTES } from '../constants.js';
-import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
-import { getSearchEngine, getActiveToolNames } from './MCPServer.search.helpers.js';
-import { describeTool, generateExampleArgs } from './ToolRouter.js';
-export async function handleSearchTools(ctx, args) {
-    const query = args.query;
-    const topK = args.top_k ?? 10;
-    const engine = getSearchEngine(ctx);
-    const activeNames = getActiveToolNames(ctx);
-    let results = await engine.search(query, topK, activeNames);
-    let autoActivatedDomains = null;
-    if (SEARCH_AUTO_ACTIVATE_DOMAINS && results.length > 0) {
-        const inactiveDomains = new Set();
-        for (const result of results) {
-            if (!activeNames.has(result.name) && result.domain) {
-                inactiveDomains.add(result.domain);
-            }
-        }
-        const domainsToActivate = [];
-        for (const domain of inactiveDomains) {
-            if (!ctx.enabledDomains.has(domain)) {
-                domainsToActivate.push(domain);
-            }
-        }
-        if (domainsToActivate.length > 0) {
-            autoActivatedDomains = [];
-            for (const domain of domainsToActivate) {
-                try {
-                    await handleActivateDomain(ctx, {
-                        domain,
-                        ttlMinutes: ACTIVATION_TTL_MINUTES,
-                    });
-                    autoActivatedDomains.push(domain);
-                    logger.info(`[search-auto-activate] Activated domain "${domain}" with TTL=${ACTIVATION_TTL_MINUTES}min`);
-                }
-                catch (error) {
-                    logger.warn(`[search-auto-activate] Failed to activate domain "${domain}":`, error);
-                }
-            }
-            if (autoActivatedDomains.length > 0) {
-                const newActiveNames = getActiveToolNames(ctx);
-                results = await engine.search(query, topK, newActiveNames);
-            }
-        }
-    }
-    const topResult = results[0];
-    const topTool = topResult ? describeTool(topResult.name, ctx) : null;
-    const topExampleArgs = topTool ? generateExampleArgs(topTool.inputSchema) : undefined;
-    const searchNextActions = [];
-    if (topResult) {
-        if (!topResult.isActive) {
-            const activateNames = results
-                .filter((r) => !r.isActive)
-                .slice(0, 3)
-                .map((r) => r.name);
-            searchNextActions.push({
-                step: 1,
-                action: 'activate_tools',
-                command: `activate_tools with names: [${activateNames.map((n) => `"${n}"`).join(', ')}]`,
-                description: `Activate top ${activateNames.length} result(s)`,
-            });
-            searchNextActions.push({
-                step: 2,
-                action: 'call',
-                command: topResult.name,
-                exampleArgs: topExampleArgs,
-                description: `Call ${topResult.name}. Use describe_tool("${topResult.name}") only if you need the full schema.`,
-            });
-        }
-        else {
-            searchNextActions.push({
-                step: 1,
-                action: 'call',
-                command: topResult.name,
-                exampleArgs: topExampleArgs,
-                description: `Call ${topResult.name} directly. Use describe_tool("${topResult.name}") only if you need the full schema.`,
-            });
-        }
-    }
-    const response = {
-        query,
-        resultCount: results.length,
-        results,
-        nextActions: searchNextActions,
-        hint: 'For guided tool discovery with workflow detection, use route_tool instead. ' +
-            'Use activate_tools to enable specific tools, activate_domain for entire domains.',
-    };
-    if (autoActivatedDomains && autoActivatedDomains.length > 0) {
-        response.autoActivatedDomains = autoActivatedDomains;
-        response.callToolHint =
-            'Tools were auto-activated but may not appear in your tool list. ' +
-                'Use call_tool({ name: "<tool_name>", args: {...} }) to invoke them directly.';
-    }
-    return asTextResponse(JSON.stringify(response, null, 2));
-}

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

@@ -1,10 +0,0 @@
-import { allTools } from './ToolCatalog.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-import { ToolSearchEngine } from './ToolSearch.js';
-export declare function getActiveToolNames(ctx: MCPServerContext): Set<string>;
-export declare function getExtensionDomainMap(ctx: MCPServerContext): Map<string, string>;
-export declare function getCombinedTools(ctx: MCPServerContext): typeof allTools;
-export declare function getToolByName(ctx: MCPServerContext): Map<string, (typeof allTools)[number]>;
-export declare function buildSearchSignature(ctx: MCPServerContext): string;
-export declare function getSearchEngine(ctx: MCPServerContext): ToolSearchEngine;
-export declare function buildDomainDescription(ctx: MCPServerContext): string;

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

@@ -1,76 +0,0 @@
-import { allTools } from './ToolCatalog.js';
-import { ToolSearchEngine } from './ToolSearch.js';
-import { getAllRegistrations } from './registry/index.js';
-import { SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER } from '../constants.js';
-export function getActiveToolNames(ctx) {
-    const names = new Set(ctx.selectedTools.map((t) => t.name));
-    for (const name of ctx.activatedToolNames)
-        names.add(name);
-    return names;
-}
-export function getExtensionDomainMap(ctx) {
-    const map = new Map();
-    for (const record of ctx.extensionToolsByName.values()) {
-        map.set(record.name, record.domain);
-    }
-    return map;
-}
-export function getCombinedTools(ctx) {
-    const tools = new Map(allTools.map((tool) => [tool.name, tool]));
-    for (const record of ctx.extensionToolsByName.values()) {
-        tools.set(record.name, record.tool);
-    }
-    return [...tools.values()];
-}
-export function getToolByName(ctx) {
-    return new Map(getCombinedTools(ctx).map((tool) => [tool.name, tool]));
-}
-const searchEngineCache = new WeakMap();
-export function buildSearchSignature(ctx) {
-    const extParts = [];
-    for (const [name, record] of ctx.extensionToolsByName) {
-        extParts.push(`${name}:${record.domain}`);
-    }
-    extParts.sort();
-    return [ctx.extensionWorkflowRuntimeById.size, extParts.join('|')].join('::');
-}
-export function getSearchEngine(ctx) {
-    const signature = buildSearchSignature(ctx);
-    const cached = searchEngineCache.get(ctx);
-    if (cached?.signature === signature)
-        return cached.engine;
-    const tools = getCombinedTools(ctx);
-    const extensionDomains = getExtensionDomainMap(ctx);
-    const domainScoreMultipliers = new Map();
-    const toolScoreMultipliers = new Map();
-    for (const record of ctx.extensionToolsByName.values()) {
-        toolScoreMultipliers.set(record.name, 1.12);
-    }
-    if (ctx.extensionWorkflowRuntimeById.size > 0) {
-        domainScoreMultipliers.set('workflow', SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER);
-        toolScoreMultipliers.set('run_extension_workflow', 1.35);
-        toolScoreMultipliers.set('list_extension_workflows', 1.25);
-    }
-    const engine = new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers, ctx.config.search);
-    searchEngineCache.set(ctx, { signature, engine });
-    return engine;
-}
-export function buildDomainDescription(ctx) {
-    const groups = {};
-    for (const r of getAllRegistrations()) {
-        groups[r.domain] = (groups[r.domain] ?? 0) + 1;
-    }
-    for (const record of ctx.extensionToolsByName.values()) {
-        groups[record.domain] = (groups[record.domain] ?? 0) + 1;
-    }
-    const totalTools = getAllRegistrations().length + ctx.extensionToolsByName.size;
-    const parts = Object.entries(groups)
-        .toSorted((a, b) => b[1] - a[1])
-        .map(([domain, count]) => `${domain} (${count})`)
-        .join(' | ');
-    return (`Search ${totalTools} tools across ${Object.keys(groups).length} capability domains. ` +
-        `This includes built-in tools plus any loaded plugin/workflow tools (${ctx.extensionToolsByName.size} currently loaded). ` +
-        `In search-tier sessions, call this before assuming a capability is unavailable. ` +
-        `Use activate_tools for exact matches, activate_domain for an entire domain. ` +
-        `Domains: ${parts}.`);
-}

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

@@ -1,184 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { asErrorResponse } from './domains/shared/response.js';
-import { getAllDomains } from './registry/index.js';
-import { buildZodShape } from './MCPServer.schema.js';
-export { buildSearchSignature, getSearchEngine } from './MCPServer.search.helpers.js';
-export { buildDomainDescription } from './MCPServer.search.helpers.js';
-import { buildDomainDescription } from './MCPServer.search.helpers.js';
-import { handleSearchTools } from './MCPServer.search.handlers.search.js';
-import { handleActivateTools, handleDeactivateTools, } from './MCPServer.search.handlers.activate.js';
-import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
-import { handleRouteTool, handleDescribeTool } from './MCPServer.search.handlers.route.js';
-import { handleCallTool } from './MCPServer.search.handlers.call.js';
-function buildMetaToolDefinitions(ctx) {
-    return [
-        {
-            name: 'search_tools',
-            description: buildDomainDescription(ctx),
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: {
-                        type: 'string',
-                        description: 'Search query: keywords, tool name, domain name, or description fragment',
-                    },
-                    top_k: { type: 'number', description: 'Max results to return (default: 10, max: 30)' },
-                },
-                required: ['query'],
-            },
-            handler: handleSearchTools,
-        },
-        {
-            name: 'route_tool',
-            description: 'One-stop tool router: accepts a natural language task description, returns recommended tools and next actions. ' +
-                'Automatically detects workflow patterns, recommends activation order, and provides example arguments. ' +
-                'Use this instead of search_tools when you want guided tool discovery with actionable next steps.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    task: {
-                        type: 'string',
-                        description: 'Natural language description of the task you want to accomplish',
-                    },
-                    context: {
-                        type: 'object',
-                        description: 'Optional context hints for routing',
-                        properties: {
-                            preferredDomain: {
-                                type: 'string',
-                                description: 'Domain preference (e.g., "browser", "network")',
-                            },
-                            autoActivate: {
-                                type: 'boolean',
-                                description: 'Whether to auto-activate recommended tools (default: true)',
-                            },
-                            maxRecommendations: {
-                                type: 'number',
-                                description: 'Maximum number of recommendations (default: 5)',
-                            },
-                        },
-                    },
-                },
-                required: ['task'],
-            },
-            handler: handleRouteTool,
-        },
-        {
-            name: 'describe_tool',
-            description: 'Get detailed information about a specific tool, including its input schema. ' +
-                'Use this to see the exact parameters a tool expects before calling it.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Tool name to describe' },
-                },
-                required: ['name'],
-            },
-            handler: handleDescribeTool,
-        },
-        {
-            name: 'activate_tools',
-            description: 'Dynamically register specific tools by name, regardless of current base tier. ' +
-                'Use after search_tools to enable exactly the tools you need. ' +
-                'In search-tier sessions this is usually enough; you do not need boost_profile just to use a few exact tools. ' +
-                'Activated tools appear in the tool list immediately. ' +
-                'If tools do not appear after activation, use call_tool to invoke them directly.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    names: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Array of tool names to activate (from search_tools results)',
-                    },
-                },
-                required: ['names'],
-            },
-            handler: handleActivateTools,
-        },
-        {
-            name: 'deactivate_tools',
-            description: 'Remove previously activated tools to free context. ' +
-                'Only affects tools added via activate_tools, not base profile tools.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    names: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Array of tool names to deactivate',
-                    },
-                },
-                required: ['names'],
-            },
-            handler: handleDeactivateTools,
-        },
-        {
-            name: 'activate_domain',
-            description: `Activate all tools in a domain at once. ` +
-                `Domains: ${[...getAllDomains()].join(', ')}. ` +
-                `Use extensions_reload first to include external plugin/workflow domains.`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    domain: {
-                        type: 'string',
-                        description: 'Domain name to activate (e.g. "debugger", "network")',
-                    },
-                    ttlMinutes: {
-                        type: 'number',
-                        description: 'Auto-deactivate after N minutes (default: 30, set 0 for no expiry)',
-                    },
-                },
-                required: ['domain'],
-            },
-            handler: handleActivateDomain,
-        },
-        {
-            name: 'call_tool',
-            description: 'Execute any tool by name with auto-activation. ' +
-                'Use this when activate_tools/activate_domain registered a tool but it does not appear in your tool list ' +
-                '(common for clients that do not support tools/list_changed notifications). ' +
-                "Accepts the tool name and its arguments object; returns the tool's native response.",
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: {
-                        type: 'string',
-                        description: 'The tool name to execute (from search_tools or describe_tool results)',
-                    },
-                    args: {
-                        type: 'object',
-                        description: 'Arguments object to pass to the tool',
-                        additionalProperties: true,
-                    },
-                },
-                required: ['name'],
-            },
-            handler: handleCallTool,
-        },
-    ];
-}
-export function registerSearchMetaTools(ctx) {
-    const defs = buildMetaToolDefinitions(ctx);
-    for (const def of defs) {
-        const shape = buildZodShape(def.inputSchema);
-        ctx.server.registerTool(def.name, {
-            description: def.description,
-            inputSchema: shape,
-        }, async (args) => {
-            try {
-                return await def.handler(ctx, args);
-            }
-            catch (error) {
-                logger.error(`${def.name} failed`, error);
-                return asErrorResponse(error);
-            }
-        });
-        ctx.metaToolsByName.set(def.name, {
-            name: def.name,
-            description: def.description.split('\n')[0] || def.description,
-            inputSchema: def.inputSchema,
-        });
-    }
-}

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

@@ -1,5 +0,0 @@
-export declare function normalizeToolName(name: string): string;
-export declare function validateToolNameArray(args: Record<string, unknown>): {
-    names: string[];
-    error?: string;
-};

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

@@ -1,25 +0,0 @@
-export function normalizeToolName(name) {
-    const trimmed = name.trim();
-    if (!trimmed.startsWith('mcp__')) {
-        return trimmed;
-    }
-    const parts = trimmed.split('__');
-    if (parts.length < 3) {
-        return trimmed;
-    }
-    return parts.slice(2).join('__');
-}
-export function validateToolNameArray(args) {
-    const raw = args.names;
-    if (!Array.isArray(raw)) {
-        return { names: [], error: 'names must be an array' };
-    }
-    const names = [];
-    for (const item of raw) {
-        if (typeof item !== 'string' || item.trim().length === 0) {
-            return { names: [], error: 'invalid tool name: expected non-empty string' };
-        }
-        names.push(normalizeToolName(item));
-    }
-    return { names };
-}

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

@@ -1,4 +0,0 @@
-import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-export declare function registerSingleTool(ctx: MCPServerContext, toolDef: Tool): RegisteredTool;

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

@@ -1,37 +0,0 @@
-import {} from 'zod';
-import { logger } from '../utils/logger.js';
-import { asErrorResponse, toolErrorToResponse } from './domains/shared/response.js';
-import { ToolError } from '../errors/ToolError.js';
-import { buildZodShape } from './MCPServer.schema.js';
-function handleToolError(toolName, error) {
-    if (error instanceof ToolError) {
-        return toolErrorToResponse(error);
-    }
-    logger.error(`Tool execution failed: ${toolName}`, error);
-    return asErrorResponse(error);
-}
-export function registerSingleTool(ctx, toolDef) {
-    const rawSchema = toolDef.inputSchema;
-    const shape = rawSchema && typeof rawSchema === 'object'
-        ? buildZodShape(rawSchema)
-        : {};
-    const description = toolDef.description ?? toolDef.name;
-    if (Object.keys(shape).length > 0) {
-        return ctx.server.registerTool(toolDef.name, { description, inputSchema: shape }, async (args) => {
-            try {
-                return await ctx.executeToolWithTracking(toolDef.name, args);
-            }
-            catch (error) {
-                return handleToolError(toolDef.name, error);
-            }
-        });
-    }
-    return ctx.server.registerTool(toolDef.name, { description }, async () => {
-        try {
-            return await ctx.executeToolWithTracking(toolDef.name, {});
-        }
-        catch (error) {
-            return handleToolError(toolDef.name, error);
-        }
-    });
-}

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

@@ -1,4 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-export declare function startStdioTransport(ctx: MCPServerContext): Promise<void>;
-export declare function startHttpTransport(ctx: MCPServerContext): Promise<void>;
-export declare function closeServer(ctx: MCPServerContext): Promise<void>;

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

@@ -1,187 +0,0 @@
-import { createServer } from 'node:http';
-import { randomUUID } from 'node:crypto';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { MCP_HTTP_REQUEST_TIMEOUT_MS, MCP_HTTP_HEADERS_TIMEOUT_MS, MCP_HTTP_KEEPALIVE_TIMEOUT_MS, MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS, } from '../constants.js';
-import { checkAuth, checkOrigin, checkRateLimit, readBodyWithLimit, } from './http/HttpMiddleware.js';
-import { logger } from '../utils/logger.js';
-export async function startStdioTransport(ctx) {
-    const transport = new StdioServerTransport();
-    await ctx.server.connect(transport);
-    let shuttingDown = false;
-    const gracefulExit = async () => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        logger.info('stdin closed — parent process gone, shutting down...');
-        try {
-            await closeServer(ctx);
-        }
-        catch {
-        }
-        process.exit(0);
-    };
-    process.stdin.on('end', gracefulExit);
-    process.stdin.on('close', gracefulExit);
-    process.stdout.on('error', (err) => {
-        if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') {
-            logger.info(`stdout error (${err.code}) — shutting down`);
-            closeServer(ctx)
-                .catch(() => { })
-                .finally(() => process.exit(0));
-        }
-    });
-    logger.success('MCP stdio server started');
-}
-export async function startHttpTransport(ctx) {
-    const port = parseInt(process.env.MCP_PORT ?? '3000', 10);
-    const host = process.env.MCP_HOST ?? '127.0.0.1';
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-    });
-    await ctx.server.connect(transport);
-    ctx.httpServer = createServer((req, res) => {
-        const url = new URL(req.url ?? '/', `http://localhost:${port}`);
-        if (url.pathname === '/health' && req.method === 'GET') {
-            handleHealthCheck(ctx, res);
-            return;
-        }
-        if (url.pathname !== '/mcp') {
-            res.writeHead(404, { 'Content-Type': 'text/plain' });
-            res.end('Not Found – use POST /mcp or GET /health');
-            return;
-        }
-        if (!checkOrigin(req, res))
-            return;
-        const authenticated = checkAuth(req, res);
-        if (!authenticated)
-            return;
-        if (!checkRateLimit(req, res, authenticated))
-            return;
-        if (req.method === 'GET' || req.method === 'DELETE') {
-            void transport.handleRequest(req, res);
-            return;
-        }
-        if (req.method === 'POST') {
-            readBodyWithLimit(req, res)
-                .then((body) => transport.handleRequest(req, res, body))
-                .catch(() => {
-            });
-            return;
-        }
-        res.writeHead(405, { 'Content-Type': 'text/plain' });
-        res.end('Method Not Allowed');
-    });
-    const httpServer = ctx.httpServer;
-    if (!httpServer) {
-        throw new Error('HTTP server initialization failed');
-    }
-    httpServer.requestTimeout = MCP_HTTP_REQUEST_TIMEOUT_MS;
-    httpServer.headersTimeout = MCP_HTTP_HEADERS_TIMEOUT_MS;
-    httpServer.keepAliveTimeout = MCP_HTTP_KEEPALIVE_TIMEOUT_MS;
-    httpServer.on('connection', (socket) => {
-        ctx.httpSockets.add(socket);
-        socket.on('close', () => ctx.httpSockets.delete(socket));
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.listen(port, host, () => {
-            logger.success(`MCP Streamable HTTP server listening on http://${host}:${port}/mcp`);
-            resolve();
-        });
-        httpServer.on('error', reject);
-    });
-}
-function handleHealthCheck(ctx, res) {
-    const verbose = ['1', 'true'].includes((process.env.MCP_HEALTH_VERBOSE ?? '').toLowerCase());
-    const body = {
-        status: 'ok',
-        uptime: process.uptime(),
-    };
-    if (verbose) {
-        const budgetStats = ctx.tokenBudget.getStats();
-        body.tier = ctx.baseTier;
-        body.baseTier = ctx.baseTier;
-        body.enabledDomains = [...ctx.enabledDomains];
-        body.registeredTools = ctx.selectedTools.length;
-        body.activatedTools = ctx.activatedToolNames.size;
-        body.tokenBudget = {
-            usagePercentage: budgetStats.usagePercentage,
-            currentUsage: budgetStats.currentUsage,
-            maxTokens: budgetStats.maxTokens,
-        };
-    }
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(body));
-}
-export async function closeServer(ctx) {
-    for (const [, entry] of ctx.domainTtlEntries) {
-        clearTimeout(entry.timer);
-    }
-    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()));
-        const forceTimeout = setTimeout(() => {
-            for (const socket of ctx.httpSockets) {
-                socket.destroy();
-            }
-        }, MCP_HTTP_FORCE_CLOSE_TIMEOUT_MS);
-        await closePromise;
-        clearTimeout(forceTimeout);
-        ctx.httpSockets.clear();
-        ctx.httpServer = undefined;
-    }
-    const closables = [
-        ['consoleMonitor', ctx.consoleMonitor, 'disable'],
-        ['runtimeInspector', ctx.runtimeInspector, 'close'],
-        ['debuggerManager', ctx.debuggerManager, 'close'],
-        ['scriptManager', ctx.scriptManager, 'close'],
-        ['transformHandlers', ctx.transformHandlers, 'close'],
-    ];
-    for (const [name, instance, method] of closables) {
-        if (!instance)
-            continue;
-        try {
-            const closeFn = instance[method];
-            if (typeof closeFn === 'function') {
-                await closeFn.call(instance);
-            }
-        }
-        catch (error) {
-            logger.warn(`${name} cleanup failed:`, error);
-        }
-    }
-    ctx.consoleMonitor = undefined;
-    ctx.runtimeInspector = undefined;
-    ctx.debuggerManager = undefined;
-    ctx.scriptManager = undefined;
-    if (ctx.collector) {
-        try {
-            await ctx.collector.close();
-        }
-        catch (error) {
-            logger.warn('collector cleanup failed:', error);
-        }
-        ctx.collector = undefined;
-    }
-    try {
-        await ctx.server.close();
-    }
-    catch (error) {
-        logger.warn('MCP server close failed:', error);
-    }
-    logger.success('MCP server closed');
-}

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

@@ -1,25 +0,0 @@
-interface TabContextProvider {
-    getContextMeta(): {
-        url: string | null;
-        title: string | null;
-        tabIndex: number | null;
-        pageId: string | null;
-    };
-}
-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 {};