@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/domains/graphql/handlers.impl.core.runtime.script-replace.js

@@ -1,74 +1 @@
-import { GRAPHQL_MAX_PREVIEW_CHARS } from '../../domains/graphql/handlers.impl.core.runtime.shared.js';
-import { GraphQLToolHandlersCallGraph } from '../../domains/graphql/handlers.impl.core.runtime.callgraph.js';
-export class GraphQLToolHandlersScriptReplace extends GraphQLToolHandlersCallGraph {
-    async handleScriptReplacePersist(args) {
-        try {
-            const url = this.getStringArg(args, 'url')?.trim();
-            const replacement = this.getStringArg(args, 'replacement');
-            const matchType = this.parseMatchType(args.matchType);
-            if (!url) {
-                return this.toError('Missing required argument: url');
-            }
-            if (typeof replacement !== 'string' || replacement.length === 0) {
-                return this.toError('Missing required argument: replacement');
-            }
-            if (matchType === 'regex') {
-                try {
-                    new RegExp(url);
-                }
-                catch (error) {
-                    return this.toError('Invalid regex in url for matchType=regex', {
-                        url,
-                        reason: this.getErrorMessage(error),
-                    });
-                }
-            }
-            const page = await this.collector.getActivePage();
-            const rule = {
-                id: this.generateRuleId(),
-                url,
-                replacement,
-                matchType,
-                createdAt: Date.now(),
-                hits: 0,
-            };
-            this.scriptReplaceRules.push(rule);
-            await this.ensureScriptInterception(page);
-            await page.evaluateOnNewDocument((payload) => {
-                const runtimeWindow = window;
-                const key = '__scriptReplacePersistRules';
-                const existing = Array.isArray(runtimeWindow[key])
-                    ? runtimeWindow[key]
-                    : [];
-                const filtered = existing.filter((entry) => entry && entry.id !== payload.id);
-                filtered.push(payload);
-                runtimeWindow[key] = filtered;
-            }, {
-                id: rule.id,
-                url: rule.url,
-                matchType: rule.matchType,
-                createdAt: rule.createdAt,
-            });
-            const replacementPreview = this.createPreview(replacement, GRAPHQL_MAX_PREVIEW_CHARS);
-            return this.toResponse({
-                success: true,
-                message: 'Script replacement rule registered and interception enabled',
-                rule: {
-                    id: rule.id,
-                    url: rule.url,
-                    matchType: rule.matchType,
-                    createdAt: rule.createdAt,
-                },
-                replacement: {
-                    length: replacement.length,
-                    preview: replacementPreview.preview,
-                    truncated: replacementPreview.truncated,
-                },
-                activeRuleCount: this.scriptReplaceRules.length,
-            });
-        }
-        catch (error) {
-            return this.toError(error);
-        }
-    }
-}
+export { GraphQLToolHandlersRuntime as GraphQLToolHandlersScriptReplace, } from '../../domains/graphql/handlers.impl.core.runtime.replay.js';

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

@@ -53,9 +53,16 @@ export interface ExtractedGraphQLQuery {
     timestamp: number | null;
     contentType: string;
 }
-export declare const GRAPHQL_MAX_PREVIEW_CHARS = 4000;
-export declare const GRAPHQL_MAX_SCHEMA_CHARS = 120000;
-export declare const GRAPHQL_MAX_QUERY_CHARS = 12000;
-export declare const GRAPHQL_MAX_GRAPH_NODES = 2000;
-export declare const GRAPHQL_MAX_GRAPH_EDGES = 5000;
+export declare const enum GraphQLRuntimeLimit {
+    MAX_PREVIEW_CHARS = 4000,
+    MAX_SCHEMA_CHARS = 120000,
+    MAX_QUERY_CHARS = 12000,
+    MAX_GRAPH_NODES = 2000,
+    MAX_GRAPH_EDGES = 5000
+}
+export declare const GRAPHQL_MAX_PREVIEW_CHARS = GraphQLRuntimeLimit.MAX_PREVIEW_CHARS;
+export declare const GRAPHQL_MAX_SCHEMA_CHARS = GraphQLRuntimeLimit.MAX_SCHEMA_CHARS;
+export declare const GRAPHQL_MAX_QUERY_CHARS = GraphQLRuntimeLimit.MAX_QUERY_CHARS;
+export declare const GRAPHQL_MAX_GRAPH_NODES = GraphQLRuntimeLimit.MAX_GRAPH_NODES;
+export declare const GRAPHQL_MAX_GRAPH_EDGES = GraphQLRuntimeLimit.MAX_GRAPH_EDGES;
 export declare const INTROSPECTION_QUERY: string;

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

@@ -1,83 +1,91 @@
-export const GRAPHQL_MAX_PREVIEW_CHARS = 4000;
-export const GRAPHQL_MAX_SCHEMA_CHARS = 120000;
-export const GRAPHQL_MAX_QUERY_CHARS = 12000;
-export const GRAPHQL_MAX_GRAPH_NODES = 2000;
-export const GRAPHQL_MAX_GRAPH_EDGES = 5000;
-export const INTROSPECTION_QUERY = `
-query IntrospectionQuery {
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types { ...FullType }
-    directives {
-      name
-      description
-      locations
-      args(includeDeprecated: true) { ...InputValue }
-    }
-  }
-}
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args(includeDeprecated: true) { ...InputValue }
-    type { ...TypeRef }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields(includeDeprecated: true) { ...InputValue }
-  interfaces { ...TypeRef }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes { ...TypeRef }
-}
-fragment InputValue on __InputValue {
-  name
-  description
-  type { ...TypeRef }
-  defaultValue
-  isDeprecated
-  deprecationReason
-}
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
+export var GraphQLRuntimeLimit;
+(function (GraphQLRuntimeLimit) {
+    GraphQLRuntimeLimit[GraphQLRuntimeLimit["MAX_PREVIEW_CHARS"] = 4000] = "MAX_PREVIEW_CHARS";
+    GraphQLRuntimeLimit[GraphQLRuntimeLimit["MAX_SCHEMA_CHARS"] = 120000] = "MAX_SCHEMA_CHARS";
+    GraphQLRuntimeLimit[GraphQLRuntimeLimit["MAX_QUERY_CHARS"] = 12000] = "MAX_QUERY_CHARS";
+    GraphQLRuntimeLimit[GraphQLRuntimeLimit["MAX_GRAPH_NODES"] = 2000] = "MAX_GRAPH_NODES";
+    GraphQLRuntimeLimit[GraphQLRuntimeLimit["MAX_GRAPH_EDGES"] = 5000] = "MAX_GRAPH_EDGES";
+})(GraphQLRuntimeLimit || (GraphQLRuntimeLimit = {}));
+export const GRAPHQL_MAX_PREVIEW_CHARS = GraphQLRuntimeLimit.MAX_PREVIEW_CHARS;
+export const GRAPHQL_MAX_SCHEMA_CHARS = GraphQLRuntimeLimit.MAX_SCHEMA_CHARS;
+export const GRAPHQL_MAX_QUERY_CHARS = GraphQLRuntimeLimit.MAX_QUERY_CHARS;
+export const GRAPHQL_MAX_GRAPH_NODES = GraphQLRuntimeLimit.MAX_GRAPH_NODES;
+export const GRAPHQL_MAX_GRAPH_EDGES = GraphQLRuntimeLimit.MAX_GRAPH_EDGES;
+export const INTROSPECTION_QUERY = `
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types { ...FullType }
+    directives {
+      name
+      description
+      locations
+      args(includeDeprecated: true) { ...InputValue }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args(includeDeprecated: true) { ...InputValue }
+    type { ...TypeRef }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields(includeDeprecated: true) { ...InputValue }
+  interfaces { ...TypeRef }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes { ...TypeRef }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  isDeprecated
+  deprecationReason
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
 `.trim();

package/dist/src/server/domains/hooks/ai-handlers.js

@@ -1,5 +1,6 @@
 import { AIHookGenerator } from '../../domains/shared/modules.js';
 import { logger } from '../../../utils/logger.js';
+import { argString, argStringRequired, argBool } from '../../domains/shared/parse-args.js';
 export class AIHookToolHandlers {
     pageController;
     hookGenerator;
@@ -15,7 +16,7 @@ export class AIHookToolHandlers {
                 target = args.target;
             }
             else {
-                const pattern = args.pattern || '';
+                const pattern = argString(args, 'pattern', '');
                 let targetType = 'function';
                 let targetName = pattern;
                 if (pattern === 'fetch' || pattern === 'XMLHttpRequest') {
@@ -28,7 +29,7 @@ export class AIHookToolHandlers {
                 target = { type: targetType, name: targetName };
             }
             const request = {
-                description: args.description || `Hook ${target.name || 'target'}`,
+                description: argString(args, 'description') || `Hook ${target.name || 'target'}`,
                 target,
                 behavior: args.behavior || {
                     captureArgs: true,
@@ -73,9 +74,9 @@ export class AIHookToolHandlers {
     }
     async handleAIHookInject(args) {
         try {
-            const hookId = args.hookId;
-            const code = args.code;
-            const method = args.method || 'evaluate';
+            const hookId = argStringRequired(args, 'hookId');
+            const code = argStringRequired(args, 'code');
+            const method = argString(args, 'method', 'evaluate');
             const page = await this.pageController.getPage();
             if (method === 'evaluateOnNewDocument') {
                 await page.evaluateOnNewDocument(code);
@@ -120,7 +121,7 @@ export class AIHookToolHandlers {
     }
     async handleAIHookGetData(args) {
         try {
-            const hookId = args.hookId;
+            const hookId = argStringRequired(args, 'hookId');
             const page = await this.pageController.getPage();
             const hookData = await page.evaluate((id) => {
                 if (!window.__aiHooks || !window.__aiHooks[id]) {
@@ -216,7 +217,7 @@ export class AIHookToolHandlers {
     }
     async handleAIHookClear(args) {
         try {
-            const hookId = args.hookId;
+            const hookId = argString(args, 'hookId');
             const page = await this.pageController.getPage();
             if (hookId) {
                 await page.evaluate((id) => {
@@ -274,8 +275,8 @@ export class AIHookToolHandlers {
     }
     async handleAIHookToggle(args) {
         try {
-            const hookId = args.hookId;
-            const enabled = args.enabled;
+            const hookId = argStringRequired(args, 'hookId');
+            const enabled = argBool(args, 'enabled');
             const page = await this.pageController.getPage();
             await page.evaluate((id, enable) => {
                 if (window.__aiHookMetadata && window.__aiHookMetadata[id]) {
@@ -313,8 +314,8 @@ export class AIHookToolHandlers {
     }
     async handleAIHookExport(args) {
         try {
-            const hookId = args.hookId;
-            const format = args.format || 'json';
+            const hookId = argString(args, 'hookId');
+            const format = argString(args, 'format', 'json');
             const page = await this.pageController.getPage();
             const exportData = await page.evaluate((id) => {
                 if (id) {

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

@@ -1,7 +1,58 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext, ToolHandlerDeps } from '../../domains/shared/registry.js';
 import { AIHookToolHandlers } from '../../domains/hooks/index.js';
-declare const DOMAIN: "hooks";
-declare const DEP_KEY: "aiHookHandlers";
+import type { ToolArgs } from '../../types.js';
 type H = AIHookToolHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "hooks";
+    depKey: "aiHookHandlers";
+    profiles: "full"[];
+    ensure: typeof ensure;
+    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: "hooks";
+        bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;