@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/definitions-uzkjBwa7.mjs

@@ -0,0 +1,258 @@
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+import { t as networkAuthorizationSchema } from "./authorization-schema-DRqyJMSk.mjs";
+//#region src/server/domains/network/definitions/analysis-tools.ts
+const analysisTools = [
+	tool("network_extract_auth", (t) => t.desc("Extract authentication data from captured network requests.").number("minConfidence", "Minimum confidence threshold 0-1", {
+		default: .4,
+		minimum: 0,
+		maximum: 1
+	})),
+	tool("network_export_har", (t) => t.desc("Export captured network traffic as HAR.").string("outputPath", "File path to write the HAR file. If omitted, returns HAR as JSON.").boolean("includeBodies", "Include response bodies in the HAR (may be slow for large captures). Default: false", { default: false }).openWorld()),
+	tool("network_replay_request", (t) => t.desc("Replay a captured network request with optional changes.").string("requestId", "Request ID from network_get_requests to replay").object("headerPatch", { additionalProperties: { type: "string" } }, "Headers to add or override (key-value pairs)").object("sessionProfile", {
+		cookies: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					value: { type: "string" },
+					domain: { type: "string" },
+					path: { type: "string" },
+					expires: { type: "number" },
+					httpOnly: { type: "boolean" },
+					secure: { type: "boolean" },
+					sameSite: {
+						type: "string",
+						enum: [
+							"Strict",
+							"Lax",
+							"None"
+						]
+					}
+				},
+				required: ["name", "value"]
+			}
+		},
+		userAgent: { type: "string" },
+		acceptLanguage: { type: "string" },
+		referer: { type: "string" },
+		clientHints: {
+			type: "object",
+			properties: {
+				"sec-ch-ua": { type: "string" },
+				"sec-ch-ua-mobile": { type: "string" },
+				"sec-ch-ua-platform": { type: "string" },
+				"sec-ch-ua-full-version-list": { type: "string" }
+			}
+		},
+		platform: { type: "string" },
+		origin: { type: "string" },
+		collectedAt: { type: "number" },
+		ttlSec: { type: "number" }
+	}, "Inject browser cookies, User-Agent and Accept-Language from a captured session into the replay.").string("bodyPatch", "Replace the entire request body with this string").string("methodOverride", "Override the HTTP method").string("urlOverride", "Override the request URL").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP replay. Use exact hosts/CIDRs instead of process-wide bypasses.").string("authorizationCapability", "Base64url-encoded JSON capability for request-scoped authorization. Payload fields mirror authorization and must include requestId.").number("timeoutMs", "Request timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).boolean("dryRun", "Preview the request without sending it", { default: true }).requiredOpenWorld("requestId")),
+	tool("network_intercept", (t) => t.desc("Manage network interception rules.").enum("action", [
+		"add",
+		"list",
+		"disable"
+	], "Intercept operation").string("urlPattern", "URL pattern to match").enum("urlPatternType", ["glob", "regex"], "How to interpret urlPattern", { default: "glob" }).enum("stage", ["Request", "Response"], "Intercept stage. Response (default) intercepts after server responds.", { default: "Response" }).number("responseCode", "HTTP status code to return", {
+		default: 200,
+		minimum: 100,
+		maximum: 599
+	}).object("responseHeaders", { additionalProperties: { type: "string" } }, "Custom response headers as key-value pairs.").string("responseBody", "Custom response body string.").array("rules", {
+		type: "object",
+		properties: {
+			urlPattern: { type: "string" },
+			urlPatternType: {
+				type: "string",
+				enum: ["glob", "regex"]
+			},
+			stage: {
+				type: "string",
+				enum: ["Request", "Response"]
+			},
+			responseCode: { type: "number" },
+			responseHeaders: {
+				type: "object",
+				additionalProperties: { type: "string" }
+			},
+			responseBody: { type: "string" }
+		},
+		required: ["urlPattern"]
+	}, "Rule objects to add").string("ruleId", "Rule ID to remove").boolean("all", "Remove all rules", { default: false }).required("action")),
+	tool("network_tls_fingerprint", (t) => t.desc("Compute TLS/HTTP fingerprint hashes for bot detection.").enum("mode", [
+		"analyze_request",
+		"compute_tls",
+		"compute_http"
+	], "Fingerprint mode").string("requestId", "Request ID to analyze").array("tlsVersions", { type: "string" }, "TLS version codes in order").array("ciphers", { type: "string" }, "Cipher suite codes in order").array("extensions", { type: "string" }, "Extension type codes in order").array("signatureAlgorithms", { type: "string" }, "Signature algorithm codes in order").enum("protocol", [
+		"tls",
+		"quic",
+		"dtls"
+	], "Transport protocol type", { default: "tls" }).boolean("sni", "Whether SNI (Server Name Indication) extension is present", { default: true }).string("alpn", "ALPN value").array("httpHeaders", { type: "string" }, "HTTP header names in order").string("userAgent", "User-Agent value").string("httpMethod", "HTTP method", { default: "GET" }).string("httpVersion", "HTTP version", { default: "1.1" }).string("cookieHeader", "Cookie header value").string("acceptLanguage", "Accept-Language header value").boolean("includeAnalysis", "Include detailed fingerprint breakdown", { default: true }).required("mode")),
+	tool("network_bot_detect_analyze", (t) => t.desc("Analyze captured requests for bot-detection signals.").number("limit", "Maximum requests to analyze", {
+		default: 50,
+		minimum: 1,
+		maximum: 500
+	}).boolean("includeDetails", "Include per-request analysis details", { default: false }).query())
+];
+//#endregion
+//#region src/server/domains/network/definitions/capture-tools.ts
+const captureTools = [
+	tool("network_enable", (t) => t.desc("Enable network request monitoring.").boolean("enableExceptions", "Also capture uncaught exceptions", { default: true })),
+	tool("network_disable", (t) => t.desc("Disable network request monitoring").destructive()),
+	tool("network_get_status", (t) => t.desc("Get network monitoring status.").query()),
+	tool("network_monitor", (t) => t.desc("Manage network request monitoring.").enum("action", [
+		"enable",
+		"disable",
+		"status"
+	], "Action to perform").boolean("enableExceptions", "Only for enable action: Also capture uncaught exceptions", { default: true }).required("action")),
+	tool("network_get_requests", (t) => t.desc("Get captured network requests.").string("url", "Filter by URL substring").string("urlRegex", "Filter by URL regex pattern").string("method", "Filter by HTTP method (GET, POST, PUT, DELETE)").number("sinceTimestamp", "Only return requests after this epoch timestamp (milliseconds). Useful for incremental polling.").string("sinceRequestId", "Only return requests after this requestId (exclusive). Useful for incremental retrieval.").number("tail", "Return the last N requests after filtering").number("limit", "Maximum number of results per page", {
+		default: 100,
+		minimum: 1,
+		maximum: 1e3
+	}).number("offset", "Skip results for pagination", {
+		default: 0,
+		minimum: 0
+	}).boolean("autoEnable", "Auto-enable network monitoring when currently disabled", { default: true }).boolean("enableExceptions", "When autoEnable=true, also enable uncaught exception monitoring", { default: true })),
+	tool("network_get_response_body", (t) => t.desc("Get the response body for a captured request.").string("requestId", "Request ID (from network_get_requests)").number("maxSize", "Maximum response size in bytes", {
+		default: 1e5,
+		minimum: 1024,
+		maximum: 2e7
+	}).boolean("returnSummary", "Return only size and preview instead of full body", { default: false }).number("retries", "Retry count when response body is not yet available", {
+		default: 3,
+		minimum: 0,
+		maximum: 10
+	}).number("retryIntervalMs", "Retry interval in milliseconds", {
+		default: 500,
+		minimum: 100,
+		maximum: 1e4
+	}).boolean("autoEnable", "Auto-enable network monitoring when currently disabled", { default: false }).boolean("enableExceptions", "When autoEnable=true, also enable uncaught exception monitoring", { default: true }).required("requestId")),
+	tool("network_get_stats", (t) => t.desc("Get network statistics.").query()),
+	tool("performance_get_metrics", (t) => t.desc("Get page performance metrics.").boolean("includeTimeline", "Include detailed timeline events", { default: false }).query()),
+	tool("performance_coverage", (t) => t.desc("Start or stop code coverage recording.").enum("action", ["start", "stop"], "Coverage action").required("action")),
+	tool("performance_take_heap_snapshot", (t) => t.desc("Take a V8 heap memory snapshot")),
+	tool("performance_trace", (t) => t.desc("Start or stop a Chrome performance trace.").enum("action", ["start", "stop"], "Trace action").array("categories", { type: "string" }, "Trace categories to capture").boolean("screenshots", "Capture screenshots during tracing", { default: false }).string("artifactPath", "Custom output path").required("action")),
+	tool("profiler_cpu", (t) => t.desc("Start or stop CPU profiling.").enum("action", ["start", "stop"], "Profiler action").string("artifactPath", "Custom output path").required("action")),
+	tool("profiler_heap_sampling", (t) => t.desc("Start or stop heap allocation sampling.").enum("action", ["start", "stop"], "Sampling action").number("samplingInterval", "Sampling interval in bytes", {
+		default: 32768,
+		minimum: 256,
+		maximum: 1048576
+	}).string("artifactPath", "Custom output path").number("topN", "Number of top allocators to return", {
+		default: 20,
+		minimum: 1,
+		maximum: 100
+	}).required("action"))
+];
+//#endregion
+//#region src/server/domains/network/definitions/console-tools.ts
+const consoleTools = [
+	tool("console_get_exceptions", (t) => t.desc("Get captured uncaught exceptions from the page").string("url", "Filter by URL substring").number("limit", "Maximum number of exceptions to return", {
+		default: 50,
+		minimum: 1,
+		maximum: 1e3
+	}).readOnly()),
+	tool("console_inject", (t) => t.desc("Inject an in-page script, XHR, fetch, or function monitor.").enum("type", [
+		"script",
+		"xhr",
+		"fetch",
+		"function"
+	], "Injection type").string("functionName", "Global function path to trace").boolean("persistent", "Keep the injection across page navigations", { default: false }).required("type").openWorld()),
+	tool("console_inject_fetch_interceptor", (t) => t.desc("Inject a fetch interceptor.").boolean("persistent", "Keep the injection across page navigations", { default: false }).openWorld()),
+	tool("console_inject_xhr_interceptor", (t) => t.desc("Inject an XMLHttpRequest interceptor.").boolean("persistent", "Keep the injection across page navigations", { default: false }).openWorld()),
+	tool("console_buffers", (t) => t.desc("Manage injected interceptor state.").enum("action", ["clear", "reset"], "Buffer action: clear buffers or reset interceptors").required("action"))
+];
+//#endregion
+//#region src/server/domains/network/definitions/probe-tools.ts
+const probeTools = [tool("network_traceroute", (t) => t.desc("Run an ICMP traceroute.").string("target", "Target hostname or IP address to trace route to").number("maxHops", "Maximum number of hops", {
+	default: 30,
+	minimum: 1,
+	maximum: 64
+}).number("timeout", "Per-hop timeout in milliseconds", {
+	default: 5e3,
+	minimum: 100,
+	maximum: 3e4
+}).number("packetSize", "ICMP echo request payload size in bytes", {
+	default: 32,
+	minimum: 8,
+	maximum: 65500
+}).required("target").query()), tool("network_icmp_probe", (t) => t.desc("Run an ICMP echo probe.").string("target", "Target hostname or IP address to probe").number("ttl", "Time-to-live value", {
+	default: 128,
+	minimum: 1,
+	maximum: 255
+}).number("packetSize", "ICMP echo request payload size in bytes", {
+	default: 32,
+	minimum: 8,
+	maximum: 65500
+}).number("timeout", "Timeout in milliseconds", {
+	default: 5e3,
+	minimum: 100,
+	maximum: 3e4
+}).required("target").query())];
+//#endregion
+//#region src/server/domains/network/definitions/transport-tools.ts
+const transportTools = [
+	tool("http_request_build", (t) => t.desc("Build a raw HTTP/1.x request payload.").string("method", "HTTP method token").string("target", "Request target, such as /path, *, or an absolute-form URL").string("host", "Optional Host header value to inject when addHostHeader is enabled").object("headers", { additionalProperties: { type: "string" } }, "Optional HTTP headers to include in the request").string("body", "Optional UTF-8 request body").enum("httpVersion", ["1.0", "1.1"], "HTTP protocol version to emit", { default: "1.1" }).boolean("addHostHeader", "Auto-add the Host header when host is provided", { default: true }).boolean("addContentLength", "Auto-add Content-Length when a body is present and Transfer-Encoding is absent", { default: true }).boolean("addConnectionClose", "Auto-add Connection: close when absent", { default: true }).requiredOpenWorld("method", "target")),
+	tool("http_plain_request", (t) => t.desc("Send a raw HTTP request over plain TCP.").string("host", "Target hostname or IP literal").number("port", "TCP port to connect to. Default: 80", {
+		default: 80,
+		minimum: 1,
+		maximum: 65535
+	}).string("requestText", "Raw HTTP request text to send as UTF-8 bytes").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP targets. Use exact hosts/CIDRs instead of process-wide bypasses.").number("timeoutMs", "Socket timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).number("maxResponseBytes", "Maximum number of raw response bytes to capture before truncating the exchange", {
+		default: 512e3,
+		minimum: 1024,
+		maximum: 10485760
+	}).requiredOpenWorld("host", "requestText")),
+	tool("http2_probe", (t) => t.desc("Probe an HTTP/2 endpoint.").string("url", "Absolute http:// or https:// URL to probe").string("method", "HTTP method token to send. Default: GET").object("headers", { additionalProperties: { type: "string" } }, "Optional request headers to include. Header names are normalized to lowercase for HTTP/2.").string("body", "Optional UTF-8 request body to send with the probe").array("alpnProtocols", { type: "string" }, "ALPN protocols to offer").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP targets. Use exact hosts/CIDRs instead of process-wide bypasses.").number("timeoutMs", "Probe timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).number("maxBodyBytes", "Maximum number of response body bytes to capture for the snippet before truncating", {
+		default: 32768,
+		minimum: 1024,
+		maximum: 1048576
+	}).requiredOpenWorld("url")),
+	tool("http2_frame_build", (t) => t.desc("Build a raw HTTP/2 frame.").string("frameType", "HTTP/2 frame type: DATA, SETTINGS, PING, WINDOW_UPDATE, RST_STREAM, GOAWAY, or RAW").number("streamId", "Stream identifier (0 for connection-level frames). Default: 0", {
+		default: 0,
+		minimum: 0,
+		maximum: 2147483647
+	}).number("flags", "Raw flags byte (0-255). Overrides type-specific defaults when set.", {
+		minimum: 0,
+		maximum: 255
+	}).number("frameTypeCode", "Explicit frame type code for RAW frames (0-255). Required when frameType is RAW.", {
+		minimum: 0,
+		maximum: 255
+	}).string("payloadHex", "Frame payload as a hex string. Mutually exclusive with payloadText.").string("payloadText", "Frame payload as a text string. Mutually exclusive with payloadHex.").string("payloadEncoding", "Encoding for payloadText: utf8 or ascii. Default: utf8").array("settings", {
+		type: "object",
+		properties: {
+			id: { type: "number" },
+			value: { type: "number" }
+		},
+		required: ["id", "value"]
+	}, "Array of {id, value} entries for SETTINGS frames").boolean("ack", "Set the ACK flag on SETTINGS or PING frames").string("pingOpaqueDataHex", "Exactly 8 bytes of opaque data for PING frames (hex string)").number("windowSizeIncrement", "Window size increment for WINDOW_UPDATE frames (1 to 2^31-1)").number("errorCode", "Error code for RST_STREAM or GOAWAY frames (0 to 2^32-1)").number("lastStreamId", "Last stream ID for GOAWAY frames (0 to 2^31-1)").string("debugDataText", "Optional debug data for GOAWAY frames").string("debugDataEncoding", "Encoding for debugDataText: utf8 or ascii. Default: utf8").requiredOpenWorld("frameType")),
+	tool("network_rtt_measure", (t) => t.desc("Measure round-trip time to a target URL.").string("url", "Target URL to measure RTT to").string("probeType", "Probe type: tcp, tls, or http. Default: tcp", { default: "tcp" }).number("iterations", "Number of probe iterations (1-50). Default: 5", {
+		default: 5,
+		minimum: 1,
+		maximum: 50
+	}).number("timeoutMs", "Per-probe timeout in milliseconds (100-30000). Default: 5000", {
+		default: 5e3,
+		minimum: 100,
+		maximum: 3e4
+	}).object("authorization", { additionalProperties: { type: "string" } }, "Authorization policy for network access").requiredOpenWorld("url"))
+];
+//#endregion
+//#region src/server/domains/network/definitions.ts
+const advancedTools = [
+	...captureTools,
+	...consoleTools,
+	...transportTools,
+	...analysisTools,
+	...probeTools
+];
+//#endregion
+export { advancedTools as t };

package/dist/definitions-va-AnLuQ.mjs

@@ -0,0 +1,28 @@
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+//#region src/server/domains/transform/definitions.ts
+const transformsEnum = [
+	"constant_fold",
+	"string_decrypt",
+	"dead_code_remove",
+	"control_flow_flatten",
+	"rename_vars"
+];
+const transformTools = [
+	tool("ast_transform_preview", (t) => t.desc("Preview lightweight AST-like transforms (string/regex based) and return before/after diff.").string("code", "Source code to transform.").array("transforms", {
+		type: "string",
+		enum: transformsEnum
+	}, "Ordered transform list.").boolean("preview", "Whether to generate line diff output.", { default: true }).required("code", "transforms").query()),
+	tool("ast_transform_chain", (t) => t.desc("Create and store an in-memory transform chain.").string("name", "Chain name.").array("transforms", {
+		type: "string",
+		enum: transformsEnum
+	}, "Ordered transform list.").string("description", "Optional chain description.").required("name", "transforms")),
+	tool("ast_transform_apply", (t) => t.desc("Apply transforms to input code or a live page scriptId.").string("scriptId", "Target script ID from page debugger context.").string("code", "Direct source code input.").string("chainName", "Use a saved transform chain by name.").array("transforms", {
+		type: "string",
+		enum: transformsEnum
+	}, "Direct transform list (used when chainName is not provided).")),
+	tool("crypto_extract_standalone", (t) => t.desc("Extract crypto/sign/encrypt function from current page and generate standalone runnable code.").string("targetFunction", "Target function name/path, e.g. \"window.sign\".").boolean("includePolyfills", "Include minimal runtime polyfills.", { default: true }).required("targetFunction")),
+	tool("crypto_test_harness", (t) => t.desc("Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.").string("code", "Standalone function code.").string("functionName", "Exported function name to execute.").array("testInputs", { type: "string" }, "Input list for test execution.").required("code", "functionName", "testInputs").query()),
+	tool("crypto_compare", (t) => t.desc("Compare two crypto implementations against identical test vectors.").string("code1", "Implementation A code.").string("code2", "Implementation B code.").string("functionName", "Function name shared by both implementations.").array("testInputs", { type: "string" }, "Input list for comparison.").required("code1", "code2", "functionName", "testInputs").query())
+];
+//#endregion
+export { transformTools as t };