@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/manifest-67Bok-Si.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 transformTools } from "./definitions-va-AnLuQ.mjs";
+//#region src/server/domains/transform/manifest.ts
+const DOMAIN = "transform";
+const DEP_KEY = "transformHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(transformTools),
+	entries: [
+		{
+			tool: "ast_transform_preview",
+			method: "handleAstTransformPreview"
+		},
+		{
+			tool: "ast_transform_chain",
+			method: "handleAstTransformChain"
+		},
+		{
+			tool: "ast_transform_apply",
+			method: "handleAstTransformApply"
+		},
+		{
+			tool: "crypto_extract_standalone",
+			method: "handleCryptoExtractStandalone"
+		},
+		{
+			tool: "crypto_test_harness",
+			method: "handleCryptoTestHarness"
+		},
+		{
+			tool: "crypto_compare",
+			method: "handleCryptoCompare"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { TransformToolHandlers } = await import("./transform-DRVgGG90.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.transformHandlers) ctx.transformHandlers = new TransformToolHandlers(ctx.collector);
+	return ctx.transformHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-6lNTMZAB2.mjs

@@ -0,0 +1,87 @@
+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/mojo-ipc/definitions.ts
+const mojoIpcTools = [
+	tool("mojo_ipc_capabilities", (t) => t.desc("Report Mojo IPC monitoring availability.").query()),
+	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 registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(mojoIpcTools),
+	entries: [
+		{
+			tool: "mojo_ipc_capabilities",
+			method: "handleMojoIpcCapabilities"
+		},
+		{
+			tool: "mojo_monitor",
+			method: "handleMojoMonitorDispatch"
+		},
+		{
+			tool: "mojo_decode_message",
+			method: "handleMojoDecodeMessage"
+		},
+		{
+			tool: "mojo_list_interfaces",
+			method: "handleMojoListInterfaces"
+		},
+		{
+			tool: "mojo_messages_get",
+			method: "handleMojoMessagesGet"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { MojoIPCHandlers } = await import("./mojo-ipc-DXNEXEqb.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,
+	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-B2duEHiH.mjs

@@ -0,0 +1,90 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as platformTools } from "./definitions-CVPD9hzZ.mjs";
+//#region src/server/domains/platform/manifest.ts
+const DOMAIN = "platform";
+const DEP_KEY = "platformHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(platformTools),
+	entries: [
+		{
+			tool: "platform_capabilities",
+			method: "handlePlatformCapabilities"
+		},
+		{
+			tool: "miniapp_pkg_scan",
+			method: "handleMiniappPkgScan"
+		},
+		{
+			tool: "miniapp_pkg_unpack",
+			method: "handleMiniappPkgUnpack"
+		},
+		{
+			tool: "miniapp_pkg_analyze",
+			method: "handleMiniappPkgAnalyze"
+		},
+		{
+			tool: "asar_extract",
+			method: "handleAsarExtract"
+		},
+		{
+			tool: "electron_inspect_app",
+			method: "handleElectronInspectApp"
+		},
+		{
+			tool: "electron_scan_userdata",
+			method: "handleElectronScanUserdata"
+		},
+		{
+			tool: "asar_search",
+			method: "handleAsarSearch"
+		},
+		{
+			tool: "electron_check_fuses",
+			method: "handleElectronCheckFuses"
+		},
+		{
+			tool: "electron_patch_fuses",
+			method: "handleElectronPatchFuses"
+		},
+		{
+			tool: "v8_bytecode_decompile",
+			method: "handleV8BytecodeDecompile"
+		},
+		{
+			tool: "electron_launch_debug",
+			method: "handleElectronLaunchDebug"
+		},
+		{
+			tool: "electron_debug_status",
+			method: "handleElectronDebugStatus"
+		},
+		{
+			tool: "electron_ipc_sniff",
+			method: "handleElectronIPCSniff"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { PlatformToolHandlers } = await import("./platform-CYeFoTWp.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
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-B6EY9Vm8.mjs

@@ -0,0 +1,57 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as coordinationTools } from "./definitions-BtWSHJ3o.mjs";
+//#region src/server/domains/coordination/manifest.ts
+const DOMAIN = "coordination";
+const DEP_KEY = "coordinationHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(coordinationTools),
+	entries: [
+		{
+			tool: "create_task_handoff",
+			method: "handleCreateTaskHandoff"
+		},
+		{
+			tool: "complete_task_handoff",
+			method: "handleCompleteTaskHandoff"
+		},
+		{
+			tool: "get_task_context",
+			method: "handleGetTaskContext"
+		},
+		{
+			tool: "append_session_insight",
+			method: "handleAppendSessionInsight"
+		},
+		{
+			tool: "save_page_snapshot",
+			method: "handleSavePageSnapshot"
+		},
+		{
+			tool: "restore_page_snapshot",
+			method: "handleRestorePageSnapshot"
+		},
+		{
+			tool: "list_page_snapshots",
+			method: "handleListPageSnapshots"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CoordinationHandlers } = await import("./coordination-DgItD9DL.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
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-B6nKSbyY.mjs

@@ -0,0 +1,95 @@
+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/extension-registry/definitions.ts
+const extensionRegistryTools = [
+	tool("extension_list_installed", (t) => t.desc("List installed extensions from the local extension registry").query()),
+	tool("extension_execute_in_context", (t) => t.desc("Load an extension and execute a named exported context function").string("pluginId", "Plugin identifier").string("contextName", "Exported function or context name").prop("args", {
+		type: "object",
+		description: "Arguments passed to the target context",
+		additionalProperties: true
+	}).requiredOpenWorld("pluginId", "contextName")),
+	tool("extension_reload", (t) => t.desc("Reload an installed extension by unloading and loading it again").string("pluginId", "Plugin identifier").requiredOpenWorld("pluginId")),
+	tool("extension_uninstall", (t) => t.desc("Uninstall an extension from the local extension registry").string("pluginId", "Plugin identifier").required("pluginId").destructive()),
+	tool("webhook", (t) => t.desc("Manage webhook endpoints for external callbacks. Actions: create, list, delete, commands.").enum("action", [
+		"create",
+		"list",
+		"delete",
+		"commands"
+	], "Webhook operation").string("name", "Human-readable webhook name (action=create)").string("path", "URL path for the webhook endpoint (action=create)").string("secret", "Optional HMAC secret for webhook authentication (action=create)").string("url", "Optional external callback URL for webhook forwarding (action=create)").array("events", { type: "string" }, "List of events to subscribe to (action=create)").string("endpointId", "Webhook endpoint identifier (action=delete, commands)").string("status", "Filter commands by status: pending, processing, completed, failed (action=commands)").prop("command", {
+		type: "object",
+		description: "Command to enqueue (action=commands, if provided adds to queue instead of listing)",
+		additionalProperties: true
+	}).required("action"))
+];
+//#endregion
+//#region src/server/domains/extension-registry/manifest.ts
+const DOMAIN = "extension-registry";
+const DEP_KEY = "extensionRegistryHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(extensionRegistryTools),
+	entries: [
+		{
+			tool: "extension_list_installed",
+			method: "handleListInstalled"
+		},
+		{
+			tool: "extension_execute_in_context",
+			method: "handleExecuteInContext"
+		},
+		{
+			tool: "extension_reload",
+			method: "handleReload"
+		},
+		{
+			tool: "extension_uninstall",
+			method: "handleUninstall"
+		},
+		{
+			tool: "webhook",
+			method: "handleWebhookDispatch"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { ExtensionRegistryHandlers } = await import("./handlers-BzgcB4iv.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new ExtensionRegistryHandlers();
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	handlers.startWebhookServer().catch(() => void 0);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations,
+	workflowRule: {
+		patterns: [/\b(extension|plugin|addon|webhook|c2|bluetooth|ble|hid|serial|esp32|registry)\b/i, /(install|uninstall|reload).*(extension|plugin)/i],
+		priority: 70,
+		tools: [
+			"install_extension",
+			"extension_list_installed",
+			"webhook"
+		],
+		hint: "Plugin + webhook C2 + BLE HID + serial flashing pipeline."
+	},
+	prerequisites: { webhook: [{
+		condition: "Webhook listen port must be free",
+		fix: "Pick an unused port via the `port` argument or stop the conflicting service"
+	}] },
+	toolDependencies: [{
+		from: "webhook",
+		to: "extension_list_installed",
+		relation: "suggests",
+		weight: .5
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-BL8AQNPF.mjs

@@ -0,0 +1,106 @@
+import { n as toolLookup, t as ensureBrowserCore } 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/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 registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(canvasTools),
+	entries: [
+		{
+			tool: "canvas_engine_fingerprint",
+			method: "handleFingerprint"
+		},
+		{
+			tool: "canvas_scene_dump",
+			method: "handleSceneDump"
+		},
+		{
+			tool: "canvas_pick_object_at_point",
+			method: "handlePick"
+		},
+		{
+			tool: "canvas_trace_click_handler",
+			method: "handleTraceClick"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { DebuggerManager } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { TraceRecorder } = await import("./TraceRecorder-B41Z5XBj.mjs");
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-C02-gXOh.mjs").then((n) => n.t);
+	const { CanvasToolHandlers } = await import("./handlers-Dz9PYsCa.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
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-BSZvJJmV.mjs

@@ -0,0 +1,47 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { n as hookPresetTools, t as aiHookTools } from "./definitions-C1gCHO0i.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 aiRegistrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: t,
+	entries: [{
+		tool: "ai_hook",
+		method: "handleAIHook"
+	}]
+});
+const presetRegistrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY_PRESET,
+	lookup: t,
+	entries: [{
+		tool: "hook_preset",
+		method: "handleHookPreset"
+	}]
+});
+async function ensure(ctx) {
+	const { AIHookToolHandlers, HookPresetToolHandlers } = await import("./hooks-B1B8NRHL.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: [...aiRegistrations, ...presetRegistrations]
+};
+//#endregion
+export { manifest as default };