@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/manifest-Deq6opGg.mjs

@@ -0,0 +1,223 @@
+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/cross-domain/definitions.ts
+const crossDomainToolDefinitions = [
+	tool("cross_domain_capabilities", (t) => t.desc("List cross-domain capabilities and workflows.").query()),
+	tool("cross_domain_suggest_workflow", (t) => t.desc("Suggest a cross-domain workflow for a goal.").string("goal", "High-level task goal or problem statement to classify").boolean("preferAvailableOnly", "Prefer workflows whose dependent domains are currently enabled", { default: true }).required("goal").query()),
+	tool("cross_domain_health", (t) => t.desc("Report cross-domain health.").query()),
+	tool("cross_domain_correlate_all", (t) => t.desc("Run the built-in skia, mojo, syscall, and binary correlators and merge the results into the shared evidence graph.").prop("sceneTree", {
+		type: "object",
+		description: "Skia scene tree with layers and drawCommands",
+		additionalProperties: true
+	}).array("jsObjects", {
+		type: "object",
+		additionalProperties: true
+	}, "JS object descriptors for Skia correlation").array("mojoMessages", {
+		type: "object",
+		properties: {
+			interface: { type: "string" },
+			method: { type: "string" },
+			timestamp: { type: "number" },
+			messageId: { type: "string" }
+		},
+		required: [
+			"interface",
+			"method",
+			"timestamp",
+			"messageId"
+		]
+	}, "Mojo messages for MOJO-03 correlation").array("cdpEvents", {
+		type: "object",
+		properties: {
+			eventType: { type: "string" },
+			timestamp: { type: "number" },
+			url: { type: "string" }
+		},
+		required: ["eventType", "timestamp"]
+	}, "CDP events for MOJO-03 correlation").array("networkRequests", {
+		type: "object",
+		properties: {
+			requestId: { type: "string" },
+			url: { type: "string" },
+			timestamp: { type: "number" }
+		},
+		required: [
+			"requestId",
+			"url",
+			"timestamp"
+		]
+	}, "Network requests for MOJO-03 correlation").array("syscallEvents", {
+		type: "object",
+		properties: {
+			pid: { type: "number" },
+			tid: { type: "number" },
+			syscallName: { type: "string" },
+			timestamp: { type: "number" }
+		},
+		required: [
+			"pid",
+			"tid",
+			"syscallName",
+			"timestamp"
+		]
+	}, "Syscall events for SYSCALL-02 correlation").array("jsStacks", {
+		type: "object",
+		properties: {
+			threadId: { type: "number" },
+			timestamp: { type: "number" },
+			frames: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: { functionName: { type: "string" } },
+					required: ["functionName"]
+				}
+			}
+		},
+		required: [
+			"threadId",
+			"timestamp",
+			"frames"
+		]
+	}, "JS stacks for SYSCALL-02 correlation").prop("ghidraOutput", {
+		type: "object",
+		description: "Binary analysis output with moduleName and functions",
+		additionalProperties: true
+	})),
+	tool("cross_domain_evidence_export", (t) => t.desc("Export the shared cross-domain evidence graph as JSON.").query()),
+	tool("cross_domain_evidence_stats", (t) => t.desc("Get node and edge statistics for the shared cross-domain evidence graph.").query())
+];
+//#endregion
+//#region src/server/domains/cross-domain/manifest.ts
+const DOMAIN = "cross-domain";
+const DEP_KEY = "crossDomainHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(crossDomainToolDefinitions),
+	entries: [
+		{
+			tool: "cross_domain_capabilities",
+			method: "handleCapabilities"
+		},
+		{
+			tool: "cross_domain_suggest_workflow",
+			method: "handleSuggestWorkflow"
+		},
+		{
+			tool: "cross_domain_health",
+			method: "handleHealth"
+		},
+		{
+			tool: "cross_domain_correlate_all",
+			method: "handleCorrelateAll"
+		},
+		{
+			tool: "cross_domain_evidence_export",
+			method: "handleEvidenceExport"
+		},
+		{
+			tool: "cross_domain_evidence_stats",
+			method: "handleEvidenceStats"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-C02-gXOh.mjs").then((n) => n.t);
+	const { CrossDomainEvidenceBridge } = await import("./evidence-graph-bridge-DcYizFk2.mjs");
+	const { CrossDomainWorkflowClassifier, CrossDomainHandlers } = await import("./handlers-BAHPxcch.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	let graph = ctx.getDomainInstance("evidenceGraph");
+	if (!graph) {
+		graph = new ReverseEvidenceGraph();
+		graph.setEventBus(ctx.eventBus);
+		ctx.setDomainInstance("evidenceGraph", graph);
+	}
+	let bridge = ctx.getDomainInstance("crossDomainEvidenceBridge");
+	if (!bridge) {
+		bridge = new CrossDomainEvidenceBridge(graph);
+		ctx.setDomainInstance("crossDomainEvidenceBridge", bridge);
+	}
+	let workflowClassifier = ctx.getDomainInstance("crossDomainWorkflowClassifier");
+	if (!workflowClassifier) {
+		workflowClassifier = new CrossDomainWorkflowClassifier(ctx, true);
+		ctx.setDomainInstance("crossDomainWorkflowClassifier", workflowClassifier);
+	}
+	const handlers = new CrossDomainHandlers(bridge, workflowClassifier);
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(cross[- ]domain|multi[- ]domain|evidence graph|correlate).*(v8|network|canvas|syscall|mojo|binary)/i, /(跨域|多域|证据图|关联).*(v8|网络|canvas|syscall|mojo|binary)/i],
+		priority: 98,
+		tools: [
+			"cross_domain_capabilities",
+			"cross_domain_suggest_workflow",
+			"cross_domain_correlate_all",
+			"cross_domain_evidence_stats"
+		],
+		hint: "Cross-domain reverse workflow: inspect capabilities → suggest mission workflow → correlate evidence from all v5.0 domains → export evidence graph"
+	},
+	toolDependencies: [
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "deobfuscate",
+			relation: "suggests",
+			weight: .6
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "js_heap_search",
+			relation: "suggests",
+			weight: .6
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "network_enable",
+			relation: "suggests",
+			weight: .5
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "canvas_scene_dump",
+			relation: "suggests",
+			weight: .5
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "skia_correlate_objects",
+			relation: "suggests",
+			weight: .5
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "syscall_correlate_js",
+			relation: "suggests",
+			weight: .5
+		},
+		{
+			from: "cross_domain_suggest_workflow",
+			to: "ghidra_analyze",
+			relation: "suggests",
+			weight: .5
+		},
+		{
+			from: "cross_domain_correlate_all",
+			to: "evidence_export",
+			relation: "precedes",
+			weight: .7
+		}
+	],
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DfJTafJK.mjs

@@ -0,0 +1,37 @@
+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/sandbox/definitions.ts
+const sandboxTools = [tool("execute_sandbox_script", (t) => t.desc("Execute JavaScript in a WASM-isolated QuickJS sandbox with optional tool brid...").string("code", "JavaScript source code to execute inside the sandbox").string("sessionId", "Session ID for scratchpad persistence across executions").number("timeoutMs", "Execution timeout in ms", { default: 1e3 }).boolean("autoCorrect", "Retry failed scripts up to 2 times with error context", { default: false }).required("code"))];
+//#endregion
+//#region src/server/domains/sandbox/manifest.ts
+const DOMAIN = "sandbox";
+const DEP_KEY = "sandboxHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(sandboxTools),
+	entries: [{
+		tool: "execute_sandbox_script",
+		method: "handleExecuteSandboxScript"
+	}]
+});
+async function ensure(ctx) {
+	const { SandboxToolHandlers } = await import("./handlers-BWXEy6ef.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new SandboxToolHandlers(ctx);
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DgOdgN_j.mjs

@@ -0,0 +1,50 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as streamingTools } from "./definitions-DcYLVLCo.mjs";
+//#region src/server/domains/streaming/manifest.ts
+const DOMAIN = "streaming";
+const DEP_KEY = "streamingHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(streamingTools),
+	entries: [
+		{
+			tool: "ws_monitor",
+			method: "handleWsMonitorDispatch"
+		},
+		{
+			tool: "ws_get_frames",
+			method: "handleWsGetFrames"
+		},
+		{
+			tool: "ws_get_connections",
+			method: "handleWsGetConnections"
+		},
+		{
+			tool: "sse_monitor_enable",
+			method: "handleSseMonitorEnable"
+		},
+		{
+			tool: "sse_get_events",
+			method: "handleSseGetEvents"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { StreamingToolHandlers } = await import("./streaming-Dal6utPp.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.streamingHandlers) ctx.streamingHandlers = new StreamingToolHandlers(ctx.collector);
+	return ctx.streamingHandlers;
+}
+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-DlbMW4v4.mjs

@@ -0,0 +1,47 @@
+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/macro/definitions.ts
+const macroTools = [tool("run_macro", (t) => t.desc("Execute a registered macro by ID with inline progress and atomic bailout").string("macroId", "Macro ID to execute").prop("inputOverrides", {
+	type: "object",
+	description: "Per-step input overrides keyed by step ID",
+	additionalProperties: {
+		type: "object",
+		additionalProperties: true
+	}
+}).required("macroId")), tool("list_macros", (t) => t.desc("List all available macros (built-in + user-defined)").query())];
+//#endregion
+//#region src/server/domains/macro/manifest.ts
+const DOMAIN = "macro";
+const DEP_KEY = "macroHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(macroTools),
+	entries: [{
+		tool: "run_macro",
+		method: "handleRunMacro"
+	}, {
+		tool: "list_macros",
+		method: "handleListMacros"
+	}]
+});
+async function ensure(ctx) {
+	const { MacroToolHandlers } = await import("./handlers-CVv2H1uq.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new MacroToolHandlers(ctx);
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };