@jshookmcp/jshook 0.2.6 → 0.2.8

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

@@ -1,192 +0,0 @@
-import { McpServer, type RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Server } from 'node:http';
-import type { Socket } from 'node:net';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { Config } from '../types/index.js';
-import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
-import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
-import { DetailedDataManager } from '../utils/DetailedDataManager.js';
-import type { ToolProfile } from './ToolCatalog.js';
-import { ToolExecutionRouter } from './ToolExecutionRouter.js';
-import { ToolCallContextGuard } from './ToolCallContextGuard.js';
-import type { ToolArgs } from './types.js';
-import type { DomainTtlEntry } from './MCPServer.activation.ttl.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-import { type EventBus, type ServerEventMap } from './EventBus.js';
-import type { ToolHandlerDeps } from './registry/contracts.js';
-import type { ExtensionListResult, ExtensionPluginRecord, ExtensionPluginRuntimeRecord, ExtensionReloadResult, ExtensionToolRecord, ExtensionWorkflowRecord, ExtensionWorkflowRuntimeRecord } from './extensions/types.js';
-export declare class MCPServer implements MCPServerContext {
-    readonly config: Config;
-    readonly server: McpServer;
-    private readonly cache;
-    readonly tokenBudget: TokenBudgetManager;
-    readonly unifiedCache: UnifiedCacheManager;
-    readonly detailedData: DetailedDataManager;
-    readonly eventBus: EventBus<ServerEventMap>;
-    readonly selectedTools: Tool[];
-    enabledDomains: Set<string>;
-    readonly router: ToolExecutionRouter;
-    readonly contextGuard: ToolCallContextGuard;
-    readonly handlerDeps: ToolHandlerDeps;
-    private degradedMode;
-    private cacheAdaptersRegistered;
-    private cacheRegistrationPromise?;
-    readonly baseTier: ToolProfile;
-    readonly activatedToolNames: Set<string>;
-    readonly activatedRegisteredTools: Map<string, RegisteredTool>;
-    readonly domainTtlEntries: Map<string, DomainTtlEntry>;
-    readonly metaToolsByName: Map<string, import("./MCPServer.context.js").MetaToolInfo>;
-    clientSupportsListChanged: boolean;
-    readonly extensionToolsByName: Map<string, ExtensionToolRecord>;
-    readonly extensionPluginsById: Map<string, ExtensionPluginRecord>;
-    readonly extensionPluginRuntimeById: Map<string, ExtensionPluginRuntimeRecord>;
-    readonly extensionWorkflowsById: Map<string, ExtensionWorkflowRecord>;
-    readonly extensionWorkflowRuntimeById: Map<string, ExtensionWorkflowRuntimeRecord>;
-    lastExtensionReloadAt?: string;
-    httpServer?: Server;
-    readonly httpSockets: Set<Socket>;
-    readonly domainInstanceMap: Map<string, unknown>;
-    getDomainInstance<T>(key: string): T | undefined;
-    setDomainInstance(key: string, value: unknown): void;
-    collector: import('../modules/collector/CodeCollector.js').CodeCollector | undefined;
-    pageController: import('../modules/collector/PageController.js').PageController | undefined;
-    domInspector: import('../modules/collector/DOMInspector.js').DOMInspector | undefined;
-    scriptManager: import('../modules/debugger/ScriptManager.js').ScriptManager | undefined;
-    debuggerManager: import('../modules/debugger/DebuggerManager.js').DebuggerManager | undefined;
-    runtimeInspector: import('../modules/debugger/RuntimeInspector.js').RuntimeInspector | undefined;
-    consoleMonitor: import('../modules/monitor/ConsoleMonitor.js').ConsoleMonitor | 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;
-    aiHookHandlers: import('./domains/hooks/index.js').AIHookToolHandlers | undefined;
-    hookPresetHandlers: import('./domains/hooks/index.js').HookPresetToolHandlers | undefined;
-    deobfuscator: import('../modules/deobfuscator/Deobfuscator.js').Deobfuscator | undefined;
-    advancedDeobfuscator: import('../modules/deobfuscator/AdvancedDeobfuscator.js').AdvancedDeobfuscator | undefined;
-    astOptimizer: import('../modules/deobfuscator/ASTOptimizer.js').ASTOptimizer | undefined;
-    obfuscationDetector: import('../modules/detector/ObfuscationDetector.js').ObfuscationDetector | undefined;
-    analyzer: import('../modules/analyzer/CodeAnalyzer.js').CodeAnalyzer | undefined;
-    cryptoDetector: import('../modules/crypto/CryptoDetector.js').CryptoDetector | undefined;
-    hookManager: import('../modules/hook/HookManager.js').HookManager | undefined;
-    coreAnalysisHandlers: import('./domains/analysis/index.js').CoreAnalysisHandlers | undefined;
-    coreMaintenanceHandlers: import('./domains/maintenance/index.js').CoreMaintenanceHandlers | undefined;
-    extensionManagementHandlers: import('./domains/maintenance/index.js').ExtensionManagementHandlers | undefined;
-    processHandlers: import('./domains/process/index.js').ProcessToolHandlers | undefined;
-    workflowHandlers: import('./domains/workflow/index.js').WorkflowHandlers | undefined;
-    wasmHandlers: import('./domains/wasm/index.js').WasmToolHandlers | undefined;
-    streamingHandlers: import('./domains/streaming/index.js').StreamingToolHandlers | undefined;
-    encodingHandlers: import('./domains/encoding/index.js').EncodingToolHandlers | undefined;
-    antidebugHandlers: import('./domains/antidebug/index.js').AntiDebugToolHandlers | undefined;
-    graphqlHandlers: import('./domains/graphql/index.js').GraphQLToolHandlers | undefined;
-    platformHandlers: import('./domains/platform/index.js').PlatformToolHandlers | undefined;
-    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;
-    reloadExtensions(): Promise<ExtensionReloadResult>;
-    listExtensions(): ExtensionListResult;
-    registerCaches(): Promise<void>;
-    executeToolWithTracking(name: string, args: ToolArgs): Promise<{
-        [x: string]: unknown;
-        content: ({
-            type: "text";
-            text: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            type: "image";
-            data: string;
-            mimeType: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            type: "audio";
-            data: string;
-            mimeType: string;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        } | {
-            uri: string;
-            name: string;
-            type: "resource_link";
-            description?: string | undefined;
-            mimeType?: string | undefined;
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        } | {
-            type: "resource";
-            resource: {
-                uri: string;
-                text: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: unknown;
-                } | undefined;
-            } | {
-                uri: string;
-                blob: string;
-                mimeType?: string | undefined;
-                _meta?: {
-                    [x: string]: unknown;
-                } | undefined;
-            };
-            annotations?: {
-                audience?: ("user" | "assistant")[] | undefined;
-                priority?: number | undefined;
-                lastModified?: string | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-        })[];
-        _meta?: {
-            [x: string]: unknown;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-        structuredContent?: {
-            [x: string]: unknown;
-        } | undefined;
-        isError?: boolean | undefined;
-    }>;
-    enterDegradedMode(reason: string): void;
-    start(): Promise<void>;
-    close(): Promise<void>;
-    private registerTools;
-}

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

@@ -1,4 +0,0 @@
-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 | Promise<T>): T;

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

@@ -1,106 +0,0 @@
-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) {
-        const domain = getToolDomain(tool.name);
-        if (domain) {
-            domains.add(domain);
-        }
-    }
-    return domains;
-}
-export function createDomainProxy(ctx, domain, label, factory) {
-    const errorDetails = { domain, label };
-    let initPromise;
-    let instance;
-    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: errorDetails });
-                };
-            }
-            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);
-            }
-            return bindPropertyValue(created, prop);
-        },
-    });
-}

package/dist/src/server/MCPServer.js

@@ -1,273 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { logger } from '../utils/logger.js';
-import { CacheManager } from '../utils/cache.js';
-import { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
-import { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
-import { DetailedDataManager } from '../utils/DetailedDataManager.js';
-import { asErrorResponse } from './domains/shared/response.js';
-import { getToolDomain } from './ToolCatalog.js';
-import { ToolExecutionRouter } from './ToolExecutionRouter.js';
-import { ToolCallContextGuard } from './ToolCallContextGuard.js';
-import { createToolHandlerMap } from './ToolHandlerMap.js';
-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';
-export class MCPServer {
-    config;
-    server;
-    cache;
-    tokenBudget;
-    unifiedCache;
-    detailedData;
-    eventBus;
-    selectedTools;
-    enabledDomains;
-    router;
-    contextGuard;
-    handlerDeps;
-    degradedMode = false;
-    cacheAdaptersRegistered = false;
-    cacheRegistrationPromise;
-    baseTier;
-    activatedToolNames = new Set();
-    activatedRegisteredTools = new Map();
-    domainTtlEntries = new Map();
-    metaToolsByName = new Map();
-    clientSupportsListChanged = true;
-    extensionToolsByName = new Map();
-    extensionPluginsById = new Map();
-    extensionPluginRuntimeById = new Map();
-    extensionWorkflowsById = new Map();
-    extensionWorkflowRuntimeById = new Map();
-    lastExtensionReloadAt;
-    httpServer;
-    httpSockets = new Set();
-    domainInstanceMap = new Map();
-    getDomainInstance(key) {
-        return this.domainInstanceMap.get(key);
-    }
-    setDomainInstance(key, value) {
-        this.domainInstanceMap.set(key, value);
-    }
-    constructor(config) {
-        this.config = config;
-        this.cache = new CacheManager(config.cache);
-        this.tokenBudget = new TokenBudgetManager();
-        this.unifiedCache = new UnifiedCacheManager();
-        this.detailedData = new DetailedDataManager();
-        this.eventBus = createServerEventBus();
-        this.tokenBudget.setExternalCleanup(() => this.detailedData.clear());
-        const { tools, profile } = resolveToolsForRegistration();
-        this.selectedTools = tools;
-        this.baseTier = profile;
-        this.enabledDomains = this.resolveEnabledDomains(this.selectedTools);
-        const depsEntries = [];
-        const manifests = getAllManifests();
-        for (const m of manifests) {
-            depsEntries.push([
-                m.depKey,
-                createDomainProxy(this, m.domain, `${m.domain}:${m.depKey}`, () => m.ensure(this)),
-            ]);
-        }
-        for (const m of manifests) {
-            if (m.secondaryDepKeys) {
-                for (const key of m.secondaryDepKeys) {
-                    if (!depsEntries.some(([k]) => k === key)) {
-                        depsEntries.push([
-                            key,
-                            createDomainProxy(this, m.domain, `${m.domain}:${key}`, async () => {
-                                await m.ensure(this);
-                                return this[key];
-                            }),
-                        ]);
-                    }
-                }
-            }
-        }
-        this.handlerDeps = Object.fromEntries(depsEntries);
-        const selectedToolNames = new Set(this.selectedTools.map((t) => t.name));
-        this.router = new ToolExecutionRouter(createToolHandlerMap(this.handlerDeps, selectedToolNames));
-        this.contextGuard = new ToolCallContextGuard(() => {
-            const bh = this.handlerDeps.browserHandlers;
-            if (bh && typeof bh.getTabRegistry === 'function') {
-                return bh.getTabRegistry();
-            }
-            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) {
-        return resolveEnabledDomains(tools);
-    }
-    registerSingleTool(toolDef) {
-        return registerSingleToolImpl(this, toolDef);
-    }
-    async reloadExtensions() {
-        return reloadExtensionsImpl(this);
-    }
-    listExtensions() {
-        return listExtensionsImpl(this);
-    }
-    async registerCaches() {
-        if (this.cacheAdaptersRegistered)
-            return;
-        if (!this.collector)
-            return;
-        if (this.cacheRegistrationPromise) {
-            await this.cacheRegistrationPromise;
-            return;
-        }
-        this.cacheRegistrationPromise = (async () => {
-            try {
-                const { createCacheAdapters } = await import('../utils/CacheAdapters.js');
-                const codeCache = this.collector.getCache();
-                const codeCompressor = this.collector.getCompressor();
-                const adapters = createCacheAdapters(this.detailedData, codeCache, codeCompressor);
-                for (const adapter of adapters) {
-                    this.unifiedCache.registerCache(adapter);
-                }
-                this.cacheAdaptersRegistered = true;
-                logger.info(`Registered ${adapters.length} cache adapters.`);
-            }
-            catch (error) {
-                logger.error('Cache registration failed:', error);
-            }
-            finally {
-                this.cacheRegistrationPromise = undefined;
-            }
-        })();
-        try {
-            await this.cacheRegistrationPromise;
-        }
-        catch (error) {
-            logger.error('Cache registration failed:', error);
-        }
-    }
-    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);
-            }
-            catch (trackingError) {
-                logger.warn('Token tracking failed, continuing without tracking this call:', trackingError);
-            }
-            if (this.activatedToolNames.has(name)) {
-                refreshDomainTtlForTool(this, name);
-            }
-            void this.eventBus.emit('tool:called', {
-                toolName: name,
-                domain: getToolDomain(name) ?? null,
-                timestamp: new Date().toISOString(),
-                success: true,
-            });
-            return enriched;
-        }
-        catch (error) {
-            const errorResponse = asErrorResponse(error);
-            try {
-                this.tokenBudget.recordToolCall(name, args, errorResponse);
-            }
-            catch (trackingError) {
-                logger.warn('Token tracking failed on error path:', trackingError);
-            }
-            throw error;
-        }
-    }
-    enterDegradedMode(reason) {
-        if (this.degradedMode)
-            return;
-        this.degradedMode = true;
-        logger.warn(`Entering degraded mode: ${reason}`);
-        this.tokenBudget.setTrackingEnabled(false);
-        logger.setLevel('warn');
-    }
-    async start() {
-        await this.registerCaches();
-        await this.cache.init();
-        const transportMode = (process.env.MCP_TRANSPORT ?? 'stdio').toLowerCase();
-        if (transportMode === 'http') {
-            await startHttpTransport(this);
-        }
-        else {
-            await startStdioTransport(this);
-        }
-    }
-    async close() {
-        return closeServer(this);
-    }
-    registerTools() {
-        for (const toolDef of this.selectedTools) {
-            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',
-    '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')
-        continue;
-    Object.defineProperty(MCPServer.prototype, key, {
-        get() {
-            return this.domainInstanceMap.get(key);
-        },
-        set(v) {
-            if (v === undefined)
-                this.domainInstanceMap.delete(key);
-            else
-                this.domainInstanceMap.set(key, v);
-        },
-        enumerable: true,
-        configurable: true,
-    });
-}

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

@@ -1,6 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { type ToolProfile } from './ToolCatalog.js';
-export declare function resolveToolsForRegistration(): {
-    tools: Tool[];
-    profile: ToolProfile;
-};

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

@@ -1,27 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { getToolsByDomains, getToolsForProfile, parseToolDomains, } from './ToolCatalog.js';
-export function resolveToolsForRegistration() {
-    const transportMode = (process.env.MCP_TRANSPORT ?? 'stdio').toLowerCase();
-    const explicitProfile = (process.env.MCP_TOOL_PROFILE ?? '').trim().toLowerCase();
-    const explicitDomains = parseToolDomains(process.env.MCP_TOOL_DOMAINS);
-    if (explicitDomains && explicitDomains.length > 0) {
-        const tools = getToolsByDomains(explicitDomains);
-        logger.info(`Tool registration mode=domains [${explicitDomains.join(',')}], count=${tools.length}`);
-        const profile = explicitProfile === 'full' || explicitProfile === 'workflow' || explicitProfile === 'search'
-            ? explicitProfile
-            : 'search';
-        return { tools, profile };
-    }
-    let profile;
-    if (explicitProfile === 'full' ||
-        explicitProfile === 'workflow' ||
-        explicitProfile === 'search') {
-        profile = explicitProfile;
-    }
-    else {
-        profile = 'search';
-    }
-    const tools = getToolsForProfile(profile);
-    logger.info(`Tool registration mode=${profile}, transport=${transportMode}, count=${tools.length}`);
-    return { tools, profile };
-}

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

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