@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/ToolRouter.probe.js

@@ -0,0 +1,103 @@
+import { allTools, getToolDomain } from './ToolCatalog.js';
+import { normalizeToolName } from './MCPServer.search.validation.js';
+let _allToolsByName = null;
+export function getAllToolsByName() {
+    if (!_allToolsByName)
+        _allToolsByName = new Map(allTools.map((t) => [t.name, t]));
+    return _allToolsByName;
+}
+export function getToolInputSchema(toolName, ctx) {
+    const canonicalName = normalizeToolName(toolName);
+    const builtInTool = getAllToolsByName().get(canonicalName);
+    if (builtInTool) {
+        return builtInTool.inputSchema;
+    }
+    const extTool = ctx.extensionToolsByName.get(canonicalName);
+    if (extTool) {
+        return extTool.tool.inputSchema;
+    }
+    const metaTool = ctx.metaToolsByName.get(canonicalName);
+    if (metaTool) {
+        return metaTool.inputSchema;
+    }
+    return undefined;
+}
+export function getToolDescription(toolName, ctx) {
+    const canonicalName = normalizeToolName(toolName);
+    const builtInTool = getAllToolsByName().get(canonicalName);
+    if (builtInTool?.description) {
+        return builtInTool.description.split('\n')[0] || 'No description available';
+    }
+    const extTool = ctx.extensionToolsByName.get(canonicalName);
+    if (extTool?.tool?.description) {
+        return extTool.tool.description.split('\n')[0] || 'No description available';
+    }
+    const metaTool = ctx.metaToolsByName.get(canonicalName);
+    if (metaTool?.description) {
+        return metaTool.description.split('\n')[0] || 'No description available';
+    }
+    return 'No description available';
+}
+export function isToolActive(toolName, ctx) {
+    const canonicalName = normalizeToolName(toolName);
+    const activeTools = new Set([
+        ...ctx.selectedTools.map((tool) => tool.name),
+        ...ctx.activatedToolNames,
+    ]);
+    return activeTools.has(canonicalName);
+}
+export function getAvailableToolNames(ctx) {
+    return new Set([...allTools.map((tool) => tool.name), ...ctx.extensionToolsByName.keys()]);
+}
+export function getToolDomainFromContext(toolName, ctx) {
+    return getToolDomain(toolName) ?? ctx.extensionToolsByName.get(toolName)?.domain ?? null;
+}
+export async function probeActivePage(ctx) {
+    if (!ctx.pageController || typeof ctx.pageController.getPage !== 'function')
+        return false;
+    try {
+        return Boolean(await ctx.pageController.getPage());
+    }
+    catch {
+        return false;
+    }
+}
+export function probeNetworkEnabled(ctx) {
+    if (!ctx.consoleMonitor)
+        return false;
+    try {
+        if (typeof ctx.consoleMonitor.getNetworkStatus === 'function') {
+            return Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
+        }
+        if (typeof ctx.consoleMonitor.isNetworkEnabled === 'function') {
+            return Boolean(ctx.consoleMonitor.isNetworkEnabled());
+        }
+    }
+    catch {
+    }
+    return false;
+}
+export function probeCapturedRequests(ctx) {
+    if (!ctx.consoleMonitor || typeof ctx.consoleMonitor.getNetworkRequests !== 'function')
+        return 0;
+    try {
+        const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
+        return Array.isArray(requests) ? requests.length : 0;
+    }
+    catch {
+        try {
+            const requests = ctx.consoleMonitor.getNetworkRequests();
+            return Array.isArray(requests) ? requests.length : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+export async function getRoutingState(ctx) {
+    return {
+        hasActivePage: await probeActivePage(ctx),
+        networkEnabled: probeNetworkEnabled(ctx),
+        capturedRequestCount: probeCapturedRequests(ctx),
+    };
+}

package/dist/src/server/ToolRouter.renderer.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { MCPServerContext } from './MCPServer.context.js';
+export declare function generateExampleArgs(schema: Tool['inputSchema']): Record<string, unknown>;
+export declare function buildCallToolCommand(toolName: string, schema: Tool['inputSchema']): string;
+export declare function describeTool(toolName: string, ctx: MCPServerContext): {
+    name: string;
+    description: string;
+    inputSchema: Tool['inputSchema'];
+} | null;

package/dist/src/server/ToolRouter.renderer.js

@@ -0,0 +1,52 @@
+import { normalizeToolName } from './MCPServer.search.validation.js';
+import { getToolInputSchema, getToolDescription } from './ToolRouter.probe.js';
+export function generateExampleArgs(schema) {
+    if (schema?.type !== 'object' || !schema.properties) {
+        return {};
+    }
+    const example = {};
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    for (const [key, prop] of Object.entries(schema.properties)) {
+        const propSchema = prop;
+        if (!required.has(key) && propSchema.default === undefined) {
+            continue;
+        }
+        if (propSchema.default !== undefined) {
+            example[key] = propSchema.default;
+        }
+        else if (propSchema.enum && Array.isArray(propSchema.enum) && propSchema.enum.length > 0) {
+            example[key] = propSchema.enum[0];
+        }
+        else if (propSchema.type === 'string') {
+            example[key] = `<${key}>`;
+        }
+        else if (propSchema.type === 'number' || propSchema.type === 'integer') {
+            example[key] = 0;
+        }
+        else if (propSchema.type === 'boolean') {
+            example[key] = false;
+        }
+        else if (propSchema.type === 'array') {
+            example[key] = [];
+        }
+        else if (propSchema.type === 'object') {
+            example[key] = {};
+        }
+    }
+    return example;
+}
+export function buildCallToolCommand(toolName, schema) {
+    return `call_tool({ name: "${toolName}", args: ${JSON.stringify(generateExampleArgs(schema))} })`;
+}
+export function describeTool(toolName, ctx) {
+    const canonicalName = normalizeToolName(toolName);
+    const schema = getToolInputSchema(canonicalName, ctx);
+    if (!schema) {
+        return null;
+    }
+    return {
+        name: canonicalName,
+        description: getToolDescription(canonicalName, ctx),
+        inputSchema: schema,
+    };
+}

package/dist/src/server/activation/ActivationController.js

@@ -1,3 +1,4 @@
+import { handleActivateDomain } from '../MCPServer.search.handlers.domain.js';
 import { CompoundConditionEngine } from './CompoundConditionEngine.js';
 import { PredictiveBooster } from './PredictiveBooster.js';
 import { AutoPruner } from './AutoPruner.js';
@@ -62,7 +63,7 @@ export class ActivationController {
         this.ctx = ctx;
         this.cooldownMs = options.cooldownMs ?? 30_000;
         const customRules = options.boostRules ?? [];
-        this.boostRules = [...DEFAULT_BOOST_RULES, ...customRules].sort((a, b) => b.priority - a.priority);
+        this.boostRules = [...DEFAULT_BOOST_RULES, ...customRules].toSorted((a, b) => b.priority - a.priority);
         this.compoundEngine = new CompoundConditionEngine();
         this.predictiveBooster = new PredictiveBooster();
         const baseDomains = new Set(getProfileDomains(ctx.baseTier));
@@ -84,7 +85,7 @@ export class ActivationController {
             this.predictiveBooster.recordCall(payload.toolName);
             const predictedDomains = this.predictiveBooster.predictNextDomains(payload.toolName, (name) => getToolDomain(name) ?? null);
             for (const domain of predictedDomains) {
-                this.attemptBoost(domain, `predictive: ${payload.toolName} → ${domain}`);
+                void this.attemptBoost(domain, `predictive: ${payload.toolName} → ${domain}`);
             }
             this.toolCallCount++;
             if (this.toolCallCount % 5 === 0) {
@@ -93,15 +94,15 @@ export class ActivationController {
         }));
         this.unsubscribers.push(this.eventBus.on('debugger:breakpoint_hit', (payload) => {
             this.recordEvent('debugger:breakpoint_hit', payload);
-            this.evaluateBoostRules('debugger:breakpoint_hit');
+            return this.evaluateBoostRules('debugger:breakpoint_hit');
         }));
         this.unsubscribers.push(this.eventBus.on('browser:navigated', (payload) => {
             this.recordEvent('browser:navigated', payload);
-            this.evaluateBoostRules('browser:navigated');
+            return this.evaluateBoostRules('browser:navigated');
         }));
         this.unsubscribers.push(this.eventBus.on('memory:scan_completed', (payload) => {
             this.recordEvent('memory:scan_completed', payload);
-            this.evaluateBoostRules('memory:scan_completed');
+            return this.evaluateBoostRules('memory:scan_completed');
         }));
     }
     recordEvent(event, payload) {
@@ -110,7 +111,7 @@ export class ActivationController {
             this.eventHistory.splice(0, this.eventHistory.length - this.maxEventHistory);
         }
     }
-    evaluateBoostRules(eventName) {
+    async evaluateBoostRules(eventName) {
         const now = Date.now();
         for (const rule of this.boostRules) {
             if (!eventName.startsWith(rule.eventPattern))
@@ -118,13 +119,11 @@ export class ActivationController {
             const windowStart = now - rule.windowMs;
             const matchCount = this.eventHistory.filter((e) => e.event.startsWith(rule.eventPattern) && e.timestamp >= windowStart).length;
             if (matchCount >= rule.threshold) {
-                for (const domain of rule.targetDomains) {
-                    this.attemptBoost(domain, `rule:${rule.eventPattern} (${matchCount} events)`);
-                }
+                await Promise.all(rule.targetDomains.map((domain) => this.attemptBoost(domain, `rule:${rule.eventPattern} (${matchCount} events)`)));
             }
         }
     }
-    attemptBoost(domain, reason) {
+    async attemptBoost(domain, reason) {
         if (this.disposed)
             return;
         const now = Date.now();
@@ -137,7 +136,11 @@ export class ActivationController {
         }
         this.lastBoostTime.set(domain, now);
         logger.info(`[ActivationController] Boosting domain "${domain}" — reason: ${reason}`);
-        void this.eventBus.emit('activation:domain_boosted', {
+        await handleActivateDomain(this.ctx, {
+            domain,
+            ttlMinutes: 30,
+        });
+        await this.eventBus.emit('activation:domain_boosted', {
             domain,
             reason,
             timestamp: new Date().toISOString(),
@@ -154,7 +157,7 @@ export class ActivationController {
         };
         const domainsToBoost = this.compoundEngine.evaluate(state);
         for (const domain of domainsToBoost) {
-            this.attemptBoost(domain, `compound condition`);
+            void this.attemptBoost(domain, `compound condition`);
         }
     }
     getLastActivity(domain) {

package/dist/src/server/activation/CompoundConditionEngine.js

@@ -34,7 +34,7 @@ const DEFAULT_COMPOUND_CONDITIONS = [
 export class CompoundConditionEngine {
     conditions;
     constructor(customConditions = []) {
-        this.conditions = [...DEFAULT_COMPOUND_CONDITIONS, ...customConditions].sort((a, b) => b.priority - a.priority);
+        this.conditions = [...DEFAULT_COMPOUND_CONDITIONS, ...customConditions].toSorted((a, b) => b.priority - a.priority);
     }
     evaluate(state) {
         const domainsToBoost = new Set();

package/dist/src/server/activation/PredictiveBooster.js

@@ -8,9 +8,7 @@ export class PredictiveBooster {
         this.confidenceThreshold = confidenceThreshold;
     }
     recordCall(toolName) {
-        const previous = this.callHistory.length > 0
-            ? this.callHistory[this.callHistory.length - 1]
-            : null;
+        const previous = this.callHistory.length > 0 ? this.callHistory[this.callHistory.length - 1] : null;
         this.callHistory.push(toolName);
         if (this.callHistory.length > this.maxHistory) {
             this.callHistory.splice(0, this.callHistory.length - this.maxHistory);