@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -1,207 +1 @@
-import { GRAPHQL_MAX_GRAPH_EDGES, GRAPHQL_MAX_GRAPH_NODES, } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-import { GraphQLToolHandlersBase } from '../../domains/graphql/handlers.impl.core.runtime.base.js';
-export class GraphQLToolHandlersCallGraph extends GraphQLToolHandlersBase {
-    async handleCallGraphAnalyze(args) {
-        try {
-            const maxDepth = this.getNumberArg(args, 'maxDepth', 5, 1, 20);
-            const filterPattern = this.getStringArg(args, 'filterPattern')?.trim() || '';
-            if (filterPattern) {
-                try {
-                    new RegExp(filterPattern);
-                }
-                catch (error) {
-                    return this.toError('Invalid filterPattern regex', {
-                        filterPattern,
-                        reason: this.getErrorMessage(error),
-                    });
-                }
-            }
-            const page = await this.collector.getActivePage();
-            const rawResult = await page.evaluate(({ maxDepth: depth, filterPattern: filter }) => {
-                const globalScope = window;
-                const edgeMap = new Map();
-                const nodeMap = new Map();
-                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;
-                    }
-                    filterRegex.lastIndex = 0;
-                    return filterRegex.test(name);
-                };
-                const includeEdge = (source, target) => {
-                    if (!filterRegex) {
-                        return true;
-                    }
-                    return matchesFilter(source) || matchesFilter(target);
-                };
-                const incrementNode = (name, by = 1) => {
-                    const existing = nodeMap.get(name);
-                    if (existing) {
-                        existing.callCount += by;
-                        return;
-                    }
-                    nodeMap.set(name, { id: name, name, callCount: by });
-                };
-                const addEdge = (sourceRaw, targetRaw) => {
-                    const source = normalizeName(sourceRaw, '');
-                    const target = normalizeName(targetRaw, '');
-                    if (!source || !target || source === target) {
-                        return;
-                    }
-                    if (!includeEdge(source, target)) {
-                        return;
-                    }
-                    const key = `${source}__->__${target}`;
-                    const existing = edgeMap.get(key);
-                    if (existing) {
-                        existing.count += 1;
-                    }
-                    else {
-                        edgeMap.set(key, { source, target, count: 1 });
-                    }
-                    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 ??
-                        record.functionName ??
-                        record.fn ??
-                        record.name ??
-                        record.method ??
-                        record.target ??
-                        fallbackName, fallbackName);
-                    const caller = normalizeName(record.caller ?? record.parent ?? record.from ?? '', '');
-                    let used = false;
-                    if (caller && callee) {
-                        addEdge(caller, callee);
-                        used = true;
-                    }
-                    const frames = parseStackFrames(record.stack ?? record.stackTrace ?? record.trace);
-                    if (frames.length > 1) {
-                        const depthLimit = Math.min(depth, frames.length - 1);
-                        for (let index = 0; index < depthLimit; index += 1) {
-                            addEdge(frames[index + 1], frames[index]);
-                        }
-                        used = true;
-                    }
-                    else if (frames.length === 1 && callee && frames[0] !== callee) {
-                        addEdge(frames[0], callee);
-                        used = true;
-                    }
-                    if (used) {
-                        acceptedRecords += 1;
-                    }
-                };
-                const aiHooks = globalScope.__aiHooks;
-                if (aiHooks && typeof aiHooks === 'object') {
-                    for (const [hookName, hookRecords] of Object.entries(aiHooks)) {
-                        if (!Array.isArray(hookRecords)) {
-                            continue;
-                        }
-                        for (const entry of hookRecords) {
-                            if (entry && typeof entry === 'object') {
-                                processRecord(entry, hookName);
-                            }
-                        }
-                    }
-                }
-                const tracerKeys = [
-                    '__functionTraceRecords',
-                    '__functionTracerRecords',
-                    '__functionCalls',
-                    '__callTrace',
-                    '__traceCalls',
-                ];
-                for (const key of tracerKeys) {
-                    const records = globalScope[key];
-                    if (!Array.isArray(records)) {
-                        continue;
-                    }
-                    for (const entry of records) {
-                        if (entry && typeof entry === 'object') {
-                            processRecord(entry, key);
-                        }
-                    }
-                }
-                const functionTracer = globalScope.__functionTracer;
-                if (functionTracer && typeof functionTracer === 'object') {
-                    const records = functionTracer.records;
-                    if (Array.isArray(records)) {
-                        for (const entry of records) {
-                            if (entry && typeof entry === 'object') {
-                                processRecord(entry, 'functionTracer.records');
-                            }
-                        }
-                    }
-                }
-                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);
-                return {
-                    nodes,
-                    edges,
-                    stats: {
-                        scannedRecords,
-                        acceptedRecords,
-                        nodeCount: nodes.length,
-                        edgeCount: edges.length,
-                        maxDepth: depth,
-                        filterPattern: filter || null,
-                    },
-                };
-            }, {
-                maxDepth,
-                filterPattern,
-            });
-            const result = rawResult;
-            const nodesTruncated = result.nodes.length > GRAPHQL_MAX_GRAPH_NODES;
-            const edgesTruncated = result.edges.length > GRAPHQL_MAX_GRAPH_EDGES;
-            return this.toResponse({
-                success: true,
-                nodes: result.nodes.slice(0, GRAPHQL_MAX_GRAPH_NODES),
-                edges: result.edges.slice(0, GRAPHQL_MAX_GRAPH_EDGES),
-                stats: {
-                    ...result.stats,
-                    nodesReturned: Math.min(result.nodes.length, GRAPHQL_MAX_GRAPH_NODES),
-                    edgesReturned: Math.min(result.edges.length, GRAPHQL_MAX_GRAPH_EDGES),
-                    nodesTruncated,
-                    edgesTruncated,
-                },
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersCallGraph, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

package/dist/src/server/domains/graphql/handlers.impl.core.runtime.extract.d.ts

@@ -1,9 +1 @@
-import { GraphQLToolHandlersIntrospection } from '../../domains/graphql/handlers.impl.core.runtime.introspection.js';
-export declare class GraphQLToolHandlersExtract extends GraphQLToolHandlersIntrospection {
-    handleGraphqlExtractQueries(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersExtract, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

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

@@ -1,228 +1 @@
-import { GRAPHQL_MAX_PREVIEW_CHARS, GRAPHQL_MAX_QUERY_CHARS, } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-import { GraphQLToolHandlersIntrospection } from '../../domains/graphql/handlers.impl.core.runtime.introspection.js';
-export class GraphQLToolHandlersExtract extends GraphQLToolHandlersIntrospection {
-    async handleGraphqlExtractQueries(args) {
-        try {
-            const limit = this.getNumberArg(args, 'limit', 50, 1, 200);
-            const page = await this.collector.getActivePage();
-            const extraction = (await page.evaluate((maxItems) => {
-                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;
-                    }
-                    const queryRaw = payload.query;
-                    if (typeof queryRaw !== 'string' || queryRaw.trim().length === 0) {
-                        return;
-                    }
-                    const operationNameRaw = payload.operationName;
-                    const operationName = typeof operationNameRaw === 'string' && operationNameRaw.trim().length > 0
-                        ? operationNameRaw
-                        : inferOperationName(queryRaw);
-                    extracted.push({
-                        source: metadata.source,
-                        url: metadata.url,
-                        method: metadata.method,
-                        operationName,
-                        query: queryRaw,
-                        variables: payload.variables ?? null,
-                        timestamp: metadata.timestamp,
-                        contentType: metadata.contentType,
-                    });
-                };
-                const processRequestRecord = (record, source) => {
-                    scannedRecords += 1;
-                    const url = typeof record.url === 'string' ? record.url : '';
-                    const method = typeof record.method === 'string' ? record.method : 'POST';
-                    const timestamp = typeof record.timestamp === 'number' ? record.timestamp : null;
-                    const headers = (record.headers && typeof record.headers === 'object' && !Array.isArray(record.headers)
-                        ? record.headers
-                        : null) ??
-                        (record.requestHeaders && typeof record.requestHeaders === 'object' && !Array.isArray(record.requestHeaders)
-                            ? record.requestHeaders
-                            : null) ??
-                        {};
-                    const contentType = getHeader(headers, 'content-type').toLowerCase();
-                    const bodyCandidates = [record.body, record.postData];
-                    if (record.options && typeof record.options === 'object' && !Array.isArray(record.options)) {
-                        const optionsRecord = record.options;
-                        bodyCandidates.push(optionsRecord.body);
-                    }
-                    for (const bodyCandidate of bodyCandidates) {
-                        const payload = parseBodyToObject(bodyCandidate);
-                        pushIfGraphQL(payload, {
-                            source,
-                            url,
-                            method,
-                            timestamp,
-                            contentType,
-                        });
-                    }
-                    if (contentType.includes('application/graphql') && typeof record.body === 'string') {
-                        pushIfGraphQL({ query: record.body, variables: null, operationName: null }, {
-                            source,
-                            url,
-                            method,
-                            timestamp,
-                            contentType,
-                        });
-                    }
-                };
-                const processArray = (value, source) => {
-                    if (!Array.isArray(value)) {
-                        return;
-                    }
-                    for (const item of value) {
-                        if (item && typeof item === 'object') {
-                            processRequestRecord(item, source);
-                        }
-                    }
-                };
-                processArray(globalScope.__fetchRequests, 'window.__fetchRequests');
-                processArray(globalScope.__xhrRequests, 'window.__xhrRequests');
-                processArray(globalScope.__networkRequests, 'window.__networkRequests');
-                const aiHooks = globalScope.__aiHooks;
-                if (aiHooks && typeof aiHooks === 'object') {
-                    for (const [hookName, hookRecords] of Object.entries(aiHooks)) {
-                        if (!Array.isArray(hookRecords)) {
-                            continue;
-                        }
-                        for (const entry of hookRecords) {
-                            if (entry && typeof entry === 'object') {
-                                processRequestRecord(entry, `window.__aiHooks.${hookName}`);
-                            }
-                        }
-                    }
-                }
-                extracted.sort((left, right) => (right.timestamp ?? 0) - (left.timestamp ?? 0));
-                const deduped = [];
-                const seen = new Set();
-                for (const item of extracted) {
-                    const key = `${item.url}|${item.operationName ?? ''}|${item.query}|${JSON.stringify(item.variables)}`;
-                    if (!seen.has(key)) {
-                        seen.add(key);
-                        deduped.push(item);
-                    }
-                }
-                return {
-                    scannedRecords,
-                    totalExtracted: deduped.length,
-                    extracted: deduped.slice(0, maxItems),
-                };
-            }, limit));
-            const queries = extraction.extracted.map((item, index) => {
-                const queryPreview = this.createPreview(item.query, GRAPHQL_MAX_QUERY_CHARS);
-                const variablesPreview = this.serializeForPreview(item.variables, GRAPHQL_MAX_PREVIEW_CHARS);
-                const normalized = {
-                    index,
-                    source: item.source,
-                    url: item.url,
-                    method: item.method,
-                    operationName: item.operationName,
-                    contentType: item.contentType,
-                    timestamp: item.timestamp,
-                    queryLength: item.query.length,
-                    queryPreview: queryPreview.preview,
-                    queryTruncated: queryPreview.truncated,
-                };
-                if (!queryPreview.truncated) {
-                    normalized.query = item.query;
-                }
-                if (!variablesPreview.truncated) {
-                    normalized.variables = item.variables;
-                }
-                else {
-                    normalized.variablesPreview = variablesPreview.preview;
-                    normalized.variablesTruncated = true;
-                }
-                return normalized;
-            });
-            return this.toResponse({
-                success: true,
-                limit,
-                stats: {
-                    scannedRecords: extraction.scannedRecords,
-                    totalExtracted: extraction.totalExtracted,
-                    returned: queries.length,
-                },
-                queries,
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersExtract, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

package/dist/src/server/domains/graphql/handlers.impl.core.runtime.introspection.d.ts

@@ -1,9 +1 @@
-import { GraphQLToolHandlersScriptReplace } from '../../domains/graphql/handlers.impl.core.runtime.script-replace.js';
-export declare class GraphQLToolHandlersIntrospection extends GraphQLToolHandlersScriptReplace {
-    handleGraphqlIntrospect(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersIntrospection, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

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

@@ -1,106 +1 @@
-import { GRAPHQL_MAX_PREVIEW_CHARS, GRAPHQL_MAX_SCHEMA_CHARS, INTROSPECTION_QUERY, } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-import { GraphQLToolHandlersScriptReplace } from '../../domains/graphql/handlers.impl.core.runtime.script-replace.js';
-export class GraphQLToolHandlersIntrospection extends GraphQLToolHandlersScriptReplace {
-    async handleGraphqlIntrospect(args) {
-        try {
-            const endpoint = this.getStringArg(args, 'endpoint')?.trim();
-            if (!endpoint) {
-                return this.toError('Missing required argument: endpoint');
-            }
-            const endpointValidationError = await this.validateExternalEndpoint(endpoint);
-            if (endpointValidationError) {
-                return this.toError(endpointValidationError);
-            }
-            const headers = this.normalizeHeaders(args.headers);
-            const page = await this.collector.getActivePage();
-            const browserResult = (await page.evaluate(async (input) => {
-                const requestHeaders = {
-                    'content-type': 'application/json',
-                    ...input.headers,
-                };
-                try {
-                    const response = await fetch(input.endpoint, {
-                        method: 'POST',
-                        headers: requestHeaders,
-                        body: JSON.stringify({
-                            query: input.query,
-                            operationName: 'IntrospectionQuery',
-                        }),
-                    });
-                    const responseText = await response.text();
-                    let responseJson = null;
-                    try {
-                        responseJson = JSON.parse(responseText);
-                    }
-                    catch {
-                        responseJson = null;
-                    }
-                    const responseHeaders = {};
-                    response.headers.forEach((value, key) => {
-                        responseHeaders[key] = value;
-                    });
-                    return {
-                        ok: response.ok,
-                        status: response.status,
-                        statusText: response.statusText,
-                        responseText,
-                        responseJson,
-                        responseHeaders,
-                    };
-                }
-                catch (error) {
-                    return {
-                        ok: false,
-                        status: 0,
-                        statusText: 'FETCH_ERROR',
-                        responseText: '',
-                        responseJson: null,
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            }, {
-                endpoint,
-                headers,
-                query: INTROSPECTION_QUERY,
-            }));
-            if (!browserResult.ok && !browserResult.responseJson) {
-                return this.toResponse({
-                    success: false,
-                    endpoint,
-                    status: browserResult.status,
-                    statusText: browserResult.statusText,
-                    error: browserResult.error ?? 'Introspection request failed',
-                    responsePreview: this.createPreview(browserResult.responseText || '', GRAPHQL_MAX_PREVIEW_CHARS),
-                });
-            }
-            const jsonRecord = browserResult.responseJson && typeof browserResult.responseJson === 'object'
-                ? browserResult.responseJson
-                : null;
-            const schemaPayload = jsonRecord && 'data' in jsonRecord ? jsonRecord.data : browserResult.responseJson ?? browserResult.responseText;
-            const schemaPreview = this.serializeForPreview(schemaPayload, GRAPHQL_MAX_SCHEMA_CHARS);
-            const payload = {
-                success: browserResult.ok,
-                endpoint,
-                status: browserResult.status,
-                statusText: browserResult.statusText,
-                schemaLength: schemaPreview.totalLength,
-                schemaPreview: schemaPreview.preview,
-                schemaTruncated: schemaPreview.truncated,
-                responseHeaders: browserResult.responseHeaders ?? {},
-            };
-            if (!schemaPreview.truncated) {
-                payload.schema = schemaPayload;
-            }
-            if (jsonRecord && Array.isArray(jsonRecord.errors)) {
-                payload.errors = jsonRecord.errors;
-            }
-            if (browserResult.error) {
-                payload.error = browserResult.error;
-            }
-            return this.toResponse(payload);
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersIntrospection, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

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

@@ -1,5 +1,29 @@
-import { GraphQLToolHandlersExtract } from '../../domains/graphql/handlers.impl.core.runtime.extract.js';
-export declare class GraphQLToolHandlersRuntime extends GraphQLToolHandlersExtract {
+import { GraphQLHandlersBase } from '../../domains/graphql/handlers.base.js';
+export declare class GraphQLToolHandlersRuntime extends GraphQLHandlersBase {
+    handleCallGraphAnalyze(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleScriptReplacePersist(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleGraphqlIntrospect(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleGraphqlExtractQueries(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
     handleGraphqlReplay(args: Record<string, unknown>): Promise<{
         content: {
             type: "text";
@@ -7,3 +31,4 @@ export declare class GraphQLToolHandlersRuntime extends GraphQLToolHandlersExtra
         }[];
     }>;
 }
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersCallGraph, GraphQLToolHandlersRuntime as GraphQLToolHandlersScriptReplace, GraphQLToolHandlersRuntime as GraphQLToolHandlersIntrospection, GraphQLToolHandlersRuntime as GraphQLToolHandlersExtract, };