@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/manifest-Sc_0JQ13.mjs

@@ -0,0 +1,418 @@
+import { t as createProgressDebouncer } from "./EventBus-DgPmwpeu.mjs";
+import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+//#region src/server/domains/memory/definitions.ts
+const ScanValueTypeOptions = [
+	"byte",
+	"int8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"double",
+	"string",
+	"hex",
+	"pointer"
+];
+const ScanCompareModeOptions = [
+	"exact",
+	"unknown_initial",
+	"changed",
+	"unchanged",
+	"increased",
+	"decreased",
+	"greater_than",
+	"less_than",
+	"between",
+	"not_equal"
+];
+const memoryScanToolDefinitions = [
+	tool("memory_first_scan", (t) => t.desc("Start a new memory scan session.").string("value", "Value to search for (as string, e.g. \"100\", \"3.14\", \"48 65 6C 6C 6F\")").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").number("alignment", "Alignment in bytes (0=unaligned, 4=4-byte aligned). Default: natural alignment for the type.").number("maxResults", "Maximum results to return (default: 1,000,000)").prop("regionFilter", {
+		type: "object",
+		properties: {
+			writable: {
+				type: "boolean",
+				description: "Only scan writable regions"
+			},
+			executable: {
+				type: "boolean",
+				description: "Only scan executable regions"
+			},
+			moduleOnly: {
+				type: "boolean",
+				description: "Only scan module-backed regions"
+			}
+		},
+		description: "Filter which memory regions to scan"
+	}).requiredOpenWorld("pid", "value", "valueType")),
+	tool("memory_next_scan", (t) => t.desc("Narrow an existing scan session.").enum("mode", [...ScanCompareModeOptions], "Comparison mode").string("value", "Target value for exact/greater_than/less_than/between/not_equal modes").string("value2", "Upper bound value for \"between\" mode").requiredOpenWorld("sessionId", "mode")),
+	tool("memory_unknown_scan", (t) => t.desc("Start an unknown initial value scan.").enum("valueType", [...ScanValueTypeOptions], "Data type to capture").number("alignment", "Alignment in bytes (default: natural for type)").number("maxResults", "Maximum addresses to capture (default: 5,000,000)").prop("regionFilter", {
+		type: "object",
+		properties: {
+			writable: { type: "boolean" },
+			executable: { type: "boolean" },
+			moduleOnly: { type: "boolean" }
+		}
+	}).requiredOpenWorld("pid", "valueType")),
+	tool("memory_pointer_scan", (t) => t.desc("Find pointers to a target address.").string("targetAddress", "Target address to find pointers to (hex, e.g. \"0x7FF612340000\")").number("maxResults", "Maximum results (default: 10,000)").boolean("moduleOnly", "Only scan module-backed regions").required("pid", "targetAddress").query().openWorld()),
+	tool("memory_group_scan", (t) => t.desc("Search for multiple values at known offsets simultaneously.").array("pattern", {
+		type: "object",
+		properties: {
+			offset: {
+				type: "number",
+				description: "Byte offset from base"
+			},
+			value: {
+				type: "string",
+				description: "Expected value at offset"
+			},
+			type: {
+				type: "string",
+				enum: [...ScanValueTypeOptions],
+				description: "Value type at offset"
+			}
+		},
+		required: [
+			"offset",
+			"value",
+			"type"
+		]
+	}, "Array of {offset, value, type} patterns").number("alignment", "Alignment for base address (default: 4)").number("maxResults", "Maximum results (default: 1,000,000)").required("pid", "pattern").query()),
+	tool("memory_scan_session", (t) => t.desc(`Manage scan sessions. Actions: list (all sessions), delete (by sessionId), export (as JSON).`).enum("action", [
+		"list",
+		"delete",
+		"export"
+	], "Session management action").string("sessionId", "Scan session ID (required for delete/export)").required("action")),
+	tool("memory_pointer_chain", (t) => t.desc(`Multi-level pointer chain operations.
+
+Actions:
+- scan: Find pointer chains to a target address
+- validate: Validate chains by re-dereferencing
+- resolve: Resolve a single chain to its current target
+- export: Export chains as JSON`).enum("action", [
+		"scan",
+		"validate",
+		"resolve",
+		"export"
+	], "Chain operation").number("pid", "Target process ID").string("targetAddress", "Target address hex (action=scan)").number("maxDepth", "Max chain depth 1-6 (action=scan, default: 4)").number("maxOffset", "Max offset per level in bytes (action=scan, default: 4096)").boolean("staticOnly", "Only module-relative chains (action=scan, default: false)").array("modules", { type: "string" }, "Only scan specific modules (action=scan)").number("maxResults", "Max chains to return (action=scan, default: 1000)").string("chains", "JSON PointerChain[] (action=validate/export)").string("chain", "JSON single PointerChain (action=resolve)").required("action")),
+	tool("memory_structure_analyze", (t) => t.desc("Analyze memory at an address to infer data structure layout.").string("address", "Base address of the structure (hex)").number("size", "Size to analyze in bytes (default: 256)").array("otherInstances", { type: "string" }, "Additional instance addresses for cross-comparison").boolean("parseRtti", "Whether to attempt RTTI parsing (default: true)").required("pid", "address").query()),
+	tool("memory_vtable_parse", (t) => t.desc("Parse a vtable to enumerate virtual function pointers and resolve them to module+offset. Also attempts RTTI parsing for class name and inheritance hierarchy.").number("pid", "Target process ID").string("vtableAddress", "Address of the vtable (hex)").required("pid", "vtableAddress").query()),
+	tool("memory_structure_export_c", (t) => t.desc("Export an inferred structure as a C-style struct definition with offset comments and type annotations.").string("structure", "JSON string of InferredStruct to export").string("name", "Struct name (defaults to RTTI class name or \"UnknownStruct\")").required("structure").query()),
+	tool("memory_structure_compare", (t) => t.desc("Compare two structure instances to identify which fields differ (dynamic values like health/position) vs which are constant (vtable, type flags). Useful for finding important fields.").number("pid", "Target process ID").string("address1", "First instance address (hex)").string("address2", "Second instance address (hex)").number("size", "Size to compare in bytes (default: 256)").required("pid", "address1", "address2").query()),
+	tool("memory_breakpoint", (t) => t.desc(`Hardware breakpoint operations using x64 debug registers (DR0-DR3). Max 4 concurrent.
+
+Actions:
+- set: Set a breakpoint (requires pid, address, access)
+- remove: Remove by breakpointId
+- list: List all active breakpoints
+- trace: Set temporary breakpoint, collect N hits, then auto-remove`).enum("action", [
+		"set",
+		"remove",
+		"list",
+		"trace"
+	], "Breakpoint operation").number("pid", "Target process ID (action=set/trace)").string("address", "Address hex (action=set/trace)").enum("access", [
+		"read",
+		"write",
+		"readwrite",
+		"execute"
+	], "Access type (action=set/trace)").number("size", "Watch size in bytes (action=set, default: 4)").string("breakpointId", "Breakpoint ID (action=remove)").number("maxHits", "Max hits to collect (action=trace, default: 50)").number("timeoutMs", "Timeout ms (action=trace, default: 10000)").required("action").destructive()),
+	tool("memory_patch_bytes", (t) => t.desc("Write bytes to target process at address. Saves original bytes for undo. Use for runtime code patching.").number("pid", "Target process ID").string("address", "Address to patch (hex)").array("bytes", { type: "number" }, "Byte values to write (e.g. [0x90, 0x90])").required("pid", "address", "bytes").destructive().openWorld()),
+	tool("memory_patch_nop", (t) => t.desc("NOP out instructions at address (replace with 0x90). Useful for disabling checks or jumps.").number("pid", "Target process ID").string("address", "Address to NOP (hex)").number("count", "Number of bytes to NOP").required("pid", "address", "count").destructive()),
+	tool("memory_patch_undo", (t) => t.desc("Undo a previous patch by restoring the original bytes.").string("patchId", "Patch ID to undo").required("patchId").destructive()),
+	tool("memory_code_caves", (t) => t.desc("Find code caves (runs of 0x00 or 0xCC) in executable sections of loaded modules. Returns largest caves first.").number("pid", "Target process ID").number("minSize", "Minimum cave size in bytes (default: 16)").required("pid").query()),
+	tool("memory_write_value", (t) => t.desc("Write a typed value to a memory address. Supports undo via memory_write_undo.").number("pid", "Target process ID").string("address", "Address to write to (hex)").string("value", "Value to write (as string)").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").required("pid", "address", "value", "valueType").destructive()),
+	tool("memory_freeze", (t) => t.desc(`Freeze or unfreeze a memory address. Freeze continuously writes a value to prevent changes; unfreeze stops it.`).enum("action", ["freeze", "unfreeze"], "Freeze operation").number("pid", "Target process ID (action=freeze)").string("address", "Address to freeze hex (action=freeze)").string("value", "Value to maintain (action=freeze)").enum("valueType", [...ScanValueTypeOptions], "Data type (action=freeze)").number("intervalMs", "Write interval ms (action=freeze, default: 100)").string("freezeId", "Freeze ID to remove (action=unfreeze)").required("action").destructive()),
+	tool("memory_dump", (t) => t.desc("Dump memory region as hex with ASCII column. Outputs a formatted hex dump similar to xxd.").number("pid", "Target process ID").string("address", "Start address (hex)").number("size", "Size to dump in bytes (default: 256)").required("pid", "address").query()),
+	tool("memory_speedhack", (t) => t.desc(`Speedhack: hook time APIs to scale process time. Speed 2.0 = 2x faster, 0.5 = half speed.
+
+Actions:
+- apply: Hook and apply speed multiplier (requires pid, speed)
+- set: Adjust speed on active hack (requires pid, speed)`).enum("action", ["apply", "set"], "Speedhack action").number("pid", "Target process ID").number("speed", "Speed multiplier").required("action", "pid", "speed").destructive()),
+	tool("memory_write_history", (t) => t.desc("Undo or redo the last memory write operation.").enum("action", ["undo", "redo"], "History action").required("action").destructive().openWorld()),
+	tool("memory_heap_enumerate", (t) => t.desc("Enumerate all heaps and heap blocks in a process via Toolhelp32 snapshot. Returns heap list with block counts, sizes, and overall statistics.").number("pid", "Target process ID").number("maxBlocks", "Maximum blocks to enumerate per heap (default: 10000)").required("pid").query()),
+	tool("memory_heap_stats", (t) => t.desc("Get detailed heap statistics with size distribution buckets (0-64B, 64B-1KB, 1-64KB, 64KB-1MB, >1MB), fragmentation ratio, and aggregate metrics.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_heap_anomalies", (t) => t.desc("Detect heap anomalies: heap spray patterns (many same-size blocks), possible use-after-free (non-zero free blocks), and suspicious block sizes (0 or >100MB).").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_pe_headers", (t) => t.desc("Parse PE headers (DOS, NT, File, Optional) from a module base address in process memory. Returns machine type, entry point, image base, section count, and data directory info.").number("pid", "Target process ID").string("moduleBase", "Module base address (hex, e.g. \"0x7ff612340000\")").required("pid", "moduleBase").query()),
+	tool("memory_pe_imports_exports", (t) => t.desc("Parse import and/or export tables from a PE module in process memory. Returns DLL names, function names, ordinals, hints, and forwarded exports.").number("pid", "Target process ID").string("moduleBase", "Module base address (hex)").enum("table", [
+		"imports",
+		"exports",
+		"both"
+	], "Which table to parse", { default: "both" }).required("pid", "moduleBase").query()),
+	tool("memory_inline_hook_detect", (t) => t.desc("Detect inline hooks by comparing the first 16 bytes of each exported function on disk vs in memory. Identifies JMP rel32, JMP abs64, PUSH+RET hooks and decodes jump targets.").number("pid", "Target process ID").string("moduleName", "Module name filter (optional — scans all modules if omitted)").required("pid").query()),
+	tool("memory_anticheat_detect", (t) => t.desc("Scan process imports for anti-debug/anti-cheat mechanisms: IsDebuggerPresent, NtQueryInformationProcess, timing checks (QPC, GetTickCount), thread hiding, heap flag checks, and DR register inspection. Each detection includes a bypass suggestion.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_guard_pages", (t) => t.desc("Find all memory regions with PAGE_GUARD protection in a process. Guard pages are often used as anti-tampering mechanisms or stack overflow detection.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_integrity_check", (t) => t.desc("Check executable memory regions against their corresponding on-disk PE files (.text sections) to detect modifications like inline hooks or code patches.").number("pid", "Target process ID").required("pid").query())
+];
+//#endregion
+//#region src/server/domains/memory/manifest.ts
+const DOMAIN = "memory";
+const DEP_KEY = "memoryScanHandlers";
+const IS_WIN32 = (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) === "win32";
+let globalContext = null;
+async function ensure(ctx) {
+	const { MemoryScanHandlers } = await import("./handlers.impl-DS0d9fUw.mjs");
+	globalContext = ctx;
+	const ctxAny = ctx;
+	if (ctxAny[DEP_KEY]) return ctxAny[DEP_KEY];
+	const [memoryScanner, scanSessionManager, pointerChainEngine, structureAnalyzer, codeInjector, memoryController] = await Promise.all([
+		import("./MemoryScanner-Bcpml6II.mjs"),
+		import("./MemoryScanSession-BsDZbLYm.mjs"),
+		import("./PointerChainEngine-BOhyVsjx.mjs"),
+		import("./StructureAnalyzer-DhFaPvRO.mjs"),
+		import("./CodeInjector-Cq8q01kp.mjs"),
+		import("./MemoryController-CbVdCIJF.mjs")
+	]);
+	if (IS_WIN32) {
+		const [hardwareBreakpointEngine, speedhack, heapAnalyzer, peAnalyzer, antiCheatDetector] = await Promise.all([
+			import("./HardwareBreakpoint-B9gZCdFP.mjs"),
+			import("./Speedhack-CqdIFlQl.mjs"),
+			import("./HeapAnalyzer-BLDH0dCv.mjs"),
+			import("./PEAnalyzer-D1lzJ_VG.mjs"),
+			import("./AntiCheatDetector-BNk-EoBt.mjs")
+		]);
+		ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, hardwareBreakpointEngine.hardwareBreakpointEngine, codeInjector.codeInjector, memoryController.memoryController, speedhack.speedhack, heapAnalyzer.heapAnalyzer, peAnalyzer.peAnalyzer, antiCheatDetector.antiCheatDetector, ctx.eventBus);
+	} else ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, null, codeInjector.codeInjector, memoryController.memoryController, null, null, null, null, ctx.eventBus);
+	return ctxAny[DEP_KEY];
+}
+function bindByKey(invoke) {
+	return (deps) => {
+		const handler = deps[DEP_KEY];
+		return (args) => {
+			const _meta = args._meta;
+			let onProgress;
+			if (_meta?.progressToken !== void 0 && globalContext) onProgress = createProgressDebouncer(globalContext.eventBus, _meta.progressToken);
+			return invoke(handler, {
+				...args,
+				onProgress
+			});
+		};
+	};
+}
+function toolByName(name) {
+	const tool = memoryScanToolDefinitions.find((t) => t.name === name);
+	if (!tool) throw new Error(`Memory tool not found: ${name}`);
+	return tool;
+}
+const WIN32_ONLY_TOOLS = new Set([
+	"memory_heap_enumerate",
+	"memory_heap_stats",
+	"memory_heap_anomalies",
+	"memory_pe_headers",
+	"memory_pe_imports_exports",
+	"memory_inline_hook_detect",
+	"memory_anticheat_detect",
+	"memory_guard_pages",
+	"memory_integrity_check",
+	"memory_breakpoint",
+	"memory_speedhack"
+]);
+const allRegistrations = [
+	{
+		tool: toolByName("memory_first_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleFirstScan(a))
+	},
+	{
+		tool: toolByName("memory_next_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleNextScan(a))
+	},
+	{
+		tool: toolByName("memory_unknown_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleUnknownScan(a))
+	},
+	{
+		tool: toolByName("memory_pointer_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePointerScan(a))
+	},
+	{
+		tool: toolByName("memory_group_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleGroupScan(a))
+	},
+	{
+		tool: toolByName("memory_scan_session"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleScanSessionDispatch(a))
+	},
+	{
+		tool: toolByName("memory_pointer_chain"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePointerChainDispatch(a))
+	},
+	{
+		tool: toolByName("memory_structure_analyze"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureAnalyze(a))
+	},
+	{
+		tool: toolByName("memory_vtable_parse"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleVtableParse(a))
+	},
+	{
+		tool: toolByName("memory_structure_export_c"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureExportC(a))
+	},
+	{
+		tool: toolByName("memory_structure_compare"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureCompare(a))
+	},
+	{
+		tool: toolByName("memory_breakpoint"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleBreakpointDispatch(a))
+	},
+	{
+		tool: toolByName("memory_patch_bytes"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchBytes(a))
+	},
+	{
+		tool: toolByName("memory_patch_nop"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchNop(a))
+	},
+	{
+		tool: toolByName("memory_patch_undo"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchUndo(a))
+	},
+	{
+		tool: toolByName("memory_code_caves"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleCodeCaves(a))
+	},
+	{
+		tool: toolByName("memory_write_value"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleWriteValue(a))
+	},
+	{
+		tool: toolByName("memory_freeze"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleFreezeDispatch(a))
+	},
+	{
+		tool: toolByName("memory_dump"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleDump(a))
+	},
+	{
+		tool: toolByName("memory_speedhack"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleSpeedhackDispatch(a))
+	},
+	{
+		tool: toolByName("memory_write_history"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleWriteHistoryDispatch(a))
+	},
+	{
+		tool: toolByName("memory_heap_enumerate"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapEnumerate(a))
+	},
+	{
+		tool: toolByName("memory_heap_stats"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapStats(a))
+	},
+	{
+		tool: toolByName("memory_heap_anomalies"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapAnomalies(a))
+	},
+	{
+		tool: toolByName("memory_pe_headers"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePEHeaders(a))
+	},
+	{
+		tool: toolByName("memory_pe_imports_exports"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePEImportsExports(a))
+	},
+	{
+		tool: toolByName("memory_inline_hook_detect"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleInlineHookDetect(a))
+	},
+	{
+		tool: toolByName("memory_anticheat_detect"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleAntiCheatDetect(a))
+	},
+	{
+		tool: toolByName("memory_guard_pages"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleGuardPages(a))
+	},
+	{
+		tool: toolByName("memory_integrity_check"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleIntegrityCheck(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)),
+	workflowRule: {
+		patterns: [
+			/memory\s*scan/i,
+			/cheat\s*engine/i,
+			/find\s*(value|address|variable|struct)/i,
+			/scan\s*(for|memory)/i,
+			/pointer\s*(chain|scan)/i,
+			/struct(ure)?\s*(analy|infer|dissect)/i,
+			/vtable|rtti/i,
+			/breakpoint|watchpoint|hardware\s*bp/i,
+			/patch\s*(byte|nop|code)/i,
+			/code\s*cave/i,
+			/freeze|unfreeze/i,
+			/speedhack|time\s*(hack|scale)/i,
+			/memory\s*(dump|hex)/i,
+			/undo|redo/i,
+			/heap|堆\s*(分析|枚举|异常)/i,
+			/PE\s*(header|import|export)|inline.*hook/i,
+			/anti.?cheat|anti.?debug|反作弊|反调试/i,
+			/guard\s*page|integrity\s*check|代码完整性/i,
+			/内存\s*(扫描|搜索|分析|结构|断点|注入|冻结|加速|堆|模块|反作弊)/i
+		],
+		priority: 90,
+		tools: [
+			"memory_first_scan",
+			"memory_next_scan",
+			"memory_unknown_scan",
+			"memory_pointer_chain",
+			"memory_structure_analyze",
+			"memory_vtable_parse",
+			"memory_scan_session",
+			...IS_WIN32 ? ["memory_breakpoint", "memory_speedhack"] : [],
+			"memory_patch_bytes",
+			"memory_freeze",
+			"memory_dump",
+			...IS_WIN32 ? [
+				"memory_speedhack",
+				"memory_heap_enumerate",
+				"memory_pe_headers",
+				"memory_anticheat_detect"
+			] : [],
+			"memory_write_history"
+		],
+		hint: IS_WIN32 ? "Memory domain: scan → narrow → pointer chain → structure | breakpoint trace → patch/NOP → freeze | speedhack | heap analysis | PE introspection | anti-cheat detection" : "Memory domain: scan → narrow → pointer chain → structure | patch/NOP → freeze | dump"
+	}
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-gZ4s_UtG.mjs

@@ -0,0 +1,96 @@
+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/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 t = toolLookup(extensionRegistryTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { ExtensionRegistryHandlers } = await import("./handlers-DeLOCd5m.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: [
+		{
+			tool: t("extension_list_installed"),
+			domain: DOMAIN,
+			bind: b((handlers) => handlers.handleListInstalled())
+		},
+		{
+			tool: t("extension_execute_in_context"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleExecuteInContext(args))
+		},
+		{
+			tool: t("extension_reload"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleReload(args))
+		},
+		{
+			tool: t("extension_uninstall"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleUninstall(args))
+		},
+		{
+			tool: t("webhook"),
+			domain: DOMAIN,
+			bind: b((handlers, args) => handlers.handleWebhookDispatch(args))
+		}
+	],
+	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 };