@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/manifest-2ToTpjv8.mjs

@@ -0,0 +1,106 @@
+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 tool } from "./tool-builder-DCbIC5Eo.mjs";
+//#region src/server/domains/canvas/definitions.ts
+const canvasTools = [
+	tool("canvas_engine_fingerprint", (t) => t.desc("Detect Canvas/WebGL game engine instances running in the page (LayaAir, PixiJ...").query()),
+	tool("canvas_scene_dump", (t) => t.desc("Extract the full scene tree / display list from a detected canvas engine").string("canvasId", "Canvas element ID or index to target").number("maxDepth", "Maximum tree traversal depth", { default: 20 }).boolean("onlyInteractive", "Only include interactive (mouseEnabled) nodes", { default: false }).boolean("onlyVisible", "Only include visible nodes", { default: false }).query()),
+	tool("canvas_pick_object_at_point", (t) => t.desc("Pick / hit-test the topmost object at a given screen coordinate using the engine's hit-test system").number("x", "Screen X coordinate").number("y", "Screen Y coordinate").string("canvasId", "Canvas element ID or index to target").boolean("highlight", "Draw a highlight rectangle on the picked object", { default: false }).required("x", "y").readOnly()),
+	tool("canvas_trace_click_handler", (t) => t.desc("Trace a click event through DOM events, engine dispatch, and JS call stack to...").number("x", "Screen X coordinate to click").number("y", "Screen Y coordinate to click").string("canvasId", "Canvas element ID or index to target").enum("breakpointType", [
+		"click",
+		"mousedown",
+		"pointerdown"
+	], "Event breakpoint type", { default: "click" }).number("maxFrames", "Maximum call stack frames to capture", { default: 50 }).requiredOpenWorld("x", "y"))
+];
+//#endregion
+//#region src/server/domains/canvas/manifest.ts
+const DOMAIN = "canvas";
+const DEP_KEY = "canvasHandlers";
+const t = toolLookup(canvasTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { DebuggerManager } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { TraceRecorder } = await import("./TraceRecorder-DgxyVbdQ.mjs");
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
+	const { CanvasToolHandlers } = await import("./handlers-Bl8zkwz1.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.debuggerManager) ctx.debuggerManager = new DebuggerManager(ctx.collector);
+	if (!ctx.traceRecorder) ctx.traceRecorder = new TraceRecorder();
+	let graph = ctx.getDomainInstance("evidenceGraph");
+	if (!graph) {
+		graph = new ReverseEvidenceGraph();
+		ctx.setDomainInstance("evidenceGraph", graph);
+	}
+	if (!ctx.canvasHandlers) ctx.canvasHandlers = new CanvasToolHandlers({
+		pageController: ctx.pageController,
+		debuggerManager: ctx.debuggerManager,
+		traceRecorder: ctx.traceRecorder,
+		evidenceStore: graph
+	});
+	return ctx.canvasHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	workflowRule: {
+		patterns: [
+			/(canvas|scene|engine|game).*(pick|dump|trace|reverse)/i,
+			/(canvas|webgl|webgpu|scene).*(graph|tree|node)/i,
+			/(laya|pixi|phaser|cocos|unity).*(reverse|scene|dump|hook)/i
+		],
+		priority: 80,
+		tools: [
+			"canvas_engine_fingerprint",
+			"canvas_scene_dump",
+			"canvas_pick_object_at_point",
+			"canvas_trace_click_handler"
+		],
+		hint: "Canvas reverse: fingerprint engine → dump scene tree → pick object at point → trace click to handler"
+	},
+	prerequisites: {
+		canvas_engine_fingerprint: [{
+			condition: "Browser must be running",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		canvas_scene_dump: [{
+			condition: "Browser must be running",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		canvas_pick_object_at_point: [{
+			condition: "Browser must be running",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		canvas_trace_click_handler: [{
+			condition: "Debugger must be enabled",
+			fix: "Call debugger_lifecycle({ action: 'enable' }) first"
+		}]
+	},
+	registrations: [
+		{
+			tool: t("canvas_engine_fingerprint"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleFingerprint(a))
+		},
+		{
+			tool: t("canvas_scene_dump"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSceneDump(a))
+		},
+		{
+			tool: t("canvas_pick_object_at_point"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handlePick(a))
+		},
+		{
+			tool: t("canvas_trace_click_handler"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleTraceClick(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-3g71z6Bg.mjs

@@ -0,0 +1,79 @@
+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";
+import { resolve } from "node:path";
+//#region src/server/domains/evidence/definitions.ts
+const evidenceTools = [
+	tool("evidence_query", (t) => t.desc("Query reverse evidence graph by URL, function name, or script ID to find associated nodes.").enum("by", [
+		"url",
+		"function",
+		"script"
+	], "Query dimension").string("value", "Search value: URL/fragment, function name, or script ID").required("by", "value").query()),
+	tool("evidence_export", (t) => t.desc("Export the reverse evidence graph as JSON snapshot or Markdown report.").enum("format", ["json", "markdown"], "Export format").required("format").query()),
+	tool("evidence_chain", (t) => t.desc("Get full provenance chain from a node ID in specified direction").string("nodeId", "Evidence node ID to start from").enum("direction", ["forward", "backward"], "Traversal direction", { default: "forward" }).required("nodeId").query())
+];
+//#endregion
+//#region src/server/domains/evidence/manifest.ts
+const DOMAIN = "evidence";
+const DEP_KEY = "evidenceHandlers";
+const t = toolLookup(evidenceTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
+	const { EvidenceGraphBridge } = await import("./EvidenceGraphBridge-SFesNera.mjs");
+	const { EvidenceHandlers } = await import("./handlers-tB9Mp9ZK.mjs");
+	let graph = ctx.getDomainInstance("evidenceGraph");
+	if (!graph) {
+		graph = new ReverseEvidenceGraph();
+		graph.setEventBus(ctx.eventBus);
+		ctx.setDomainInstance("evidenceGraph", graph);
+	}
+	let bridge = ctx.getDomainInstance("evidenceGraphBridge");
+	if (!bridge) {
+		bridge = new EvidenceGraphBridge(graph);
+		ctx.setDomainInstance("evidenceGraphBridge", bridge);
+	}
+	ctx.getDomainInstance("instrumentationSessionManager")?.setEvidenceBridge(bridge);
+	if (!ctx.evidenceHandlers) ctx.evidenceHandlers = new EvidenceHandlers(graph);
+	const scheduler = ctx.getDomainInstance("snapshotScheduler");
+	const stateDir = ctx.getDomainInstance("snapshotStateDir");
+	graph.setPersistNotifier(scheduler ? () => scheduler.notifyDirty() : void 0);
+	if (scheduler && stateDir && !ctx.getDomainInstance("evidenceGraphSnapshotRegistered")) {
+		scheduler.register(resolve(stateDir, "evidence-graph", "current.json"), graph);
+		ctx.setDomainInstance("evidenceGraphSnapshotRegistered", true);
+	}
+	return ctx.evidenceHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(evidence|provenance|chain).*(graph|query|export|report)/i, /(证据|溯源|链).*(图|查询|导出|报告)/i],
+		priority: 90,
+		tools: ["evidence_query", "evidence_export"],
+		hint: "Evidence graph: query by URL/function/scriptId → get provenance chain → export as JSON or Markdown report"
+	},
+	registrations: [
+		{
+			tool: t("evidence_query"),
+			domain: DOMAIN,
+			bind: b(async (h, a) => h.handleQueryDispatch(a))
+		},
+		{
+			tool: t("evidence_export"),
+			domain: DOMAIN,
+			bind: b(async (h, a) => h.handleExportDispatch(a))
+		},
+		{
+			tool: t("evidence_chain"),
+			domain: DOMAIN,
+			bind: b(async (h, a) => h.handleChain(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-82baTv4U.mjs

@@ -0,0 +1,45 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as sourcemapTools } from "./definitions-LKpC3-nL.mjs";
+//#region src/server/domains/sourcemap/manifest.ts
+const DOMAIN = "sourcemap";
+const DEP_KEY = "sourcemapHandlers";
+const t = toolLookup(sourcemapTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { SourcemapToolHandlers } = await import("./sourcemap-Dq8ez8vS.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: [
+		{
+			tool: t("sourcemap_discover"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSourcemapDiscover(a))
+		},
+		{
+			tool: t("sourcemap_fetch_and_parse"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSourcemapFetchAndParse(a))
+		},
+		{
+			tool: t("sourcemap_reconstruct_tree"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSourcemapReconstructTree(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-B3QVVeBS.mjs

@@ -0,0 +1,82 @@
+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/mojo-ipc/definitions.ts
+const mojoIpcTools = [
+	tool("mojo_monitor", (t) => t.desc("Start or stop Mojo IPC monitoring for the active Chromium-based target.").enum("action", ["start", "stop"], "Monitor action").string("deviceId", "Optional device or transport identifier (action=start)").required("action")),
+	tool("mojo_decode_message", (t) => t.desc("Decode a Mojo IPC hex payload into a structured field map").string("hexPayload", "Hex-encoded Mojo IPC payload").required("hexPayload").query()),
+	tool("mojo_list_interfaces", (t) => t.desc("List discovered Mojo IPC interfaces and their pending message counts").query()),
+	tool("mojo_messages_get", (t) => t.desc("Retrieve captured Mojo IPC messages from the active monitoring session").number("limit", "Maximum number of messages to retrieve (default 100)").string("interface", "Filter messages by interface name").query())
+];
+//#endregion
+//#region src/server/domains/mojo-ipc/manifest.ts
+const DOMAIN = "mojo-ipc";
+const DEP_KEY = "mojoIpcHandlers";
+const toolByName = toolLookup(mojoIpcTools);
+const bind = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { MojoIPCHandlers } = await import("./mojo-ipc-B_H61Afw.mjs");
+	const existingHandlers = ctx.getDomainInstance(DEP_KEY);
+	if (existingHandlers) return existingHandlers;
+	const handlers = new MojoIPCHandlers(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"],
+	registrations: [
+		{
+			tool: toolByName("mojo_monitor"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleMojoMonitorDispatch(args))
+		},
+		{
+			tool: toolByName("mojo_decode_message"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleMojoDecodeMessage(args))
+		},
+		{
+			tool: toolByName("mojo_list_interfaces"),
+			domain: DOMAIN,
+			bind: bind((handlers) => handlers.handleMojoListInterfaces())
+		},
+		{
+			tool: toolByName("mojo_messages_get"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleMojoMessagesGet(args))
+		}
+	],
+	ensure,
+	workflowRule: {
+		patterns: [/\b(mojo|ipc|chromium\s?(ipc|message)|interface\s?(broker|registry))\b/i, /(mojo|ipc|chromium).*(monitor|capture|hook|trace)/i],
+		priority: 75,
+		tools: [
+			"mojo_monitor",
+			"mojo_decode_message",
+			"mojo_list_interfaces"
+		],
+		hint: "Mojo IPC: start monitor → capture messages → decode payloads → correlate with CDP"
+	},
+	prerequisites: {
+		mojo_monitor: [{
+			condition: "Frida must be available for real process attachment",
+			fix: "Install Frida and ensure the Chromium target process is launched first"
+		}],
+		mojo_decode_message: [{
+			condition: "Captured message payload hex is required",
+			fix: "Start a monitoring session via mojo_monitor and capture traffic first"
+		}]
+	},
+	toolDependencies: [{
+		from: "browser",
+		to: "mojo-ipc",
+		relation: "uses",
+		weight: .8
+	}]
+};
+//#endregion
+export { manifest as default, mojoIpcTools as t };

package/dist/manifest-BB2J8IMJ.mjs

@@ -0,0 +1,149 @@
+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/syscall-hook/definitions.ts
+const BACKEND_OPTIONS = [
+	"etw",
+	"strace",
+	"dtrace"
+];
+const SYSCALL_EVENT_SCHEMA = {
+	type: "object",
+	properties: {
+		timestamp: {
+			type: "number",
+			description: "Unix timestamp in milliseconds"
+		},
+		pid: {
+			type: "number",
+			description: "Process identifier"
+		},
+		syscall: {
+			type: "string",
+			description: "Observed syscall name"
+		},
+		args: {
+			type: "array",
+			description: "Stringified syscall arguments",
+			items: { type: "string" }
+		},
+		returnValue: {
+			type: "number",
+			description: "Numeric syscall return value if available"
+		},
+		duration: {
+			type: "number",
+			description: "Execution duration in milliseconds if available"
+		}
+	},
+	required: [
+		"timestamp",
+		"pid",
+		"syscall",
+		"args"
+	]
+};
+const syscallHookToolDefinitions = [
+	tool("syscall_start_monitor", (t) => t.desc("Start syscall monitoring using ETW, strace, or dtrace.").enum("backend", BACKEND_OPTIONS, "Syscall capture backend").number("pid", "Optional PID to scope monitoring to a single process").required("backend")),
+	tool("syscall_stop_monitor", (t) => t.desc("Stop syscall monitoring.").idempotent()),
+	tool("syscall_capture_events", (t) => t.desc("Capture syscall events from the active or last monitoring session.").prop("filter", {
+		type: "object",
+		description: "Optional event filter",
+		properties: {
+			name: {
+				type: "array",
+				description: "Restrict events to specific syscall names",
+				items: { type: "string" }
+			},
+			pid: {
+				type: "number",
+				description: "Restrict events to a specific process ID"
+			}
+		}
+	}).query()),
+	tool("syscall_correlate_js", (t) => t.desc("Correlate captured syscalls with likely JavaScript functions.").array("syscallEvents", SYSCALL_EVENT_SCHEMA, "Syscall events to correlate").required("syscallEvents").query()),
+	tool("syscall_filter", (t) => t.desc("Filter captured syscall events by syscall name.").array("names", { type: "string" }, "Syscall names to keep").query()),
+	tool("syscall_get_stats", (t) => t.desc("Get syscall monitoring statistics.").query())
+];
+//#endregion
+//#region src/server/domains/syscall-hook/manifest.ts
+const DOMAIN = "syscall-hook";
+const DEP_KEY = "syscallHookHandlers";
+const lookupTool = toolLookup(syscallHookToolDefinitions);
+const bindTool = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { SyscallHookHandlers } = await import("./handlers-C67ktuRN.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new SyscallHookHandlers(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: lookupTool("syscall_start_monitor"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleSyscallStartMonitor(args))
+		},
+		{
+			tool: lookupTool("syscall_stop_monitor"),
+			domain: DOMAIN,
+			bind: bindTool((handlers) => handlers.handleSyscallStopMonitor())
+		},
+		{
+			tool: lookupTool("syscall_capture_events"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleSyscallCaptureEvents(args))
+		},
+		{
+			tool: lookupTool("syscall_correlate_js"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleSyscallCorrelateJs(args))
+		},
+		{
+			tool: lookupTool("syscall_filter"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleSyscallFilter(args))
+		},
+		{
+			tool: lookupTool("syscall_get_stats"),
+			domain: DOMAIN,
+			bind: bindTool((handlers) => handlers.handleSyscallGetStats())
+		}
+	],
+	workflowRule: {
+		patterns: [/\b(syscall|etw|strace|dtrace|kernel|system\s?call)\b/i, /(syscall|kernel).*(trace|monitor|capture|filter)/i],
+		priority: 78,
+		tools: [
+			"syscall_start_monitor",
+			"syscall_capture_events",
+			"syscall_correlate_js"
+		],
+		hint: "Syscall tracing: start monitor (ETW/strace/dtrace) → capture events → correlate with JS stacks."
+	},
+	prerequisites: {
+		syscall_start_monitor: [{
+			condition: "Administrator/root privileges required for ETW and dtrace; Linux strace needs ptrace_scope=0",
+			fix: "Run the MCP server with elevated privileges, or relax kernel restrictions on Linux"
+		}],
+		syscall_correlate_js: [{
+			condition: "A debugger or v8-inspector session must expose JS stacks",
+			fix: "Attach the debugger or v8-inspector domain before correlating"
+		}]
+	},
+	toolDependencies: [{
+		from: "memory",
+		to: "syscall-hook",
+		relation: "uses",
+		weight: .5
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-BKbgbSiY.mjs

@@ -0,0 +1,60 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as coordinationTools } from "./definitions-CkFDALoa.mjs";
+//#region src/server/domains/coordination/manifest.ts
+const DOMAIN = "coordination";
+const DEP_KEY = "coordinationHandlers";
+const t = toolLookup(coordinationTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CoordinationHandlers } = await import("./coordination-qUbyF8KU.mjs");
+	if (!ctx.coordinationHandlers) ctx.coordinationHandlers = new CoordinationHandlers(ctx);
+	return ctx.coordinationHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("create_task_handoff"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCreateTaskHandoff(a))
+		},
+		{
+			tool: t("complete_task_handoff"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCompleteTaskHandoff(a))
+		},
+		{
+			tool: t("get_task_context"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleGetTaskContext(a))
+		},
+		{
+			tool: t("append_session_insight"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAppendSessionInsight(a))
+		},
+		{
+			tool: t("save_page_snapshot"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSavePageSnapshot(a))
+		},
+		{
+			tool: t("restore_page_snapshot"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleRestorePageSnapshot(a))
+		},
+		{
+			tool: t("list_page_snapshots"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleListPageSnapshots())
+		}
+	]
+};
+//#endregion
+export { manifest as default };