@jshookmcp/jshook 0.2.3 → 0.2.5

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

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

package/dist/src/server/MCPServer.js

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

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

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

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

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

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

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

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

@@ -65,7 +65,7 @@ export function buildDomainDescription(ctx) {
     }
     const totalTools = getAllRegistrations().length + ctx.extensionToolsByName.size;
     const parts = Object.entries(groups)
-        .sort((a, b) => b[1] - a[1])
+        .toSorted((a, b) => b[1] - a[1])
         .map(([domain, count]) => `${domain} (${count})`)
         .join(' | ');
     return (`Search ${totalTools} tools across ${Object.keys(groups).length} capability domains. ` +

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

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

package/dist/src/server/ToolCallContextGuard.js

@@ -11,6 +11,11 @@ const CONTEXT_SENSITIVE_PREFIXES = [
     'js_heap_',
     'script_',
     'captcha_',
+    'ai_hook_',
+    'instrumentation_',
+    'hook_preset_',
+    'ws_',
+    'evidence_',
 ];
 const MAX_CONSECUTIVE_REPEATS = 3;
 const REPEAT_GUARD_EXCLUDES = new Set([
@@ -28,6 +33,9 @@ const DOMAIN_ALTERNATIVES = new Map([
     ['console', ['page_evaluate', 'page_screenshot']],
     ['network', ['network_get_requests', 'page_navigate']],
     ['captcha', ['captcha_wait', 'page_screenshot']],
+    ['ai_hook', ['manage_hooks', 'page_evaluate', 'ai_hook_inject']],
+    ['instrumentation', ['instrumentation_session_list', 'instrumentation_artifact_query']],
+    ['evidence', ['evidence_query_url', 'evidence_chain']],
 ]);
 export class ToolCallContextGuard {
     getProvider;

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

@@ -1,6 +1,10 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { MCPServerContext } from './MCPServer.context.js';
 import { type ToolSearchEngine } from './ToolSearch.js';
+import type { WorkflowRule, RoutedWorkflowMatch } from './ToolRouter.intent.js';
+import type { RoutingState } from './ToolRouter.probe.js';
+export type { WorkflowRule, RoutedWorkflowMatch };
+export type { RoutingState };
+import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
 export interface RouterRequest {
     task: string;
     context?: {
@@ -34,15 +38,27 @@ export interface RouterResponse {
         description: string;
     }>;
     workflowHint?: string;
+    routeMatch?: {
+        kind: WorkflowRouteMetadata['kind'];
+        id: string;
+        name: string;
+        description: string;
+        confidence: number;
+        matchedPattern: string;
+        requiredDomains: string[];
+        steps: Array<{
+            id: string;
+            toolName: string;
+            domain: string | null;
+            description: string;
+            prerequisites: string[];
+            parallel?: boolean;
+            isActive: boolean;
+        }>;
+    };
     autoActivated?: boolean;
     activatedNames?: string[];
     callToolHint?: string;
 }
-export declare function routeToolRequest(request: RouterRequest, ctx: MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
-export declare function buildCallToolCommand(toolName: string, schema: Tool['inputSchema']): string;
-export declare function generateExampleArgs(schema: Tool['inputSchema']): Record<string, unknown>;
-export declare function describeTool(toolName: string, ctx: MCPServerContext): {
-    name: string;
-    description: string;
-    inputSchema: Tool['inputSchema'];
-} | null;
+export declare function routeToolRequest(request: RouterRequest, ctx: import('./MCPServer.context.js').MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
+export { buildCallToolCommand, describeTool, generateExampleArgs, } from './ToolRouter.renderer.js';

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

@@ -0,0 +1,26 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
+export interface WorkflowRule {
+    patterns: RegExp[];
+    domain: string;
+    priority: number;
+    tools: string[];
+    hint: string;
+}
+export interface RoutedWorkflowMatch {
+    workflow: {
+        id: string;
+        name: string;
+        description: string;
+        route: WorkflowRouteMetadata;
+    };
+    confidence: number;
+    matchedPattern: string;
+}
+export declare const BROWSER_OR_NETWORK_TASK_PATTERN: RegExp;
+export declare const MAINTENANCE_TASK_PATTERN: RegExp;
+export declare function getEffectiveWorkflowRules(): WorkflowRule[];
+export declare function detectWorkflowIntent(query: string): WorkflowRule | null;
+export declare function matchWorkflowRoute(query: string, ctx: MCPServerContext): RoutedWorkflowMatch | null;
+export declare function isBrowserOrNetworkTask(task: string, workflow: WorkflowRule | null): boolean;
+export declare function isMaintenanceTask(task: string): boolean;

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

@@ -0,0 +1,77 @@
+import { getAllManifests } from './registry/index.js';
+export const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
+export const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
+let _cachedWorkflowRules = null;
+export function getEffectiveWorkflowRules() {
+    if (_cachedWorkflowRules)
+        return _cachedWorkflowRules;
+    const rules = [];
+    for (const m of getAllManifests()) {
+        if (m.workflowRule) {
+            rules.push({
+                patterns: [...m.workflowRule.patterns],
+                domain: m.domain,
+                priority: m.workflowRule.priority,
+                tools: [...m.workflowRule.tools],
+                hint: m.workflowRule.hint,
+            });
+        }
+    }
+    _cachedWorkflowRules = [...rules].toSorted((a, b) => b.priority - a.priority);
+    return _cachedWorkflowRules;
+}
+export function detectWorkflowIntent(query) {
+    const matches = [];
+    for (const rule of getEffectiveWorkflowRules()) {
+        for (const pattern of rule.patterns) {
+            if (pattern.test(query)) {
+                matches.push(rule);
+                break;
+            }
+        }
+    }
+    if (matches.length === 0)
+        return null;
+    matches.sort((a, b) => b.priority - a.priority);
+    return matches[0];
+}
+export function matchWorkflowRoute(query, ctx) {
+    let bestMatch = null;
+    for (const [workflowId, runtimeRecord] of ctx.extensionWorkflowRuntimeById.entries()) {
+        const route = runtimeRecord.route ?? runtimeRecord.workflow.route;
+        if (!route) {
+            continue;
+        }
+        const descriptor = ctx.extensionWorkflowsById.get(workflowId);
+        const name = descriptor?.displayName ?? runtimeRecord.workflow.displayName;
+        const description = descriptor?.description ?? runtimeRecord.workflow.description ?? 'Workflow route';
+        for (const pattern of route.triggerPatterns) {
+            if (!pattern.test(query)) {
+                continue;
+            }
+            const confidence = route.priority / 100;
+            if (!bestMatch || confidence > bestMatch.confidence) {
+                bestMatch = {
+                    workflow: {
+                        id: workflowId,
+                        name,
+                        description,
+                        route,
+                    },
+                    confidence,
+                    matchedPattern: pattern.source,
+                };
+            }
+            break;
+        }
+    }
+    return bestMatch;
+}
+export function isBrowserOrNetworkTask(task, workflow) {
+    return (workflow?.domain === 'browser' ||
+        workflow?.domain === 'network' ||
+        BROWSER_OR_NETWORK_TASK_PATTERN.test(task));
+}
+export function isMaintenanceTask(task) {
+    return MAINTENANCE_TASK_PATTERN.test(task);
+}