@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/manifest-DlpTj4ic2.mjs

@@ -0,0 +1,193 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as advancedTools } from "./definitions-CXEI7QC72.mjs";
+//#region src/server/domains/network/manifest.ts
+const DOMAIN = "network";
+const DEP_KEY = "advancedHandlers";
+const t = toolLookup(advancedTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { AdvancedToolHandlers } = await import("./network-671Cw6hV.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.advancedHandlers) ctx.advancedHandlers = new AdvancedToolHandlers(ctx.collector, ctx.consoleMonitor, ctx.eventBus);
+	return ctx.advancedHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(capture|intercept|monitor|hook).*(network|request|response|api|traffic)/i, /(抓包|拦截|监控|hook).*(网络|请求|响应|api|流量)/i],
+		priority: 100,
+		tools: [
+			"run_extension_workflow",
+			"list_extension_workflows",
+			"network_monitor",
+			"page_navigate",
+			"network_get_requests"
+		],
+		hint: "Network capture workflow: prefer extension workflows first; otherwise bootstrap browser/page state -> enable capture -> navigate or act -> inspect captured requests"
+	},
+	prerequisites: {
+		network_get_requests: [{
+			condition: "Browser must be launched",
+			fix: "Call browser_launch or browser_attach first"
+		}, {
+			condition: "Network monitoring must be enabled",
+			fix: "Call network_monitor(enable) first"
+		}],
+		network_get_response_body: [{
+			condition: "Browser must be launched",
+			fix: "Call browser_launch or browser_attach first"
+		}, {
+			condition: "Network monitoring must be enabled",
+			fix: "Call network_monitor(enable) first"
+		}],
+		network_extract_auth: [{
+			condition: "Network monitoring must be enabled",
+			fix: "Call network_monitor(enable) first"
+		}]
+	},
+	registrations: [
+		{
+			tool: t("network_enable"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkEnable(a))
+		},
+		{
+			tool: t("network_disable"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkDisable(a))
+		},
+		{
+			tool: t("network_get_status"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkGetStatus(a))
+		},
+		{
+			tool: t("network_monitor"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkMonitor(a))
+		},
+		{
+			tool: t("network_get_requests"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkGetRequests(a))
+		},
+		{
+			tool: t("network_get_response_body"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkGetResponseBody(a))
+		},
+		{
+			tool: t("network_get_stats"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkGetStats(a))
+		},
+		{
+			tool: t("performance_get_metrics"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePerformanceGetMetrics(a))
+		},
+		{
+			tool: t("performance_coverage"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePerformanceCoverage(a))
+		},
+		{
+			tool: t("performance_take_heap_snapshot"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePerformanceTakeHeapSnapshot(a))
+		},
+		{
+			tool: t("performance_trace"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePerformanceTraceDispatch(a))
+		},
+		{
+			tool: t("profiler_cpu"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleProfilerCpuDispatch(a))
+		},
+		{
+			tool: t("profiler_heap_sampling"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleProfilerHeapSamplingDispatch(a))
+		},
+		{
+			tool: t("console_get_exceptions"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleConsoleGetExceptions(a))
+		},
+		{
+			tool: t("console_inject"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleConsoleInjectDispatch(a))
+		},
+		{
+			tool: t("console_buffers"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleConsoleBuffersDispatch(a))
+		},
+		{
+			tool: t("http_request_build"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleHttpRequestBuild(a))
+		},
+		{
+			tool: t("http_plain_request"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleHttpPlainRequest(a))
+		},
+		{
+			tool: t("http2_probe"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleHttp2Probe(a))
+		},
+		{
+			tool: t("http2_frame_build"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleHttp2FrameBuild(a))
+		},
+		{
+			tool: t("network_rtt_measure"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkRttMeasure(a))
+		},
+		{
+			tool: t("network_traceroute"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkTraceroute(a))
+		},
+		{
+			tool: t("network_icmp_probe"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkIcmpProbe(a))
+		},
+		{
+			tool: t("network_extract_auth"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkExtractAuth(a))
+		},
+		{
+			tool: t("network_export_har"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkExportHar(a))
+		},
+		{
+			tool: t("network_replay_request"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkReplayRequest(a))
+		},
+		{
+			tool: t("network_intercept"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkInterceptDispatch(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DrbmZcFl2.mjs

@@ -0,0 +1,253 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+//#region src/server/domains/protocol-analysis/definitions.ts
+const protocolAnalysisTools = [
+	tool("payload_template_build", (t) => t.desc("Build a binary payload from declarative field definitions.").idempotent()),
+	tool("payload_mutate", (t) => t.desc("Apply deterministic byte-level mutations to a hex payload. Useful for protocol probing, boundary testing, and replay preparation.").string("hexPayload", "Source payload as a hex string").array("mutations", {
+		type: "object",
+		properties: {
+			offset: {
+				type: "number",
+				description: "Zero-based byte offset"
+			},
+			length: {
+				type: "number",
+				description: "Mutation length in bytes (default: 1, ignored for replace_hex when valueHex is longer)"
+			},
+			mode: {
+				type: "string",
+				enum: [
+					"zero",
+					"ff",
+					"flip_bits",
+					"increment_u8",
+					"decrement_u8",
+					"replace_hex"
+				],
+				description: "Mutation strategy"
+			},
+			valueHex: {
+				type: "string",
+				description: "Replacement hex bytes for replace_hex mode"
+			}
+		},
+		required: ["offset", "mode"]
+	}, "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 raw IPv4 or IPv6 packet header around an existing payload.").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("name", "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())
+];
+//#endregion
+//#region src/server/domains/protocol-analysis/manifest.ts
+const DOMAIN = "protocol-analysis";
+const DEP_KEY = "protocolAnalysisHandlers";
+const t = toolLookup(protocolAnalysisTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { ProtocolAnalysisHandlers } = await import("./handlers-D6j6yka7.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: [
+		{
+			tool: t("proto_define_pattern"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleDefinePattern(args))
+		},
+		{
+			tool: t("proto_auto_detect"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleAutoDetect(args))
+		},
+		{
+			tool: t("proto_infer_fields"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleInferFields(args))
+		},
+		{
+			tool: t("proto_infer_state_machine"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleInferStateMachine(args))
+		},
+		{
+			tool: t("proto_export_schema"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleExportSchema(args))
+		},
+		{
+			tool: t("proto_visualize_state"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleVisualizeState(args))
+		},
+		{
+			tool: t("payload_template_build"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handlePayloadTemplateBuild(args))
+		},
+		{
+			tool: t("payload_mutate"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handlePayloadMutate(args))
+		},
+		{
+			tool: t("ethernet_frame_build"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleEthernetFrameBuild(args))
+		},
+		{
+			tool: t("arp_build"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleArpBuild(args))
+		},
+		{
+			tool: t("raw_ip_packet_build"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleRawIpPacketBuild(args))
+		},
+		{
+			tool: t("icmp_echo_build"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleIcmpEchoBuild(args))
+		},
+		{
+			tool: t("checksum_apply"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleChecksumApply(args))
+		},
+		{
+			tool: t("pcap_write"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handlePcapWrite(args))
+		},
+		{
+			tool: t("pcap_read"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handlePcapRead(args))
+		}
+	],
+	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
+		],
+		priority: .6,
+		tools: [
+			"proto_auto_detect",
+			"proto_infer_fields",
+			"proto_define_pattern",
+			"proto_infer_state_machine",
+			"proto_export_schema",
+			"proto_visualize_state",
+			"payload_template_build",
+			"payload_mutate",
+			"ethernet_frame_build",
+			"arp_build",
+			"raw_ip_packet_build",
+			"icmp_echo_build",
+			"checksum_apply",
+			"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",
+		to: "protocol-analysis",
+		relation: "uses",
+		weight: .7
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DuwHjUa5.mjs

@@ -0,0 +1,70 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as wasmTools } from "./definitions-Cy3Sl6gV.mjs";
+//#region src/server/domains/wasm/manifest.ts
+const DOMAIN = "wasm";
+const DEP_KEY = "wasmHandlers";
+const t = toolLookup(wasmTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { WasmToolHandlers } = await import("./wasm-DQTnHDs4.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.wasmHandlers) ctx.wasmHandlers = new WasmToolHandlers(ctx.collector);
+	return ctx.wasmHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("wasm_dump"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmDump(a))
+		},
+		{
+			tool: t("wasm_disassemble"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmDisassemble(a))
+		},
+		{
+			tool: t("wasm_decompile"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmDecompile(a))
+		},
+		{
+			tool: t("wasm_inspect_sections"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmInspectSections(a))
+		},
+		{
+			tool: t("wasm_offline_run"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmOfflineRun(a))
+		},
+		{
+			tool: t("wasm_optimize"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmOptimize(a))
+		},
+		{
+			tool: t("wasm_vmp_trace"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmVmpTrace(a))
+		},
+		{
+			tool: t("wasm_memory_inspect"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWasmMemoryInspect(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DzwvxPJX.mjs

@@ -0,0 +1,38 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
+import { n as getDep, t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { n as hookPresetTools, t as aiHookTools } from "./definitions-BMfYXoNC.mjs";
+//#region src/server/domains/hooks/manifest.ts
+const DOMAIN = "hooks";
+const DEP_KEY = "aiHookHandlers";
+const DEP_KEY_PRESET = "hookPresetHandlers";
+const t = toolLookup([...aiHookTools, ...hookPresetTools]);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { AIHookToolHandlers, HookPresetToolHandlers } = await import("./hooks-CzCWByww.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.aiHookHandlers || !ctx.hookPresetHandlers) {
+		if (!ctx.aiHookHandlers) ctx.aiHookHandlers = new AIHookToolHandlers(ctx.pageController);
+		if (!ctx.hookPresetHandlers) ctx.hookPresetHandlers = new HookPresetToolHandlers(ctx.pageController);
+	}
+	return ctx.aiHookHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	secondaryDepKeys: ["hookPresetHandlers"],
+	profiles: ["full"],
+	ensure,
+	registrations: [{
+		tool: t("ai_hook"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleAIHook(a))
+	}, {
+		tool: t("hook_preset"),
+		domain: DOMAIN,
+		bind: (deps) => (args) => getDep(deps, DEP_KEY_PRESET).handleHookPreset(args)
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-NXctwWQq.mjs

@@ -0,0 +1,68 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as workflowToolDefinitions } from "./definitions-Cke7zEb8.mjs";
+//#region src/server/domains/workflow/manifest.ts
+const DOMAIN = "workflow";
+const DEP_KEY = "workflowHandlers";
+const t = toolLookup(workflowToolDefinitions);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { WorkflowHandlers } = await import("./workflow-f3xJOcjx.mjs");
+	await ensureBrowserCore(ctx);
+	const browserHandlers = ctx.handlerDeps.browserHandlers;
+	const advancedHandlers = ctx.handlerDeps.advancedHandlers;
+	if (!ctx.workflowHandlers) ctx.workflowHandlers = new WorkflowHandlers({
+		browserHandlers,
+		advancedHandlers,
+		serverContext: ctx
+	});
+	return ctx.workflowHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(workflow|extension|run)/i, /(工作流|扩展|运行)/i],
+		priority: 95,
+		tools: ["run_extension_workflow", "list_extension_workflows"],
+		hint: "Extension workflow: list available workflows -> run the best matching workflow"
+	},
+	registrations: [
+		{
+			tool: t("page_script_register"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePageScriptRegister(a))
+		},
+		{
+			tool: t("page_script_run"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePageScriptRun(a))
+		},
+		{
+			tool: t("api_probe_batch"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleApiProbeBatch(a))
+		},
+		{
+			tool: t("js_bundle_search"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleJsBundleSearch(a))
+		},
+		{
+			tool: t("list_extension_workflows"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleListExtensionWorkflows())
+		},
+		{
+			tool: t("run_extension_workflow"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleRunExtensionWorkflow(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };