@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/manifest-DmVfbH0w.mjs

@@ -0,0 +1,374 @@
+import { i as asToolResponse } from "./response-CWhh2aLo.mjs";
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+//#region src/server/domains/protocol-analysis/definitions.ts
+const protocolAnalysisTools = [
+	tool("payload_template_build", (t) => t.desc("Build a deterministic payload from field definitions.").array("fields", {
+		type: "object",
+		properties: {
+			name: {
+				type: "string",
+				description: "Field name"
+			},
+			type: {
+				type: "string",
+				enum: [
+					"u8",
+					"u16",
+					"u32",
+					"i8",
+					"i16",
+					"i32",
+					"string",
+					"bytes"
+				],
+				description: "Field type"
+			},
+			value: { description: "Numeric or string field value" },
+			encoding: {
+				type: "string",
+				enum: [
+					"utf8",
+					"ascii",
+					"hex",
+					"base64"
+				],
+				description: "String/bytes encoding override"
+			},
+			length: {
+				type: "number",
+				description: "Optional fixed length"
+			},
+			padByte: {
+				type: "number",
+				description: "Optional pad byte"
+			}
+		},
+		required: [
+			"name",
+			"type",
+			"value"
+		]
+	}, "Field definitions in output order").enum("endian", ["big", "little"], "Integer byte order", { default: "big" }).required("fields").idempotent()),
+	tool("payload_mutate", (t) => t.desc("Apply deterministic byte-level mutations to a hex payload.").string("hexPayload", "Source payload as a hex string").array("mutations", {
+		type: "object",
+		properties: {
+			strategy: {
+				type: "string",
+				enum: [
+					"set_byte",
+					"flip_bit",
+					"overwrite_bytes",
+					"append_bytes",
+					"truncate",
+					"increment_integer"
+				],
+				description: "Mutation strategy"
+			},
+			offset: {
+				type: "number",
+				description: "Zero-based byte offset"
+			},
+			value: {
+				type: "number",
+				description: "Byte value for set_byte"
+			},
+			bit: {
+				type: "number",
+				description: "Bit index for flip_bit"
+			},
+			data: {
+				type: "string",
+				description: "Mutation data for overwrite/append"
+			},
+			encoding: {
+				type: "string",
+				enum: [
+					"utf8",
+					"ascii",
+					"hex",
+					"base64"
+				],
+				description: "Data encoding for overwrite/append"
+			},
+			length: {
+				type: "number",
+				description: "Target length for truncate"
+			},
+			width: {
+				type: "number",
+				enum: [
+					1,
+					2,
+					4
+				],
+				description: "Integer width in bytes"
+			},
+			delta: {
+				type: "number",
+				description: "Increment/decrement delta"
+			},
+			endian: {
+				type: "string",
+				enum: ["big", "little"],
+				description: "Integer byte order"
+			},
+			signed: {
+				type: "boolean",
+				description: "Treat increment target as signed"
+			}
+		},
+		required: ["strategy"]
+	}, "Byte-level mutations to apply in order").required("hexPayload", "mutations")),
+	tool("ethernet_frame_build", (t) => t.desc("Build a deterministic Ethernet II frame from source/destination MAC addresses, EtherType, and payload bytes.").string("destinationMac", "Destination MAC address in colon, dash, dotted, or plain hex form").string("sourceMac", "Source MAC address in colon, dash, dotted, or plain hex form").string("etherType", "EtherType name (arp, ipv4, ipv6, vlan) or a 16-bit hex value such as 0800").string("payloadHex", "Frame payload as a hex string").required("destinationMac", "sourceMac", "etherType", "payloadHex").idempotent()),
+	tool("arp_build", (t) => t.desc("Build a deterministic ARP payload for Ethernet/IPv4 style address resolution packets.").enum("operation", ["request", "reply"], "ARP operation code", { default: "request" }).string("senderMac", "Sender hardware address").string("senderIp", "Sender IPv4 address").string("targetMac", "Target hardware address (use zeros for requests)", { default: "00:00:00:00:00:00" }).string("targetIp", "Target IPv4 address").number("hardwareType", "Hardware type number. Default: 1 (Ethernet)", { default: 1 }).string("protocolType", "Protocol type name (ipv4) or 16-bit hex value. Default: ipv4", { default: "ipv4" }).number("hardwareSize", "Hardware address size in bytes. Default: 6", { default: 6 }).number("protocolSize", "Protocol address size in bytes. Default: 4", { default: 4 }).required("senderMac", "senderIp", "targetIp").idempotent()),
+	tool("raw_ip_packet_build", (t) => t.desc("Build a deterministic IPv4 or IPv6 packet.").enum("version", ["ipv4", "ipv6"], "IP version", { default: "ipv4" }).string("sourceIp", "Source IPv4/IPv6 address").string("destinationIp", "Destination IPv4/IPv6 address").string("protocol", "Protocol/next-header name (icmp, tcp, udp, icmpv6) or an 8-bit integer string/hex value").string("payloadHex", "Inner payload as a hex string", { default: "" }).number("ttl", "IPv4 TTL or IPv6 hop limit fallback. Default: 64", { default: 64 }).number("hopLimit", "Explicit IPv6 hop limit override").number("identification", "IPv4 identification field. Default: 0", { default: 0 }).boolean("dontFragment", "Set the IPv4 DF flag", { default: false }).boolean("moreFragments", "Set the IPv4 MF flag", { default: false }).number("fragmentOffset", "IPv4 fragment offset in 8-byte units. Default: 0", { default: 0 }).number("dscp", "IPv4 DSCP or IPv6 traffic-class DSCP value (0-63). Default: 0", { default: 0 }).number("ecn", "IPv4/IPv6 ECN bits (0-3). Default: 0", { default: 0 }).number("flowLabel", "IPv6 flow label (0-1048575). Default: 0", { default: 0 }).required("version", "sourceIp", "destinationIp", "protocol").idempotent()),
+	tool("icmp_echo_build", (t) => t.desc("Build a deterministic ICMPv4 echo request or reply payload with an automatically computed checksum.").enum("operation", ["request", "reply"], "ICMP echo operation", { default: "request" }).number("identifier", "ICMP echo identifier field. Default: 0", { default: 0 }).number("sequenceNumber", "ICMP echo sequence number field. Default: 0", { default: 0 }).string("payloadHex", "Optional ICMP payload as a hex string", { default: "" }).idempotent()),
+	tool("checksum_apply", (t) => t.desc("Apply a deterministic 16-bit Internet checksum across a payload slice, optionally zeroing and writing the checksum field back into the packet.").string("hexPayload", "Source payload as a hex string").number("startOffset", "Inclusive start offset for checksum range. Default: 0", { default: 0 }).number("endOffset", "Exclusive end offset for checksum range. Default: payload length").number("zeroOffset", "Optional checksum field offset to zero before calculation").number("zeroLength", "Checksum field width in bytes when zeroOffset is set. Default: 2", { default: 2 }).number("writeOffset", "Optional destination offset for writing the computed checksum. Defaults to zeroOffset when provided").enum("endian", ["big", "little"], "Byte order used when writing the checksum back", { default: "big" }).required("hexPayload").idempotent()),
+	tool("pcap_write", (t) => t.desc("Write a compact classic PCAP file from deterministic packet byte records.").string("path", "Destination path for the PCAP file").array("packets", {
+		type: "object",
+		properties: {
+			dataHex: {
+				type: "string",
+				description: "Packet bytes as a hex string"
+			},
+			timestampSeconds: {
+				type: "number",
+				description: "Unix timestamp seconds. Defaults to 0 when omitted"
+			},
+			timestampFraction: {
+				type: "number",
+				description: "Microsecond or nanosecond fraction depending on timestampPrecision"
+			},
+			originalLength: {
+				type: "number",
+				description: "Original on-wire packet length. Defaults to included length"
+			}
+		},
+		required: ["dataHex"]
+	}, "Packet records to serialize in order").enum("endianness", ["little", "big"], "PCAP byte order for numeric fields", { default: "little" }).enum("timestampPrecision", ["micro", "nano"], "Timestamp precision marker in the PCAP magic", { default: "micro" }).number("snapLength", "Global snapshot length. Default: 65535", { default: 65535 }).string("linkType", "Link-layer type name (ethernet, raw, loopback) or integer string", { default: "ethernet" }).required("path", "packets").idempotent()),
+	tool("pcap_read", (t) => t.desc("Read a classic PCAP file and return compact deterministic packet summaries. PCAPNG is intentionally not supported.").string("path", "Path to the PCAP file to parse").number("maxPackets", "Maximum number of packet records to decode").number("maxBytesPerPacket", "Maximum payload bytes to return per packet before truncating the reported hex payload").required("path").query()),
+	tool("proto_define_pattern", (t) => t.desc("Define a protocol pattern with delimiter, byte order, and field layout").string("name", "Pattern name").prop("spec", {
+		type: "object",
+		description: "Pattern specification object",
+		additionalProperties: true
+	}).required("spec").idempotent()),
+	tool("proto_auto_detect", (t) => t.desc("Auto-detect a protocol pattern from one or more hex payload samples").array("hexPayloads", { type: "string" }, "Hex payload samples").required("hexPayloads").query()),
+	tool("proto_export_schema", (t) => t.desc("Export a protocol pattern to a .proto-like schema definition").string("patternId", "Pattern ID to export").required("patternId").query()),
+	tool("proto_infer_fields", (t) => t.desc("Infer likely protocol fields from repeated hex payload samples").array("hexPayloads", { type: "string" }, "Hex payload samples").required("hexPayloads").query()),
+	tool("proto_infer_state_machine", (t) => t.desc("Infer a protocol state machine from captured message sequences").array("messages", {
+		type: "object",
+		properties: {
+			direction: {
+				type: "string",
+				enum: ["req", "res"],
+				description: "Message direction"
+			},
+			timestamp: {
+				type: "number",
+				description: "Message timestamp"
+			},
+			fields: {
+				type: "object",
+				description: "Decoded message fields",
+				additionalProperties: true
+			},
+			raw: {
+				type: "string",
+				description: "Raw message or payload summary"
+			}
+		},
+		required: [
+			"direction",
+			"timestamp",
+			"fields",
+			"raw"
+		]
+	}, "Captured protocol messages").required("messages").query()),
+	tool("proto_visualize_state", (t) => t.desc("Generate a Mermaid state diagram from a protocol state machine definition").prop("stateMachine", {
+		type: "object",
+		description: "State machine definition with states and transitions",
+		additionalProperties: true
+	}).query()),
+	tool("proto_fingerprint", (t) => t.desc("Identify protocol type from hex payload samples (TLS, HTTP, DNS, WebSocket, SSH).").array("hexPayloads", { type: "string" }, "Hex payload samples to fingerprint").boolean("includeKnownProtocols", "Match against known protocol signatures", { default: true }).boolean("includeFieldHints", "Suggest likely field boundaries", { default: true }).required("hexPayloads").query())
+];
+//#endregion
+//#region src/server/domains/protocol-analysis/manifest.ts
+const DOMAIN = "protocol-analysis";
+const DEP_KEY = "protocolAnalysisHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(protocolAnalysisTools),
+	wrapResult: asToolResponse,
+	entries: [
+		{
+			tool: "proto_define_pattern",
+			method: "handleDefinePattern"
+		},
+		{
+			tool: "proto_auto_detect",
+			method: "handleAutoDetect"
+		},
+		{
+			tool: "proto_infer_fields",
+			method: "handleInferFields"
+		},
+		{
+			tool: "proto_infer_state_machine",
+			method: "handleInferStateMachine"
+		},
+		{
+			tool: "proto_export_schema",
+			method: "handleExportSchema"
+		},
+		{
+			tool: "proto_visualize_state",
+			method: "handleVisualizeState"
+		},
+		{
+			tool: "payload_template_build",
+			method: "handlePayloadTemplateBuild"
+		},
+		{
+			tool: "payload_mutate",
+			method: "handlePayloadMutate"
+		},
+		{
+			tool: "ethernet_frame_build",
+			method: "handleEthernetFrameBuild"
+		},
+		{
+			tool: "arp_build",
+			method: "handleArpBuild"
+		},
+		{
+			tool: "raw_ip_packet_build",
+			method: "handleRawIpPacketBuild"
+		},
+		{
+			tool: "icmp_echo_build",
+			method: "handleIcmpEchoBuild"
+		},
+		{
+			tool: "checksum_apply",
+			method: "handleChecksumApply"
+		},
+		{
+			tool: "pcap_write",
+			method: "handlePcapWrite"
+		},
+		{
+			tool: "pcap_read",
+			method: "handlePcapRead"
+		},
+		{
+			tool: "proto_fingerprint",
+			method: "handleProtoFingerprint"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { ProtocolAnalysisHandlers } = await import("./handlers-Dx2d7jt7.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new ProtocolAnalysisHandlers(void 0, void 0, ctx.eventBus);
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations,
+	prerequisites: {
+		proto_auto_detect: [{
+			condition: "At least one hex payload sample is required",
+			fix: "Capture traffic using network monitoring tools first"
+		}],
+		proto_infer_state_machine: [{
+			condition: "Multiple message samples are required for state machine inference",
+			fix: "Capture message sequences with mojo-ipc or network tools"
+		}]
+	},
+	workflowRule: {
+		patterns: [
+			/protocol\s+(reverse|analysis|pattern|state\s*machine|schema)/i,
+			/custom\s+protocol|binary\s+protocol|wire\s+format/i,
+			/infer\s+(protocol|fields|state\s*machine)/i,
+			/proto.*export|proto.*schema|proto.*diagram/i,
+			/payload\s+(template|build|mutate)|packet\s+(template|mutate)/i,
+			/ethernet|arp|ipv4|ipv6|pcap|internet\s+checksum|raw\s+packet/i,
+			/(decode|payload|bytes?|hex|protobuf|msgpack).*(protocol|field|state\s*machine)/i,
+			/(base64|hex|protobuf|msgpack).*(payload|protocol|field|decode)/i,
+			/(crypto\s*harness|checksum|payload\s+rebuild|payload\s+template).*(protocol|payload|decode)/i,
+			/(无状态|纯算|确定性|解码|载荷|字节|报文).*(协议|字段|状态机)/i
+		],
+		priority: .6,
+		tools: [
+			"binary_detect_format",
+			"binary_decode",
+			"proto_auto_detect",
+			"proto_infer_fields",
+			"proto_define_pattern",
+			"proto_infer_state_machine",
+			"proto_export_schema",
+			"proto_visualize_state",
+			"payload_template_build",
+			"payload_mutate",
+			"checksum_apply",
+			"crypto_test_harness",
+			"ethernet_frame_build",
+			"arp_build",
+			"raw_ip_packet_build",
+			"icmp_echo_build",
+			"pcap_write",
+			"pcap_read"
+		],
+		hint: "Capture or craft packet bytes -> build Ethernet/ARP/IP/ICMP headers -> apply deterministic checksums and payload mutations -> read/write compact PCAP files -> infer fields or state machines from resulting payloads"
+	},
+	toolDependencies: [
+		{
+			from: "network_get_requests",
+			to: "binary_decode",
+			relation: "suggests",
+			weight: .9
+		},
+		{
+			from: "binary_decode",
+			to: "proto_auto_detect",
+			relation: "precedes",
+			weight: .95
+		},
+		{
+			from: "proto_auto_detect",
+			to: "proto_infer_fields",
+			relation: "precedes",
+			weight: .95
+		},
+		{
+			from: "proto_infer_fields",
+			to: "proto_infer_state_machine",
+			relation: "precedes",
+			weight: .9
+		},
+		{
+			from: "detect_crypto",
+			to: "crypto_test_harness",
+			relation: "suggests",
+			weight: .8
+		},
+		{
+			from: "network",
+			to: "protocol-analysis",
+			relation: "uses",
+			weight: .7
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-Dog6Ddjr.mjs

@@ -0,0 +1,109 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as debuggerTools } from "./definitions-BbkvZkiv.mjs";
+//#region src/server/domains/debugger/manifest.ts
+const DOMAIN = "debugger";
+const DEP_KEY = "debuggerHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(debuggerTools),
+	entries: [
+		{
+			tool: "debugger_lifecycle",
+			method: "handleDebuggerLifecycle"
+		},
+		{
+			tool: "debugger_pause",
+			method: "handleDebuggerPause"
+		},
+		{
+			tool: "debugger_resume",
+			method: "handleDebuggerResume"
+		},
+		{
+			tool: "debugger_step",
+			method: "handleDebuggerStep"
+		},
+		{
+			tool: "breakpoint",
+			method: "handleBreakpoint"
+		},
+		{
+			tool: "get_call_stack",
+			method: "handleGetCallStack"
+		},
+		{
+			tool: "debugger_evaluate",
+			method: "handleDebuggerEvaluateDispatch"
+		},
+		{
+			tool: "debugger_wait_for_paused",
+			method: "handleDebuggerWaitForPaused"
+		},
+		{
+			tool: "debugger_get_paused_state",
+			method: "handleDebuggerGetPausedState"
+		},
+		{
+			tool: "get_object_properties",
+			method: "handleGetObjectProperties"
+		},
+		{
+			tool: "get_scope_variables_enhanced",
+			method: "handleGetScopeVariablesEnhanced"
+		},
+		{
+			tool: "debugger_session",
+			method: "handleDebuggerSession"
+		},
+		{
+			tool: "watch",
+			method: "handleWatch"
+		},
+		{
+			tool: "blackbox_add",
+			method: "handleBlackboxAdd"
+		},
+		{
+			tool: "blackbox_add_common",
+			method: "handleBlackboxAddCommon"
+		},
+		{
+			tool: "blackbox_list",
+			method: "handleBlackboxList"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { DebuggerManager, RuntimeInspector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { DebuggerToolHandlers } = await import("./debugger-RS3RSAqs.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.debuggerManager || !ctx.runtimeInspector || !ctx.debuggerHandlers) {
+		if (!ctx.debuggerManager) ctx.debuggerManager = new DebuggerManager(ctx.collector);
+		if (!ctx.runtimeInspector) ctx.runtimeInspector = new RuntimeInspector(ctx.collector, ctx.debuggerManager);
+		if (!ctx.debuggerHandlers) ctx.debuggerHandlers = new DebuggerToolHandlers(ctx.debuggerManager, ctx.runtimeInspector, ctx.eventBus);
+	}
+	return ctx.debuggerHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	prerequisites: {
+		debugger_lifecycle: [{
+			condition: "Browser must be launched",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		breakpoint: [{
+			condition: "Browser must be launched",
+			fix: "Call browser_launch and debugger_lifecycle(enable) first"
+		}]
+	},
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DvgU5FWb.mjs

@@ -0,0 +1,58 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as graphqlTools } from "./definitions-Pp5LI2H4.mjs";
+//#region src/server/domains/graphql/manifest.ts
+const DOMAIN = "graphql";
+const DEP_KEY = "graphqlHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(graphqlTools),
+	entries: [
+		{
+			tool: "call_graph_analyze",
+			method: "handleCallGraphAnalyze"
+		},
+		{
+			tool: "script_replace_persist",
+			method: "handleScriptReplacePersist"
+		},
+		{
+			tool: "graphql_introspect",
+			method: "handleGraphqlIntrospect"
+		},
+		{
+			tool: "graphql_extract_queries",
+			method: "handleGraphqlExtractQueries"
+		},
+		{
+			tool: "graphql_replay",
+			method: "handleGraphqlReplay"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector, ConsoleMonitor } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { GraphQLToolHandlers } = await import("./graphql-CoHrhweh.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.consoleMonitor) ctx.consoleMonitor = new ConsoleMonitor(ctx.collector);
+	if (!ctx.graphqlHandlers) ctx.graphqlHandlers = new GraphQLToolHandlers({
+		collector: ctx.collector,
+		consoleMonitor: ctx.consoleMonitor
+	});
+	return ctx.graphqlHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-HsfDBs7j.mjs

@@ -0,0 +1,50 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as sourcemapTools } from "./definitions-DAgIyjxM.mjs";
+//#region src/server/domains/sourcemap/manifest.ts
+const DOMAIN = "sourcemap";
+const DEP_KEY = "sourcemapHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(sourcemapTools),
+	entries: [
+		{
+			tool: "sourcemap_discover",
+			method: "handleSourcemapDiscover"
+		},
+		{
+			tool: "sourcemap_fetch_and_parse",
+			method: "handleSourcemapFetchAndParse"
+		},
+		{
+			tool: "sourcemap_reconstruct_tree",
+			method: "handleSourcemapReconstructTree"
+		},
+		{
+			tool: "sourcemap_parse_v4",
+			method: "handleSourcemapParseV4"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { SourcemapToolHandlers } = await import("./sourcemap-BIDHUVXy.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.sourcemapHandlers) ctx.sourcemapHandlers = new SourcemapToolHandlers(ctx.collector);
+	return ctx.sourcemapHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };