@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/src/server/MCPServer.js

@@ -10,12 +10,13 @@ import { ToolCallContextGuard } from './ToolCallContextGuard.js';
 import { createToolHandlerMap } from './ToolHandlerMap.js';
 import { resolveToolsForRegistration } from './MCPServer.registration.js';
 import { createDomainProxy, resolveEnabledDomains } from './MCPServer.domain.js';
-import { boostProfile as boostProfileImpl, refreshBoostTtl, switchToTier as switchToTierImpl, unboostProfile as unboostProfileImpl, } from './MCPServer.boost.js';
+import { refreshDomainTtlForTool } from './MCPServer.activation.ttl.js';
 import { closeServer, startHttpTransport, startStdioTransport, } from './MCPServer.transport.js';
-import { registerMetaTools, registerSingleTool as registerSingleToolImpl, } from './MCPServer.tools.js';
+import { registerSingleTool as registerSingleToolImpl, } from './MCPServer.tools.js';
 import { registerSearchMetaTools } from './MCPServer.search.js';
 import { ALL_MANIFESTS } from './registry/index.js';
 import { listExtensions as listExtensionsImpl, reloadExtensions as reloadExtensionsImpl } from './extensions/ExtensionManager.js';
+import { DomainInstanceRegistry } from './DomainInstanceRegistry.js';
 export class MCPServer {
     config;
     server;
@@ -32,17 +33,9 @@ export class MCPServer {
     cacheAdaptersRegistered = false;
     cacheRegistrationPromise;
     baseTier;
-    currentTier;
-    boostHistory = [];
-    boostedToolNames = new Set();
-    boostedRegisteredTools = new Map();
-    boostTtlTimer = null;
-    boostTtlMinutes = 0;
-    boostLock = Promise.resolve();
     activatedToolNames = new Set();
     activatedRegisteredTools = new Map();
-    absorbedFromActivated = new Set();
-    boostedExtensionToolNames = new Set();
+    domainTtlEntries = new Map();
     extensionToolsByName = new Map();
     extensionPluginsById = new Map();
     extensionPluginRuntimeById = new Map();
@@ -51,50 +44,84 @@ export class MCPServer {
     lastExtensionReloadAt;
     httpServer;
     httpSockets = new Set();
-    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;
+    domainInstances;
+    get collector() { return this.domainInstances.collector; }
+    set collector(v) { this.domainInstances.collector = v; }
+    get pageController() { return this.domainInstances.pageController; }
+    set pageController(v) { this.domainInstances.pageController = v; }
+    get domInspector() { return this.domainInstances.domInspector; }
+    set domInspector(v) { this.domainInstances.domInspector = v; }
+    get scriptManager() { return this.domainInstances.scriptManager; }
+    set scriptManager(v) { this.domainInstances.scriptManager = v; }
+    get debuggerManager() { return this.domainInstances.debuggerManager; }
+    set debuggerManager(v) { this.domainInstances.debuggerManager = v; }
+    get runtimeInspector() { return this.domainInstances.runtimeInspector; }
+    set runtimeInspector(v) { this.domainInstances.runtimeInspector = v; }
+    get consoleMonitor() { return this.domainInstances.consoleMonitor; }
+    set consoleMonitor(v) { this.domainInstances.consoleMonitor = v; }
+    get llm() { return this.domainInstances.llm; }
+    set llm(v) { this.domainInstances.llm = v; }
+    get browserHandlers() { return this.domainInstances.browserHandlers; }
+    set browserHandlers(v) { this.domainInstances.browserHandlers = v; }
+    get debuggerHandlers() { return this.domainInstances.debuggerHandlers; }
+    set debuggerHandlers(v) { this.domainInstances.debuggerHandlers = v; }
+    get advancedHandlers() { return this.domainInstances.advancedHandlers; }
+    set advancedHandlers(v) { this.domainInstances.advancedHandlers = v; }
+    get aiHookHandlers() { return this.domainInstances.aiHookHandlers; }
+    set aiHookHandlers(v) { this.domainInstances.aiHookHandlers = v; }
+    get hookPresetHandlers() { return this.domainInstances.hookPresetHandlers; }
+    set hookPresetHandlers(v) { this.domainInstances.hookPresetHandlers = v; }
+    get deobfuscator() { return this.domainInstances.deobfuscator; }
+    set deobfuscator(v) { this.domainInstances.deobfuscator = v; }
+    get advancedDeobfuscator() { return this.domainInstances.advancedDeobfuscator; }
+    set advancedDeobfuscator(v) { this.domainInstances.advancedDeobfuscator = v; }
+    get astOptimizer() { return this.domainInstances.astOptimizer; }
+    set astOptimizer(v) { this.domainInstances.astOptimizer = v; }
+    get obfuscationDetector() { return this.domainInstances.obfuscationDetector; }
+    set obfuscationDetector(v) { this.domainInstances.obfuscationDetector = v; }
+    get analyzer() { return this.domainInstances.analyzer; }
+    set analyzer(v) { this.domainInstances.analyzer = v; }
+    get cryptoDetector() { return this.domainInstances.cryptoDetector; }
+    set cryptoDetector(v) { this.domainInstances.cryptoDetector = v; }
+    get hookManager() { return this.domainInstances.hookManager; }
+    set hookManager(v) { this.domainInstances.hookManager = v; }
+    get coreAnalysisHandlers() { return this.domainInstances.coreAnalysisHandlers; }
+    set coreAnalysisHandlers(v) { this.domainInstances.coreAnalysisHandlers = v; }
+    get coreMaintenanceHandlers() { return this.domainInstances.coreMaintenanceHandlers; }
+    set coreMaintenanceHandlers(v) { this.domainInstances.coreMaintenanceHandlers = v; }
+    get extensionManagementHandlers() { return this.domainInstances.extensionManagementHandlers; }
+    set extensionManagementHandlers(v) { this.domainInstances.extensionManagementHandlers = v; }
+    get processHandlers() { return this.domainInstances.processHandlers; }
+    set processHandlers(v) { this.domainInstances.processHandlers = v; }
+    get workflowHandlers() { return this.domainInstances.workflowHandlers; }
+    set workflowHandlers(v) { this.domainInstances.workflowHandlers = v; }
+    get wasmHandlers() { return this.domainInstances.wasmHandlers; }
+    set wasmHandlers(v) { this.domainInstances.wasmHandlers = v; }
+    get streamingHandlers() { return this.domainInstances.streamingHandlers; }
+    set streamingHandlers(v) { this.domainInstances.streamingHandlers = v; }
+    get encodingHandlers() { return this.domainInstances.encodingHandlers; }
+    set encodingHandlers(v) { this.domainInstances.encodingHandlers = v; }
+    get antidebugHandlers() { return this.domainInstances.antidebugHandlers; }
+    set antidebugHandlers(v) { this.domainInstances.antidebugHandlers = v; }
+    get graphqlHandlers() { return this.domainInstances.graphqlHandlers; }
+    set graphqlHandlers(v) { this.domainInstances.graphqlHandlers = v; }
+    get platformHandlers() { return this.domainInstances.platformHandlers; }
+    set platformHandlers(v) { this.domainInstances.platformHandlers = v; }
+    get sourcemapHandlers() { return this.domainInstances.sourcemapHandlers; }
+    set sourcemapHandlers(v) { this.domainInstances.sourcemapHandlers = v; }
+    get transformHandlers() { return this.domainInstances.transformHandlers; }
+    set transformHandlers(v) { this.domainInstances.transformHandlers = v; }
     constructor(config) {
         this.config = config;
         this.cache = new CacheManager(config.cache);
         this.tokenBudget = new TokenBudgetManager();
         this.unifiedCache = new UnifiedCacheManager();
         this.detailedData = new DetailedDataManager();
+        this.domainInstances = new DomainInstanceRegistry();
         this.tokenBudget.setExternalCleanup(() => this.detailedData.clear());
         const { tools, profile } = resolveToolsForRegistration();
         this.selectedTools = tools;
         this.baseTier = profile;
-        this.currentTier = profile;
         this.enabledDomains = this.resolveEnabledDomains(this.selectedTools);
         const depsEntries = [];
         for (const m of ALL_MANIFESTS) {
@@ -142,15 +169,6 @@ export class MCPServer {
     registerSingleTool(toolDef) {
         return registerSingleToolImpl(this, toolDef);
     }
-    async boostProfile(target, ttlMinutes) {
-        return boostProfileImpl(this, target, ttlMinutes);
-    }
-    async unboostProfile(target) {
-        return unboostProfileImpl(this, target);
-    }
-    async switchToTier(targetTier) {
-        return switchToTierImpl(this, targetTier);
-    }
     async reloadExtensions() {
         return reloadExtensionsImpl(this);
     }
@@ -202,8 +220,8 @@ export class MCPServer {
             catch (trackingError) {
                 logger.warn('Token tracking failed, continuing without tracking this call:', trackingError);
             }
-            if (this.boostedToolNames.has(name)) {
-                refreshBoostTtl(this);
+            if (this.activatedToolNames.has(name)) {
+                refreshDomainTtlForTool(this, name);
             }
             return enriched;
         }
@@ -244,7 +262,6 @@ export class MCPServer {
         for (const toolDef of this.selectedTools) {
             this.registerSingleTool(toolDef);
         }
-        registerMetaTools(this);
         registerSearchMetaTools(this);
         logger.info(`Registered ${this.selectedTools.length} tools + meta tools with McpServer`);
     }

package/dist/src/server/MCPServer.search.handlers.activate.d.ts

@@ -1,4 +1,12 @@
 import type { MCPServerContext } from './MCPServer.context.js';
 import type { ToolResponse } from './types.js';
+interface ActivationSummary {
+    activated: string[];
+    alreadyActive: string[];
+    notFound: string[];
+    totalActive: number;
+}
+export declare function activateToolNames(ctx: MCPServerContext, names: string[]): Promise<ActivationSummary>;
 export declare function handleActivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
 export declare function handleDeactivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
+export {};

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

@@ -2,18 +2,26 @@ import { logger } from '../utils/logger.js';
 import { asTextResponse } from './domains/shared/response.js';
 import { getToolDomain } from './ToolCatalog.js';
 import { createToolHandlerMap } from './ToolHandlerMap.js';
-import { validateToolNameArray } from './MCPServer.search.validation.js';
+import { normalizeToolName, validateToolNameArray, } from './MCPServer.search.validation.js';
 import { getActiveToolNames, getToolByName, } from './MCPServer.search.helpers.js';
-export async function handleActivateTools(ctx, args) {
-    const { names, error } = validateToolNameArray(args);
-    if (error) {
-        return asTextResponse(JSON.stringify({ success: false, error }));
+async function notifyToolListChanged(ctx, changed) {
+    if (!changed) {
+        return;
+    }
+    try {
+        await ctx.server.sendToolListChanged();
+    }
+    catch (e) {
+        logger.warn('sendToolListChanged failed:', e);
     }
+}
+export async function activateToolNames(ctx, names) {
     const activeNames = getActiveToolNames(ctx);
     const activated = [];
     const alreadyActive = [];
     const notFound = [];
-    for (const name of names) {
+    for (const rawName of names) {
+        const name = normalizeToolName(rawName);
         if (activeNames.has(name)) {
             alreadyActive.push(name);
             continue;
@@ -35,7 +43,9 @@ export async function handleActivateTools(ctx, args) {
             ctx.enabledDomains.add(domain);
         }
         if (extensionRecord?.handler) {
-            ctx.router.addHandlers({ [name]: extensionRecord.handler });
+            ctx.router.addHandlers({
+                [name]: extensionRecord.handler,
+            });
         }
         else {
             const newToolNames = new Set([name]);
@@ -45,21 +55,27 @@ export async function handleActivateTools(ctx, args) {
         activated.push(name);
         activeNames.add(name);
     }
-    if (activated.length > 0) {
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed:', e);
-        }
-    }
+    await notifyToolListChanged(ctx, activated.length > 0);
     logger.info(`activate_tools: activated ${activated.length}, already_active ${alreadyActive.length}, not_found ${notFound.length}`);
-    return asTextResponse(JSON.stringify({
-        success: true,
+    return {
         activated,
         alreadyActive,
         notFound,
         totalActive: activeNames.size,
+    };
+}
+export async function handleActivateTools(ctx, args) {
+    const { names, error } = validateToolNameArray(args);
+    if (error) {
+        return asTextResponse(JSON.stringify({ success: false, error }));
+    }
+    const result = await activateToolNames(ctx, names);
+    return asTextResponse(JSON.stringify({
+        success: true,
+        ...result,
+        hint: result.activated.length > 0
+            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
+            : undefined,
     }));
 }
 export async function handleDeactivateTools(ctx, args) {
@@ -69,7 +85,8 @@ export async function handleDeactivateTools(ctx, args) {
     }
     const deactivated = [];
     const notActivated = [];
-    for (const name of names) {
+    for (const rawName of names) {
+        const name = normalizeToolName(rawName);
         if (!ctx.activatedToolNames.has(name)) {
             notActivated.push(name);
             continue;
@@ -92,14 +109,7 @@ export async function handleDeactivateTools(ctx, args) {
         }
         deactivated.push(name);
     }
-    if (deactivated.length > 0) {
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed:', e);
-        }
-    }
+    await notifyToolListChanged(ctx, deactivated.length > 0);
     logger.info(`deactivate_tools: deactivated ${deactivated.length}, not_activated ${notActivated.length}`);
     return asTextResponse(JSON.stringify({
         success: true,

package/dist/src/server/MCPServer.search.handlers.call.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { ToolResponse } from './types.js';
+export declare function handleCallTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

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

@@ -0,0 +1,86 @@
+import { logger } from '../utils/logger.js';
+import { asTextResponse } from './domains/shared/response.js';
+import { normalizeToolName } from './MCPServer.search.validation.js';
+import { getToolByName } from './MCPServer.search.helpers.js';
+import { activateToolNames } from './MCPServer.search.handlers.activate.js';
+function buildCallToolMetadata(wasAutoActivated, activatedTools) {
+    return {
+        wasAutoActivated,
+        activatedTools,
+    };
+}
+function attachCallToolMetadata(response, metadata) {
+    return {
+        ...response,
+        content: response.content.map((item) => {
+            if (item.type !== 'text' || !('text' in item) || typeof item.text !== 'string') {
+                return item;
+            }
+            try {
+                const parsed = JSON.parse(item.text);
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    return item;
+                }
+                return {
+                    ...item,
+                    text: JSON.stringify({
+                        ...parsed,
+                        ...metadata,
+                    }, null, 2),
+                };
+            }
+            catch {
+                return item;
+            }
+        }),
+    };
+}
+export async function handleCallTool(ctx, args) {
+    const rawName = typeof args.name === 'string' ? args.name : '';
+    const defaultMetadata = buildCallToolMetadata(false, []);
+    if (!rawName) {
+        return asTextResponse(JSON.stringify({
+            success: false,
+            error: 'name must be a non-empty string',
+            ...defaultMetadata,
+        }));
+    }
+    const name = normalizeToolName(rawName);
+    const toolArgs = (args.args && typeof args.args === 'object' && !Array.isArray(args.args))
+        ? args.args
+        : {};
+    let callMetadata = defaultMetadata;
+    if (!ctx.router.has(name)) {
+        const toolDef = getToolByName(ctx).get(name);
+        if (!toolDef) {
+            return asTextResponse(JSON.stringify({
+                success: false,
+                error: `Tool "${name}" not found in the catalogue. Use search_tools to discover available tools.`,
+                ...callMetadata,
+            }));
+        }
+        logger.info(`call_tool: auto-activating "${name}" (not in router)`);
+        const activation = await activateToolNames(ctx, [name]);
+        callMetadata = buildCallToolMetadata(true, activation.activated);
+        if (activation.activated.length === 0 && activation.alreadyActive.length === 0) {
+            return asTextResponse(JSON.stringify({
+                success: false,
+                error: `Tool "${name}" exists but could not be activated.`,
+                ...callMetadata,
+            }));
+        }
+    }
+    try {
+        const response = await ctx.executeToolWithTracking(name, toolArgs);
+        return attachCallToolMetadata(response, callMetadata);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`call_tool: execution of "${name}" failed`, error);
+        return asTextResponse(JSON.stringify({
+            success: false,
+            error: `Tool "${name}" failed: ${message}`,
+            ...callMetadata,
+        }));
+    }
+}

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

@@ -4,6 +4,8 @@ import { getToolsByDomains } from './ToolCatalog.js';
 import { createToolHandlerMap } from './ToolHandlerMap.js';
 import { ALL_DOMAINS } from './registry/index.js';
 import { getActiveToolNames } from './MCPServer.search.helpers.js';
+import { startDomainTtl } from './MCPServer.activation.ttl.js';
+import { ACTIVATION_TTL_MINUTES } from '../constants.js';
 export async function handleActivateDomain(ctx, args) {
     const domain = typeof args.domain === 'string' ? args.domain : '';
     if (!domain) {
@@ -19,6 +21,7 @@ export async function handleActivateDomain(ctx, args) {
             error: `Unknown domain "${domain}". Valid: ${[...validDomains].join(', ')}`,
         }));
     }
+    const ttlMinutes = typeof args.ttlMinutes === 'number' ? args.ttlMinutes : ACTIVATION_TTL_MINUTES;
     const domainTools = [
         ...getToolsByDomains([domain]),
         ...[...ctx.extensionToolsByName.values()]
@@ -52,6 +55,7 @@ export async function handleActivateDomain(ctx, args) {
                 ctx.router.addHandlers({ [name]: extRecord.handler });
             }
         }
+        startDomainTtl(ctx, domain, ttlMinutes, activated);
         try {
             await ctx.server.sendToolListChanged();
         }
@@ -59,12 +63,16 @@ export async function handleActivateDomain(ctx, args) {
             logger.warn('sendToolListChanged failed:', e);
         }
     }
-    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools`);
+    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools, ttl=${ttlMinutes}min`);
     return asTextResponse(JSON.stringify({
         success: true,
         domain,
         activated: activated.length,
         activatedTools: activated,
         totalDomainTools: domainTools.length,
+        ttlMinutes: ttlMinutes > 0 ? ttlMinutes : 'no expiry',
+        hint: activated.length > 0
+            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
+            : undefined,
     }));
 }

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

@@ -1,6 +1,19 @@
 import { asTextResponse } from './domains/shared/response.js';
-import { routeToolRequest, describeTool } from './ToolRouter.js';
+import { buildCallToolCommand, routeToolRequest, describeTool, } from './ToolRouter.js';
+import { activateToolNames } from './MCPServer.search.handlers.activate.js';
+import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
 import { getSearchEngine } from './MCPServer.search.helpers.js';
+import { ACTIVATION_TTL_MINUTES } from '../constants.js';
+function populateCallCommands(response) {
+    return {
+        ...response,
+        recommendations: response.recommendations.map((recommendation) => ({
+            ...recommendation,
+            callCommand: recommendation.callCommand
+                ?? buildCallToolCommand(recommendation.name, recommendation.inputSchema),
+        })),
+    };
+}
 export async function handleRouteTool(ctx, args) {
     const task = args.task;
     const context = args.context;
@@ -8,7 +21,55 @@ export async function handleRouteTool(ctx, args) {
         return asTextResponse(JSON.stringify({ success: false, error: 'task must be a non-empty string' }));
     }
     const engine = getSearchEngine(ctx);
-    const response = await routeToolRequest({ task, context }, ctx, engine);
+    const autoActivate = context?.autoActivate !== false;
+    let response = populateCallCommands(await routeToolRequest({ task, context }, ctx, engine));
+    if (autoActivate) {
+        const inactiveRecs = response.recommendations
+            .filter((recommendation) => !recommendation.isActive);
+        if (inactiveRecs.length > 0) {
+            const domainsToActivate = new Set();
+            const toolsWithoutDomain = [];
+            for (const rec of inactiveRecs) {
+                if (rec.domain && !ctx.enabledDomains.has(rec.domain)) {
+                    domainsToActivate.add(rec.domain);
+                }
+                else if (!rec.domain) {
+                    toolsWithoutDomain.push(rec.name);
+                }
+            }
+            let activated = false;
+            for (const domain of domainsToActivate) {
+                try {
+                    await handleActivateDomain(ctx, {
+                        domain,
+                        ttlMinutes: ACTIVATION_TTL_MINUTES,
+                    });
+                    activated = true;
+                }
+                catch {
+                }
+            }
+            const remainingInactive = inactiveRecs
+                .filter((rec) => !domainsToActivate.has(rec.domain ?? ''))
+                .map((rec) => rec.name);
+            if (remainingInactive.length > 0 || toolsWithoutDomain.length > 0) {
+                const names = [...new Set([...remainingInactive, ...toolsWithoutDomain])];
+                const activation = await activateToolNames(ctx, names);
+                if (activation.activated.length > 0) {
+                    activated = true;
+                }
+            }
+            if (activated) {
+                response = populateCallCommands(await routeToolRequest({ task, context: { ...context, autoActivate: false } }, ctx, engine));
+                response.autoActivated = true;
+                response.activatedNames = inactiveRecs.map((r) => r.name)
+                    .filter((name) => ctx.activatedToolNames.has(name));
+                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));
 }
 export async function handleDescribeTool(ctx, args) {