@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/domains/evidence/index.d.ts

@@ -0,0 +1,2 @@
+export * from './definitions.js';
+export { EvidenceHandlers } from './handlers.js';

package/dist/src/server/domains/evidence/index.js

@@ -0,0 +1,2 @@
+export * from './definitions.js';
+export { EvidenceHandlers } from './handlers.js';

package/dist/src/server/domains/evidence/manifest.d.ts

@@ -0,0 +1,63 @@
+import type { MCPServerContext } from '../../domains/shared/registry.js';
+import { EvidenceHandlers } from '../../domains/evidence/handlers.js';
+type H = EvidenceHandlers;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "evidence";
+    depKey: "evidenceHandlers";
+    profiles: ("workflow" | "full")[];
+    ensure: typeof ensure;
+    workflowRule: {
+        patterns: RegExp[];
+        priority: number;
+        tools: string[];
+        hint: string;
+    };
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "evidence";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
+export default manifest;

package/dist/src/server/domains/evidence/manifest.js

@@ -0,0 +1,78 @@
+import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
+import { evidenceTools } from '../../domains/evidence/definitions.js';
+import { EvidenceHandlers } from '../../domains/evidence/handlers.js';
+import { ReverseEvidenceGraph } from '../../evidence/ReverseEvidenceGraph.js';
+import { InstrumentationSessionManager } from '../../instrumentation/InstrumentationSession.js';
+import { EvidenceGraphBridge } from '../../instrumentation/EvidenceGraphBridge.js';
+const DOMAIN = 'evidence';
+const DEP_KEY = 'evidenceHandlers';
+const t = toolLookup(evidenceTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+function ensure(ctx) {
+    let graph = ctx.getDomainInstance('evidenceGraph');
+    if (!graph) {
+        graph = new ReverseEvidenceGraph();
+        ctx.setDomainInstance('evidenceGraph', graph);
+    }
+    let bridge = ctx.getDomainInstance('evidenceGraphBridge');
+    if (!bridge) {
+        bridge = new EvidenceGraphBridge(graph);
+        ctx.setDomainInstance('evidenceGraphBridge', bridge);
+    }
+    const sessionManager = ctx.getDomainInstance('instrumentationSessionManager');
+    sessionManager?.setEvidenceBridge(bridge);
+    if (!ctx.evidenceHandlers) {
+        ctx.evidenceHandlers = new EvidenceHandlers(graph);
+    }
+    return ctx.evidenceHandlers;
+}
+const manifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: DOMAIN,
+    depKey: DEP_KEY,
+    profiles: ['workflow', 'full'],
+    ensure,
+    workflowRule: {
+        patterns: [
+            /(evidence|provenance|chain).*(graph|query|export|report)/i,
+            /(证据|溯源|链).*(图|查询|导出|报告)/i,
+        ],
+        priority: 90,
+        tools: ['evidence_query_url', 'evidence_export_markdown'],
+        hint: 'Evidence graph: query by URL/function/scriptId → get provenance chain → export as JSON or Markdown report',
+    },
+    registrations: [
+        {
+            tool: t('evidence_query_url'),
+            domain: DOMAIN,
+            bind: b(async (h, a) => h.handleQueryUrl(a)),
+        },
+        {
+            tool: t('evidence_query_function'),
+            domain: DOMAIN,
+            bind: b(async (h, a) => h.handleQueryFunction(a)),
+        },
+        {
+            tool: t('evidence_query_script'),
+            domain: DOMAIN,
+            bind: b(async (h, a) => h.handleQueryScript(a)),
+        },
+        {
+            tool: t('evidence_export_json'),
+            domain: DOMAIN,
+            bind: b(async (h) => h.handleExportJson()),
+        },
+        {
+            tool: t('evidence_export_markdown'),
+            domain: DOMAIN,
+            bind: b(async (h) => h.handleExportMarkdown()),
+        },
+        {
+            tool: t('evidence_chain'),
+            domain: DOMAIN,
+            bind: b(async (h, a) => h.handleChain(a)),
+        },
+    ],
+};
+export default manifest;

package/dist/src/server/domains/graphql/definitions.js

@@ -1,143 +1,55 @@
+import { tool } from '../../registry/tool-builder.js';
 export const graphqlTools = [
-    {
-        name: 'call_graph_analyze',
-        description: 'Analyze runtime function call graph from in-page traces (__aiHooks / tracer records). Returns nodes, edges, and stats.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum stack-derived edge depth to include (default: 5, min: 1, max: 20).',
-                    default: 5,
-                },
-                filterPattern: {
-                    type: 'string',
-                    description: 'Optional regex string to filter function names (source or target).',
-                },
-            },
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'script_replace_persist',
-        description: 'Persistently replace matching script responses via request interception, and register metadata with evaluateOnNewDocument.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: {
-                    type: 'string',
-                    description: 'Script URL match pattern.',
-                },
-                replacement: {
-                    type: 'string',
-                    description: 'Replacement JavaScript source (full script content).',
-                },
-                matchType: {
-                    type: 'string',
-                    enum: ['exact', 'contains', 'regex'],
-                    description: "URL matching strategy. Defaults to 'contains'.",
-                    default: 'contains',
-                },
-            },
-            required: ['url', 'replacement'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    },
-    {
-        name: 'graphql_introspect',
-        description: 'Run GraphQL introspection query against a target endpoint and return schema payload.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                endpoint: {
-                    type: 'string',
-                    description: 'GraphQL endpoint URL.',
-                },
-                headers: {
-                    type: 'object',
-                    description: 'Optional custom request headers.',
-                    additionalProperties: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['endpoint'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    },
-    {
-        name: 'graphql_extract_queries',
-        description: 'Extract GraphQL queries/mutations from captured in-page network traces (fetch/xhr/aiHook records).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum number of extracted operations to return (default: 50, max: 200).',
-                    default: 50,
-                },
-            },
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'graphql_replay',
-        description: 'Replay a GraphQL operation with optional variables and headers via in-page fetch.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                endpoint: {
-                    type: 'string',
-                    description: 'GraphQL endpoint URL.',
-                },
-                query: {
-                    type: 'string',
-                    description: 'GraphQL query/mutation string.',
-                },
-                variables: {
-                    type: 'object',
-                    description: 'GraphQL variables object.',
-                    additionalProperties: true,
-                },
-                operationName: {
-                    type: 'string',
-                    description: 'Optional GraphQL operationName.',
-                },
-                headers: {
-                    type: 'object',
-                    description: 'Optional custom request headers.',
-                    additionalProperties: {
-                        type: 'string',
-                    },
-                },
-            },
-            required: ['endpoint', 'query'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    },
+    tool('call_graph_analyze')
+        .desc('Analyze runtime function call graph from in-page traces')
+        .number('maxDepth', 'Maximum stack-derived edge depth', { default: 5 })
+        .string('filterPattern', 'Regex filter for function names')
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('script_replace_persist')
+        .desc('Persistently replace matching script responses via request interception')
+        .string('url', 'Script URL match pattern')
+        .string('replacement', 'Replacement JavaScript source')
+        .enum('matchType', ['exact', 'contains', 'regex'], 'URL matching strategy', {
+        default: 'contains',
+    })
+        .required('url', 'replacement')
+        .openWorld()
+        .build(),
+    tool('graphql_introspect')
+        .desc('Run GraphQL introspection query against a target endpoint')
+        .string('endpoint', 'GraphQL endpoint URL')
+        .prop('headers', {
+        type: 'object',
+        description: 'Custom request headers',
+        additionalProperties: { type: 'string' },
+    })
+        .required('endpoint')
+        .openWorld()
+        .build(),
+    tool('graphql_extract_queries')
+        .desc('Extract GraphQL queries/mutations from captured network traces')
+        .number('limit', 'Maximum extracted operations', { default: 50 })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('graphql_replay')
+        .desc('Replay a GraphQL operation with optional variables via in-page fetch')
+        .string('endpoint', 'GraphQL endpoint URL')
+        .string('query', 'GraphQL query/mutation string')
+        .prop('variables', {
+        type: 'object',
+        description: 'GraphQL variables',
+        additionalProperties: true,
+    })
+        .string('operationName', 'GraphQL operationName')
+        .prop('headers', {
+        type: 'object',
+        description: 'Custom request headers',
+        additionalProperties: { type: 'string' },
+    })
+        .required('endpoint', 'query')
+        .openWorld()
+        .build(),
 ];

package/dist/src/server/domains/graphql/handlers.impl.core.runtime.replay.js

@@ -8,7 +8,7 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
             const filterPattern = this.getStringArg(args, 'filterPattern')?.trim() || '';
             if (filterPattern) {
                 try {
-                    new RegExp(filterPattern);
+                    RegExp(filterPattern);
                 }
                 catch (error) {
                     return this.toError('Invalid filterPattern regex', {
@@ -25,13 +25,6 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                 let scannedRecords = 0;
                 let acceptedRecords = 0;
                 const filterRegex = filter ? new RegExp(filter) : null;
-                const normalizeName = (value, fallback = 'anonymous') => {
-                    if (typeof value === 'string') {
-                        const normalized = value.trim();
-                        return normalized.length > 0 ? normalized : fallback;
-                    }
-                    return fallback;
-                };
                 const matchesFilter = (name) => {
                     if (!filterRegex) {
                         return true;
@@ -54,8 +47,8 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                     nodeMap.set(name, { id: name, name, callCount: by });
                 };
                 const addEdge = (sourceRaw, targetRaw) => {
-                    const source = normalizeName(sourceRaw, '');
-                    const target = normalizeName(targetRaw, '');
+                    const source = typeof sourceRaw === 'string' ? sourceRaw.trim() || '' : '';
+                    const target = typeof targetRaw === 'string' ? targetRaw.trim() || '' : '';
                     if (!source || !target || source === target) {
                         return;
                     }
@@ -73,43 +66,42 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                     incrementNode(source, 1);
                     incrementNode(target, 1);
                 };
-                const parseStackFrames = (stackValue) => {
-                    if (typeof stackValue !== 'string' || stackValue.trim().length === 0) {
-                        return [];
-                    }
-                    return stackValue
-                        .split('\n')
-                        .map((line) => line.trim())
-                        .filter((line) => line.length > 0)
-                        .map((line) => {
-                        const atMatch = line.match(/at\s+([^(<\s]+)/);
-                        if (atMatch && atMatch[1]) {
-                            return atMatch[1];
-                        }
-                        const atFileMatch = line.match(/^([^(<\s]+)@/);
-                        if (atFileMatch && atFileMatch[1]) {
-                            return atFileMatch[1];
-                        }
-                        return '';
-                    })
-                        .filter((name) => name.length > 0);
-                };
                 const processRecord = (record, fallbackName) => {
                     scannedRecords += 1;
-                    const callee = normalizeName(record.callee ??
+                    const calleeRaw = record.callee ??
                         record.functionName ??
                         record.fn ??
                         record.name ??
                         record.method ??
                         record.target ??
-                        fallbackName, fallbackName);
-                    const caller = normalizeName(record.caller ?? record.parent ?? record.from ?? '', '');
+                        fallbackName;
+                    const callee = typeof calleeRaw === 'string' ? calleeRaw.trim() || fallbackName : fallbackName;
+                    const callerRaw = record.caller ?? record.parent ?? record.from ?? '';
+                    const caller = typeof callerRaw === 'string' ? callerRaw.trim() || '' : '';
                     let used = false;
                     if (caller && callee) {
                         addEdge(caller, callee);
                         used = true;
                     }
-                    const frames = parseStackFrames(record.stack ?? record.stackTrace ?? record.trace);
+                    const stackValue = record.stack ?? record.stackTrace ?? record.trace;
+                    const frames = typeof stackValue === 'string' && stackValue.trim().length > 0
+                        ? stackValue
+                            .split('\n')
+                            .map((line) => line.trim())
+                            .filter((line) => line.length > 0)
+                            .map((line) => {
+                            const atMatch = line.match(/at\s+([^(<\s]+)/);
+                            if (atMatch?.[1]) {
+                                return atMatch[1];
+                            }
+                            const atFileMatch = line.match(/^([^(<\s]+)@/);
+                            if (atFileMatch?.[1]) {
+                                return atFileMatch[1];
+                            }
+                            return '';
+                        })
+                            .filter((name) => name.length > 0)
+                        : [];
                     if (frames.length > 1) {
                         const depthLimit = Math.min(depth, frames.length - 1);
                         for (let index = 0; index < depthLimit; index += 1) {
@@ -167,8 +159,8 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                         }
                     }
                 }
-                const nodes = Array.from(nodeMap.values()).sort((left, right) => right.callCount - left.callCount);
-                const edges = Array.from(edgeMap.values()).sort((left, right) => right.count - left.count);
+                const nodes = Array.from(nodeMap.values()).toSorted((left, right) => right.callCount - left.callCount);
+                const edges = Array.from(edgeMap.values()).toSorted((left, right) => right.count - left.count);
                 return {
                     nodes,
                     edges,
@@ -218,7 +210,7 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
             }
             if (matchType === 'regex') {
                 try {
-                    new RegExp(url);
+                    RegExp(url);
                 }
                 catch (error) {
                     return this.toError('Invalid regex in url for matchType=regex', {
@@ -397,79 +389,6 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                 const globalScope = window;
                 const extracted = [];
                 let scannedRecords = 0;
-                const getHeader = (headers, name) => {
-                    if (!headers || typeof headers !== 'object') {
-                        return '';
-                    }
-                    const headerEntries = Object.entries(headers);
-                    for (const [key, value] of headerEntries) {
-                        if (key.toLowerCase() === name.toLowerCase()) {
-                            return typeof value === 'string' ? value : String(value);
-                        }
-                    }
-                    return '';
-                };
-                const parseBodyToObject = (body) => {
-                    if (!body) {
-                        return null;
-                    }
-                    if (typeof body === 'object' && !Array.isArray(body)) {
-                        return body;
-                    }
-                    if (typeof body !== 'string') {
-                        return null;
-                    }
-                    const trimmed = body.trim();
-                    if (!trimmed) {
-                        return null;
-                    }
-                    try {
-                        const parsed = JSON.parse(trimmed);
-                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                            return parsed;
-                        }
-                    }
-                    catch {
-                    }
-                    if (trimmed.includes('query=')) {
-                        try {
-                            const params = new URLSearchParams(trimmed);
-                            const query = params.get('query');
-                            if (!query) {
-                                return null;
-                            }
-                            const operationName = params.get('operationName');
-                            const variablesRaw = params.get('variables');
-                            let variables = null;
-                            if (variablesRaw) {
-                                try {
-                                    variables = JSON.parse(variablesRaw);
-                                }
-                                catch {
-                                    variables = variablesRaw;
-                                }
-                            }
-                            return {
-                                query,
-                                operationName,
-                                variables,
-                            };
-                        }
-                        catch {
-                            return null;
-                        }
-                    }
-                    if (trimmed.startsWith('query ') ||
-                        trimmed.startsWith('mutation ') ||
-                        trimmed.startsWith('subscription ')) {
-                        return { query: trimmed };
-                    }
-                    return null;
-                };
-                const inferOperationName = (query) => {
-                    const match = query.match(/^\s*(query|mutation|subscription)\s+([A-Za-z0-9_]+)/);
-                    return match?.[2] ?? null;
-                };
                 const pushIfGraphQL = (payload, metadata) => {
                     if (!payload) {
                         return;
@@ -481,7 +400,8 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                     const operationNameRaw = payload.operationName;
                     const operationName = typeof operationNameRaw === 'string' && operationNameRaw.trim().length > 0
                         ? operationNameRaw
-                        : inferOperationName(queryRaw);
+                        : (queryRaw.match(/^\s*(query|mutation|subscription)\s+([A-Za-z0-9_]+)/)?.[2] ??
+                            null);
                     extracted.push({
                         source: metadata.source,
                         url: metadata.url,
@@ -509,7 +429,14 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                             ? record.requestHeaders
                             : null) ??
                         {};
-                    const contentType = getHeader(headers, 'content-type').toLowerCase();
+                    let contentType = '';
+                    for (const [key, value] of Object.entries(headers)) {
+                        if (key.toLowerCase() === 'content-type') {
+                            contentType = typeof value === 'string' ? value : String(value);
+                            break;
+                        }
+                    }
+                    contentType = contentType.toLowerCase();
                     const bodyCandidates = [record.body, record.postData];
                     if (record.options &&
                         typeof record.options === 'object' &&
@@ -518,7 +445,58 @@ export class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
                         bodyCandidates.push(optionsRecord.body);
                     }
                     for (const bodyCandidate of bodyCandidates) {
-                        const payload = parseBodyToObject(bodyCandidate);
+                        let payload = null;
+                        if (bodyCandidate &&
+                            typeof bodyCandidate === 'object' &&
+                            !Array.isArray(bodyCandidate)) {
+                            payload = bodyCandidate;
+                        }
+                        else if (typeof bodyCandidate === 'string') {
+                            const trimmed = bodyCandidate.trim();
+                            if (trimmed) {
+                                try {
+                                    const parsed = JSON.parse(trimmed);
+                                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                                        payload = parsed;
+                                    }
+                                }
+                                catch {
+                                }
+                                if (!payload && trimmed.includes('query=')) {
+                                    try {
+                                        const params = new URLSearchParams(trimmed);
+                                        const query = params.get('query');
+                                        if (query) {
+                                            const operationName = params.get('operationName');
+                                            const variablesRaw = params.get('variables');
+                                            let variables = null;
+                                            if (variablesRaw) {
+                                                try {
+                                                    variables = JSON.parse(variablesRaw);
+                                                }
+                                                catch {
+                                                    variables = variablesRaw;
+                                                }
+                                            }
+                                            payload = {
+                                                query,
+                                                operationName,
+                                                variables,
+                                            };
+                                        }
+                                    }
+                                    catch {
+                                        payload = null;
+                                    }
+                                }
+                                if (!payload &&
+                                    (trimmed.startsWith('query ') ||
+                                        trimmed.startsWith('mutation ') ||
+                                        trimmed.startsWith('subscription '))) {
+                                    payload = { query: trimmed };
+                                }
+                            }
+                        }
                         pushIfGraphQL(payload, {
                             source,
                             url,

package/dist/src/server/domains/hooks/ai-handlers.d.ts

@@ -1,15 +1,8 @@
 import type { PageController } from '../../domains/shared/modules.js';
 export declare class AIHookToolHandlers {
     private pageController;
-    private hookGenerator;
     private injectedHooks;
     constructor(pageController: PageController);
-    handleAIHookGenerate(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
     handleAIHookInject(args: Record<string, unknown>): Promise<{
         content: {
             type: string;