@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/manifest-C5qDjysN.mjs

@@ -0,0 +1,107 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { i as tokenBudgetTools, n as cacheTools, r as extensionTools, t as artifactTools } from "./definitions-ClJLzsJQ.mjs";
+//#region src/server/domains/maintenance/manifest.ts
+const DOMAIN = "maintenance";
+const DEP_KEY = "coreMaintenanceHandlers";
+const EXT_DEP_KEY = "extensionManagementHandlers";
+const t = toolLookup([
+	...tokenBudgetTools,
+	...cacheTools,
+	...artifactTools,
+	...extensionTools
+]);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const be = (invoke) => bindByDepKey(EXT_DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CoreMaintenanceHandlers, ExtensionManagementHandlers } = await import("./maintenance-P7ePRXQC.mjs");
+	if (!ctx.coreMaintenanceHandlers || !ctx.extensionManagementHandlers) {
+		if (!ctx.coreMaintenanceHandlers) ctx.coreMaintenanceHandlers = new CoreMaintenanceHandlers({
+			tokenBudget: ctx.tokenBudget,
+			unifiedCache: ctx.unifiedCache
+		});
+		if (!ctx.extensionManagementHandlers) ctx.extensionManagementHandlers = new ExtensionManagementHandlers(ctx);
+	}
+	return ctx.coreMaintenanceHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	secondaryDepKeys: ["extensionManagementHandlers"],
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("get_token_budget_stats"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleGetTokenBudgetStats()),
+			profiles: ["workflow", "full"]
+		},
+		{
+			tool: t("manual_token_cleanup"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleManualTokenCleanup())
+		},
+		{
+			tool: t("reset_token_budget"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleResetTokenBudget())
+		},
+		{
+			tool: t("get_cache_stats"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleGetCacheStats()),
+			profiles: ["workflow", "full"]
+		},
+		{
+			tool: t("smart_cache_cleanup"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSmartCacheCleanup(a.targetSize))
+		},
+		{
+			tool: t("clear_all_caches"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleClearAllCaches())
+		},
+		{
+			tool: t("cleanup_artifacts"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCleanupArtifacts({
+				retentionDays: a.retentionDays,
+				maxTotalBytes: a.maxTotalBytes,
+				dryRun: a.dryRun
+			}))
+		},
+		{
+			tool: t("doctor_environment"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleEnvironmentDoctor({ includeBridgeHealth: a.includeBridgeHealth }))
+		},
+		{
+			tool: t("list_extensions"),
+			domain: DOMAIN,
+			bind: be((h) => h.handleListExtensions()),
+			profiles: ["workflow", "full"]
+		},
+		{
+			tool: t("reload_extensions"),
+			domain: DOMAIN,
+			bind: be((h) => h.handleReloadExtensions())
+		},
+		{
+			tool: t("browse_extension_registry"),
+			domain: DOMAIN,
+			bind: be((h, a) => h.handleBrowseExtensionRegistry(a.kind ?? "all")),
+			profiles: ["workflow", "full"]
+		},
+		{
+			tool: t("install_extension"),
+			domain: DOMAIN,
+			bind: be((h, a) => h.handleInstallExtension(a.slug, a.targetDir))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-C9RT5nk32.mjs

@@ -0,0 +1,34 @@
+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/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 t = toolLookup(sandboxTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { SandboxToolHandlers } = await import("./handlers-DxGIq15_2.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: [{
+		tool: t("execute_sandbox_script"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleExecuteSandboxScript(a))
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CAhOuvSl.mjs

@@ -0,0 +1,204 @@
+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/binary-instrument/definitions.ts
+const binaryInstrumentTools = [
+	tool("frida_attach", (t) => t.desc("Attach Frida to a local process, PID, or binary path and create a binary inst...").string("target", "Process name, PID, or binary path to attach to").required("target")),
+	tool("frida_enumerate_modules", (t) => t.desc("Enumerate modules for an attached Frida session.").string("sessionId", "Session id returned by frida_attach").required("sessionId").query()),
+	tool("ghidra_analyze", (t) => t.desc("Run binary metadata analysis with Ghidra headless when available, with struct...").number("timeout", "Optional timeout in milliseconds for headless analysis").required("binaryPath")),
+	tool("generate_hooks", (t) => t.desc("Generate a Frida interceptor script for a list of symbols.").array("symbols", { type: "string" }, "Symbol names to hook").object("options", {
+		includeArgs: {
+			type: "boolean",
+			description: "Emit argument logging on function entry"
+		},
+		includeRetAddr: {
+			type: "boolean",
+			description: "Emit return-address logging on function entry"
+		}
+	}, "Optional Frida hook generation flags").required("symbols")),
+	tool("unidbg_emulate", (t) => t.desc("Attempt to emulate a native function with unidbg, or return structured mock o...").string("functionName", "Function name to emulate").array("args", { type: "string" }, "Optional string arguments forwarded to emulation").required("binaryPath", "functionName")),
+	tool("frida_run_script", (t) => t.desc("Execute a Frida JavaScript snippet inside an attached Frida session.").string("sessionId", "Session id returned by frida_attach").string("script", "Frida JavaScript to execute").required("sessionId", "script")),
+	tool("frida_detach", (t) => t.desc("Detach from a Frida session and clean up resources.").string("sessionId", "Session id returned by frida_attach").required("sessionId")),
+	tool("frida_list_sessions", (t) => t.desc("List all active Frida sessions.").query()),
+	tool("frida_generate_script", (t) => t.desc("Generate a Frida interceptor script from templates (trace, intercept, replace, log).").string("target", "Target binary or module name").string("template", "Hook template type: trace, intercept, replace, log").string("functionName", "Function name to generate hook for").required("target", "template")),
+	tool("get_available_plugins", (t) => t.desc("List all available binary analysis plugins (frida, ghidra, ida, jadx).").query()),
+	tool("ghidra_decompile", (t) => t.desc("Decompile a specific function using Ghidra headless analysis.").string("binaryPath", "Path to the binary file").string("functionName", "Function name to decompile").required("binaryPath", "functionName")),
+	tool("ida_decompile", (t) => t.desc("Decompile a function using IDA Pro via plugin bridge.").string("binaryPath", "Path to the binary file").string("functionName", "Function name to decompile").required("binaryPath", "functionName")),
+	tool("jadx_decompile", (t) => t.desc("Decompile an APK class or method using JADX via plugin bridge.").string("apkPath", "Path to the APK file").string("className", "Fully qualified class name").string("methodName", "Method name to decompile").required("apkPath", "className")),
+	tool("unidbg_launch", (t) => t.desc("Launch an ARM/ARM64 .so library in the Unidbg emulator. First call ~3-5s warmup.").string("soPath", "Path to the .so library file").string("arch", "Architecture: arm or arm64").required("soPath")),
+	tool("unidbg_call", (t) => t.desc("Call a JNI function in a running Unidbg emulator session.").string("sessionId", "Session id from unidbg_launch").string("functionName", "JNI function name to call").required("sessionId", "functionName")),
+	tool("unidbg_trace", (t) => t.desc("Get an execution trace from an Unidbg session (full/basic/instruction modes).").string("sessionId", "Session id from unidbg_launch").required("sessionId")),
+	tool("export_hook_script", (t) => t.desc("Export generated hook templates as a complete, runnable Frida script.").string("hookTemplates", "JSON array of hook template objects")),
+	tool("frida_enumerate_functions", (t) => t.desc("Enumerate exported functions for a specific module in a Frida session.").string("sessionId", "Session id returned by frida_attach").string("moduleName", "Module name to enumerate exports from").required("sessionId", "moduleName").query()),
+	tool("frida_find_symbols", (t) => t.desc("Search for symbols matching a pattern in a Frida session using ApiResolver.").string("sessionId", "Session id returned by frida_attach").string("pattern", "Symbol search pattern (e.g. \"exports:*libssl*SSL*\")").required("sessionId", "pattern").query())
+];
+//#endregion
+//#region src/server/domains/binary-instrument/manifest.ts
+const DOMAIN = "binary-instrument";
+const DEP_KEY = "binaryInstrumentHandlers";
+const toolByName = toolLookup(binaryInstrumentTools);
+const bind = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { BinaryInstrumentHandlers } = await import("./handlers-Cgyg6c0U.mjs");
+	const { GhidraAnalyzer, HookGenerator } = await import("./binary-instrument-CXfpx6fT.mjs").then((n) => n.t);
+	let handlers = ctx.getDomainInstance(DEP_KEY);
+	if (!handlers) {
+		handlers = new BinaryInstrumentHandlers(ctx, new GhidraAnalyzer(), new HookGenerator());
+		ctx.setDomainInstance(DEP_KEY, handlers);
+	}
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [
+		{
+			tool: toolByName("frida_attach"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaAttach(args))
+		},
+		{
+			tool: toolByName("frida_enumerate_modules"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaEnumerateModules(args))
+		},
+		{
+			tool: toolByName("ghidra_analyze"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleGhidraAnalyze(args))
+		},
+		{
+			tool: toolByName("generate_hooks"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleGenerateHooks(args))
+		},
+		{
+			tool: toolByName("unidbg_emulate"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleUnidbgEmulate(args))
+		},
+		{
+			tool: toolByName("frida_run_script"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaRunScript(args))
+		},
+		{
+			tool: toolByName("frida_detach"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaDetach(args))
+		},
+		{
+			tool: toolByName("frida_list_sessions"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaListSessions(args))
+		},
+		{
+			tool: toolByName("frida_generate_script"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaGenerateScript(args))
+		},
+		{
+			tool: toolByName("get_available_plugins"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleGetAvailablePlugins(args))
+		},
+		{
+			tool: toolByName("ghidra_decompile"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleGhidraDecompile(args))
+		},
+		{
+			tool: toolByName("ida_decompile"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleIdaDecompile(args))
+		},
+		{
+			tool: toolByName("jadx_decompile"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleJadxDecompile(args))
+		},
+		{
+			tool: toolByName("unidbg_launch"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleUnidbgLaunch(args))
+		},
+		{
+			tool: toolByName("unidbg_call"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleUnidbgCall(args))
+		},
+		{
+			tool: toolByName("unidbg_trace"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleUnidbgTrace(args))
+		},
+		{
+			tool: toolByName("export_hook_script"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleExportHookScript(args))
+		},
+		{
+			tool: toolByName("frida_enumerate_functions"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaEnumerateFunctions(args))
+		},
+		{
+			tool: toolByName("frida_find_symbols"),
+			domain: DOMAIN,
+			bind: bind((handlers, args) => handlers.handleFridaFindSymbols(args))
+		}
+	],
+	workflowRule: {
+		patterns: [/\b(frida|ghidra|ida|unidbg|jadx|binary|disassemb|decompil|dump\s?so)\b/i, /(binary|native|so|dll|elf|apk).*(analyze|hook|instrument|decompile)/i],
+		priority: 88,
+		tools: [
+			"frida_attach",
+			"ghidra_analyze",
+			"generate_hooks",
+			"unidbg_launch"
+		],
+		hint: "Binary analysis pipeline: attach Frida → decompile (Ghidra/IDA/JADX) → generate hook scripts → emulate with Unidbg."
+	},
+	prerequisites: {
+		frida_attach: [{
+			condition: "plugin_frida_bridge must be installed and frida-server reachable",
+			fix: "Install @jshookmcpextension/plugin-frida-bridge; launch frida-server on the target"
+		}],
+		frida_run_script: [{
+			condition: "A Frida session must be active",
+			fix: "Call frida_attach before running a script"
+		}],
+		ghidra_analyze: [{
+			condition: "plugin_ghidra_bridge must be installed with Ghidra headless available",
+			fix: "Install @jshookmcpextension/plugin-ghidra-bridge and configure Ghidra path"
+		}],
+		ida_decompile: [{
+			condition: "plugin_ida_bridge must be installed",
+			fix: "Install @jshookmcpextension/plugin-ida-bridge and provide IDA Pro license"
+		}],
+		jadx_decompile: [{
+			condition: "plugin_jadx_bridge must be installed",
+			fix: "Install @jshookmcpextension/plugin-jadx-bridge"
+		}],
+		unidbg_launch: [{
+			condition: "Java 17+ and unidbg JAR must be reachable",
+			fix: "Install JDK 17+ and download unidbg from its official release"
+		}],
+		generate_hooks: [{
+			condition: "Ghidra analysis output required",
+			fix: "Run ghidra_analyze first and pass the output to generate_hooks"
+		}]
+	},
+	toolDependencies: [{
+		from: "process",
+		to: "binary-instrument",
+		relation: "uses",
+		weight: .6
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CBYWCUBJ.mjs

@@ -0,0 +1,51 @@
+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 streamingTools } from "./definitions-BB_4jnmy.mjs";
+//#region src/server/domains/streaming/manifest.ts
+const DOMAIN = "streaming";
+const DEP_KEY = "streamingHandlers";
+const t = toolLookup(streamingTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { StreamingToolHandlers } = await import("./streaming-BUQ0VJsg.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: [
+		{
+			tool: t("ws_monitor"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWsMonitorDispatch(a))
+		},
+		{
+			tool: t("ws_get_frames"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWsGetFrames(a))
+		},
+		{
+			tool: t("ws_get_connections"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWsGetConnections(a))
+		},
+		{
+			tool: t("sse_monitor_enable"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSseMonitorEnable(a))
+		},
+		{
+			tool: t("sse_get_events"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSseGetEvents(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CFADCRa1.mjs

@@ -0,0 +1,37 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as antidebugTools } from "./definitions-B18eyf0B.mjs";
+//#region src/server/domains/antidebug/manifest.ts
+const DOMAIN = "antidebug";
+const DEP_KEY = "antidebugHandlers";
+const t = toolLookup(antidebugTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { AntiDebugToolHandlers } = await import("./antidebug-CqDTB_uk.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.antidebugHandlers) ctx.antidebugHandlers = new AntiDebugToolHandlers(ctx.collector);
+	return ctx.antidebugHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [{
+		tool: t("antidebug_bypass"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleAntidebugBypass(a))
+	}, {
+		tool: t("antidebug_detect_protections"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleAntiDebugDetectProtections(a))
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CQVhavRF.mjs

@@ -0,0 +1,114 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as processToolDefinitions } from "./definitions-B4rAvHNZ.mjs";
+//#region src/server/domains/process/manifest.ts
+const DOMAIN = "process";
+const DEP_KEY = "processHandlers";
+const t = toolLookup(processToolDefinitions);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const EFFECTIVE_PLATFORM = process.env.JSHOOK_REGISTRY_PLATFORM === "win32" || process.env.JSHOOK_REGISTRY_PLATFORM === "linux" || process.env.JSHOOK_REGISTRY_PLATFORM === "darwin" ? process.env.JSHOOK_REGISTRY_PLATFORM : process.platform;
+async function ensure(ctx) {
+	const { ProcessToolHandlers } = await import("./process-QcbIy5Zq.mjs");
+	if (!ctx.processHandlers) ctx.processHandlers = new ProcessToolHandlers();
+	return ctx.processHandlers;
+}
+const IS_WIN32 = EFFECTIVE_PLATFORM === "win32";
+const WIN32_ONLY_TOOLS = new Set(["check_debug_port"]);
+const allRegistrations = [
+	{
+		tool: t("electron_attach"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleElectronAttach(a))
+	},
+	{
+		tool: t("process_windows"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleProcessWindows(a))
+	},
+	{
+		tool: t("process_check_debug_port"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleProcessCheckDebugPort(a))
+	},
+	{
+		tool: t("process_launch_debug"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleProcessLaunchDebug(a))
+	},
+	{
+		tool: t("memory_read"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryRead(a))
+	},
+	{
+		tool: t("memory_write"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryWrite(a))
+	},
+	{
+		tool: t("memory_scan"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryScan(a))
+	},
+	{
+		tool: t("memory_check_protection"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryCheckProtection(a))
+	},
+	{
+		tool: t("memory_scan_filtered"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryScanFiltered(a))
+	},
+	{
+		tool: t("memory_batch_write"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryBatchWrite(a))
+	},
+	{
+		tool: t("memory_dump_region"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryDumpRegion(a))
+	},
+	{
+		tool: t("memory_list_regions"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryListRegions(a))
+	},
+	{
+		tool: t("memory_audit_export"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleMemoryAuditExport(a))
+	},
+	{
+		tool: t("inject_dll"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleInjectDll(a))
+	},
+	{
+		tool: t("inject_shellcode"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleInjectShellcode(a))
+	},
+	{
+		tool: t("check_debug_port"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleCheckDebugPort(a))
+	},
+	{
+		tool: t("enumerate_modules"),
+		domain: DOMAIN,
+		bind: b((h, a) => h.handleEnumerateModules(a))
+	}
+];
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: IS_WIN32 ? allRegistrations : allRegistrations.filter((r) => !WIN32_ONLY_TOOLS.has(r.tool.name))
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CT7zZBV1.mjs

@@ -0,0 +1,48 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as sharedStateBoardTools } from "./definitions-B3QdlrHv.mjs";
+import { resolve } from "node:path";
+//#region src/server/domains/shared-state-board/manifest.ts
+const DOMAIN = "shared-state-board";
+const DEP_KEY = "sharedStateBoardHandlers";
+const t = toolLookup(sharedStateBoardTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { SharedStateBoardHandlers } = await import("./shared-state-board-DV-dpHFJ.mjs");
+	if (!ctx.sharedStateBoardHandlers) ctx.sharedStateBoardHandlers = new SharedStateBoardHandlers();
+	const scheduler = ctx.getDomainInstance("snapshotScheduler");
+	const stateDir = ctx.getDomainInstance("snapshotStateDir");
+	ctx.sharedStateBoardHandlers.setPersistNotifier(scheduler ? () => scheduler.notifyDirty() : void 0);
+	if (scheduler && stateDir && !ctx.getDomainInstance("sharedStateBoardSnapshotRegistered")) {
+		scheduler.register(resolve(stateDir, "state-board", "current.json"), ctx.sharedStateBoardHandlers.getStore());
+		ctx.setDomainInstance("sharedStateBoardSnapshotRegistered", true);
+	}
+	return ctx.sharedStateBoardHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("state_board"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDispatch(a))
+		},
+		{
+			tool: t("state_board_watch"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWatchDispatch(a))
+		},
+		{
+			tool: t("state_board_io"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleIODispatch(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };