@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/manifest-CV12bcrF.mjs

@@ -0,0 +1,121 @@
+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 debuggerTools } from "./definitions-DVGfrn7y.mjs";
+//#region src/server/domains/debugger/manifest.ts
+const DOMAIN = "debugger";
+const DEP_KEY = "debuggerHandlers";
+const t = toolLookup(debuggerTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { DebuggerManager, RuntimeInspector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { DebuggerToolHandlers } = await import("./debugger-gnKxRSN0.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: [
+		{
+			tool: t("debugger_lifecycle"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerLifecycle(a))
+		},
+		{
+			tool: t("debugger_pause"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerPause(a))
+		},
+		{
+			tool: t("debugger_resume"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerResume(a))
+		},
+		{
+			tool: t("debugger_step"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerStep(a))
+		},
+		{
+			tool: t("breakpoint"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBreakpoint(a))
+		},
+		{
+			tool: t("get_call_stack"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleGetCallStack(a))
+		},
+		{
+			tool: t("debugger_evaluate"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerEvaluateDispatch(a))
+		},
+		{
+			tool: t("debugger_wait_for_paused"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerWaitForPaused(a))
+		},
+		{
+			tool: t("debugger_get_paused_state"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerGetPausedState(a))
+		},
+		{
+			tool: t("get_object_properties"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleGetObjectProperties(a))
+		},
+		{
+			tool: t("get_scope_variables_enhanced"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleGetScopeVariablesEnhanced(a))
+		},
+		{
+			tool: t("debugger_session"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDebuggerSession(a))
+		},
+		{
+			tool: t("watch"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWatch(a))
+		},
+		{
+			tool: t("blackbox_add"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBlackboxAdd(a))
+		},
+		{
+			tool: t("blackbox_add_common"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBlackboxAddCommon(a))
+		},
+		{
+			tool: t("blackbox_list"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBlackboxList(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CXsRWjjI.mjs

@@ -0,0 +1,224 @@
+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/cross-domain/definitions.ts
+const crossDomainToolDefinitions = [
+	tool("cross_domain_capabilities", (t) => t.desc("List cross-domain capabilities, supported v5.0 domains, and available mission workflows.").query()),
+	tool("cross_domain_suggest_workflow", (t) => t.desc("Suggest the best cross-domain workflow for a reverse-engineering 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, enabled v5.0 domains, and evidence-graph availability.").query()),
+	tool("cross_domain_correlate_all", (t) => t.desc("Ingest artifacts from V8, network, canvas, syscall, mojo, and binary domains into one shared evidence graph with optional cross-links.").array("v8Objects", {
+		type: "object",
+		properties: {
+			address: { type: "string" },
+			size: { type: "number" },
+			type: { type: "string" },
+			name: { type: "string" }
+		},
+		required: [
+			"address",
+			"size",
+			"type",
+			"name"
+		]
+	}, "Optional V8 heap objects to import first").array("networkRequests", {
+		type: "object",
+		properties: {
+			url: { type: "string" },
+			method: { type: "string" },
+			headers: {
+				type: "object",
+				additionalProperties: { type: "string" }
+			},
+			initiatorHeapIndex: { type: "number" }
+		},
+		required: ["url", "method"]
+	}, "Optional network requests. Use initiatorHeapIndex to link a request to v8Objects[index].").array("canvasNodes", {
+		type: "object",
+		properties: {
+			nodeId: { type: "string" },
+			type: { type: "string" },
+			label: { type: "string" },
+			creatorHeapIndex: { type: "number" }
+		},
+		required: [
+			"nodeId",
+			"type",
+			"label"
+		]
+	}, "Optional canvas nodes. Use creatorHeapIndex to link to v8Objects[index].").array("binarySymbols", {
+		type: "object",
+		properties: {
+			name: { type: "string" },
+			address: { type: "string" },
+			module: { type: "string" }
+		},
+		required: [
+			"name",
+			"address",
+			"module"
+		]
+	}, "Optional binary symbols to import before syscall correlation.").array("syscallEvents", {
+		type: "object",
+		properties: {
+			syscall: { type: "string" },
+			pid: { type: "number" },
+			timestamp: { type: "number" },
+			jsFunctionSymbolIndex: { type: "number" }
+		},
+		required: [
+			"syscall",
+			"pid",
+			"timestamp"
+		]
+	}, "Optional syscall events. Use jsFunctionSymbolIndex to link to binarySymbols[index].").array("mojoMessages", {
+		type: "object",
+		properties: {
+			interfaceName: { type: "string" },
+			messageType: { type: "string" },
+			payload: { description: "Any JSON-serializable payload object" },
+			sourceRequestIndex: { type: "number" }
+		},
+		required: [
+			"interfaceName",
+			"messageType",
+			"payload"
+		]
+	}, "Optional Mojo IPC messages. Use sourceRequestIndex to link to networkRequests[index].")),
+	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 lookupTool = toolLookup(crossDomainToolDefinitions);
+const bindTool = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
+	const { CrossDomainEvidenceBridge } = await import("./evidence-graph-bridge-C_fv9PuC.mjs");
+	const { CrossDomainWorkflowClassifier, CrossDomainHandlers } = await import("./handlers-DlCJN4Td.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_json",
+			relation: "precedes",
+			weight: .7
+		}
+	],
+	registrations: [
+		{
+			tool: lookupTool("cross_domain_capabilities"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleCapabilities(args))
+		},
+		{
+			tool: lookupTool("cross_domain_suggest_workflow"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleSuggestWorkflow(args))
+		},
+		{
+			tool: lookupTool("cross_domain_health"),
+			domain: DOMAIN,
+			bind: bindTool((handlers) => handlers.handleHealth())
+		},
+		{
+			tool: lookupTool("cross_domain_correlate_all"),
+			domain: DOMAIN,
+			bind: bindTool((handlers, args) => handlers.handleCorrelateAll(args))
+		},
+		{
+			tool: lookupTool("cross_domain_evidence_export"),
+			domain: DOMAIN,
+			bind: bindTool((handlers) => handlers.handleEvidenceExport())
+		},
+		{
+			tool: lookupTool("cross_domain_evidence_stats"),
+			domain: DOMAIN,
+			bind: bindTool((handlers) => handlers.handleEvidenceStats())
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CZLUCfG02.mjs

@@ -0,0 +1,95 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as platformTools } from "./definitions-6M-eejaT.mjs";
+//#region src/server/domains/platform/manifest.ts
+const DOMAIN = "platform";
+const DEP_KEY = "platformHandlers";
+const t = toolLookup(platformTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { PlatformToolHandlers } = await import("./platform-WmNn8Sxb.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.platformHandlers) ctx.platformHandlers = new PlatformToolHandlers(ctx.collector);
+	return ctx.platformHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("miniapp_pkg_scan"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleMiniappPkgScan(a))
+		},
+		{
+			tool: t("miniapp_pkg_unpack"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleMiniappPkgUnpack(a))
+		},
+		{
+			tool: t("miniapp_pkg_analyze"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleMiniappPkgAnalyze(a))
+		},
+		{
+			tool: t("asar_extract"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAsarExtract(a))
+		},
+		{
+			tool: t("electron_inspect_app"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronInspectApp(a))
+		},
+		{
+			tool: t("electron_scan_userdata"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronScanUserdata(a))
+		},
+		{
+			tool: t("asar_search"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAsarSearch(a))
+		},
+		{
+			tool: t("electron_check_fuses"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronCheckFuses(a))
+		},
+		{
+			tool: t("electron_patch_fuses"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronPatchFuses(a))
+		},
+		{
+			tool: t("v8_bytecode_decompile"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleV8BytecodeDecompile(a))
+		},
+		{
+			tool: t("electron_launch_debug"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronLaunchDebug(a))
+		},
+		{
+			tool: t("electron_debug_status"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronDebugStatus(a))
+		},
+		{
+			tool: t("electron_ipc_sniff"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleElectronIPCSniff(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-D6phHKFd.mjs

@@ -0,0 +1,131 @@
+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/instrumentation/definitions.ts
+const queryTypes = [
+	"before-load-inject",
+	"runtime-hook",
+	"network-intercept",
+	"function-trace"
+];
+const instrumentationTools = [
+	tool("instrumentation_session", (t) => t.desc(`Manage instrumentation sessions that group hooks, intercepts, and traces.
+
+Actions:
+- create: Create a new session
+- list: List all active sessions
+- destroy: Destroy a session (requires sessionId)
+- status: Get detailed session status (requires sessionId)`).enum("action", [
+		"create",
+		"list",
+		"destroy",
+		"status"
+	], "Session operation").string("sessionId", "Session ID (required for destroy/status)").required("action")),
+	tool("instrumentation_operation", (t) => t.desc(`Manage operations within an instrumentation session.
+
+Actions:
+- register: Register a new operation (requires sessionId, type, target)
+- list: List operations in a session (requires sessionId)`).enum("action", ["register", "list"], "Operation").enum("type", queryTypes, "Instrumentation type (action=register)").string("target", "Function name, URL pattern, or script target (action=register)").object("config", {}, "Operation-specific config (action=register)").required("action", "sessionId")),
+	tool("instrumentation_artifact", (t) => t.desc(`Manage captured artifacts for instrumentation operations.
+
+Actions:
+- record: Record a captured artifact (requires operationId, data)
+- query: Query captured artifacts (requires sessionId)`).enum("action", ["record", "query"], "Artifact operation").string("operationId", "Operation ID (action=record)").object("data", {}, "Captured artifact payload (action=record)").enum("type", queryTypes, "Optional artifact type filter (action=query)").number("limit", "Max artifacts to return (action=query, default: 50)", { default: 50 }).required("action", "sessionId")),
+	tool("instrumentation_hook_preset", (t) => t.desc("Apply hooks domain preset hooks within an instrumentation session and persist...").string("preset", "Single preset id to inject").array("presets", { type: "string" }, "Multiple preset ids to inject in one call").boolean("captureStack", "Whether injected presets should capture stack traces", { default: false }).boolean("logToConsole", "Whether injected presets should log to console", { default: true }).enum("method", ["evaluate", "evaluateOnNewDocument"], "Injection method forwarded to hook_preset", { default: "evaluate" }).prop("customTemplate", {
+		type: "object",
+		additionalProperties: true,
+		description: "Optional inline custom preset definition"
+	}).prop("customTemplates", {
+		type: "array",
+		items: {
+			type: "object",
+			additionalProperties: true
+		},
+		description: "Optional inline custom preset definitions"
+	}).requiredOpenWorld("sessionId")),
+	tool("instrumentation_network_replay", (t) => t.desc("Replay a previously captured network request inside an instrumentation sessio...").string("requestId", "Captured request ID returned by network_get_requests").object("headerPatch", { additionalProperties: { type: "string" } }, "Optional request header overrides").string("bodyPatch", "Optional raw request body override").string("methodOverride", "Optional HTTP method override").string("urlOverride", "Optional destination URL override").number("timeoutMs", "Optional replay timeout in milliseconds").boolean("dryRun", "Preview the replay without sending the request", { default: true }).requiredOpenWorld("sessionId", "requestId"))
+];
+//#endregion
+//#region src/server/domains/instrumentation/manifest.ts
+const DOMAIN = "instrumentation";
+const DEP_KEY = "instrumentationHandlers";
+const t = toolLookup(instrumentationTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
+	const { InstrumentationSessionManager } = await import("./InstrumentationSession-CvPC7Jwy.mjs");
+	const { EvidenceGraphBridge } = await import("./EvidenceGraphBridge-SFesNera.mjs");
+	const { InstrumentationHandlers } = await import("./handlers-C87g8oCe.mjs");
+	const hookPresetHandlers = ctx.handlerDeps.hookPresetHandlers;
+	const advancedHandlers = ctx.handlerDeps.advancedHandlers;
+	let graph = ctx.getDomainInstance("evidenceGraph");
+	if (!graph) {
+		graph = new ReverseEvidenceGraph();
+		ctx.setDomainInstance("evidenceGraph", graph);
+	}
+	let sessionManager = ctx.getDomainInstance("instrumentationSessionManager");
+	if (!sessionManager) {
+		sessionManager = new InstrumentationSessionManager();
+		ctx.setDomainInstance("instrumentationSessionManager", sessionManager);
+	}
+	let bridge = ctx.getDomainInstance("evidenceGraphBridge");
+	if (!bridge) {
+		bridge = new EvidenceGraphBridge(graph);
+		ctx.setDomainInstance("evidenceGraphBridge", bridge);
+	}
+	sessionManager.setEvidenceBridge(bridge);
+	if (!ctx.instrumentationHandlers) ctx.instrumentationHandlers = new InstrumentationHandlers(sessionManager, {
+		hookPresetHandlers,
+		advancedHandlers
+	});
+	return ctx.instrumentationHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(hook|intercept|trace|instrument).*(session|unified|manage|all)/i, /(session|统一|会话).*(hook|拦截|追踪|仪器化|instrument)/i],
+		priority: 95,
+		tools: [
+			"instrumentation_session",
+			"instrumentation_operation",
+			"instrumentation_artifact",
+			"instrumentation_hook_preset",
+			"instrumentation_network_replay"
+		],
+		hint: "Instrumentation session: create session → attach hook presets / network replay → record artifacts → query artifacts → destroy when done"
+	},
+	registrations: [
+		{
+			tool: t("instrumentation_session"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSessionDispatch(a))
+		},
+		{
+			tool: t("instrumentation_operation"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleOperationDispatch(a))
+		},
+		{
+			tool: t("instrumentation_artifact"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleArtifactDispatch(a))
+		},
+		{
+			tool: t("instrumentation_hook_preset"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleHookPreset(a))
+		},
+		{
+			tool: t("instrumentation_network_replay"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleNetworkReplay(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };