@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/manifest-Sc_0JQ13.mjs

@@ -1,418 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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 };