@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/handlers-DeLOCd5m.mjs

@@ -0,0 +1,799 @@
+import { gr as WEBHOOK_PROCESS_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { n as asJsonResponse } from "./response-BQVP-xUn.mjs";
+import { i as getProjectRoot, r as getExtensionRegistryDir } from "./outputPaths-B1uGmrWZ.mjs";
+import { a as argString, i as argObject, s as argStringRequired } from "./parse-args-BlRjqlkL.mjs";
+import http from "node:http";
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { mkdir, writeFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
+//#region src/modules/extension-registry/PluginRegistry.ts
+function isRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizeId(value) {
+	const normalized = value.trim().toLowerCase().replace(/\//g, "-").replace(/(?!^@)[^a-z0-9@_-]+/g, "-");
+	return normalized.length > 0 ? normalized : `plugin-${Date.now()}`;
+}
+function toStoredPluginManifest(value) {
+	if (!isRecord$2(value)) return null;
+	const { id, name, version, entry, permissions, status } = value;
+	if (typeof id !== "string" || typeof name !== "string" || typeof version !== "string" || typeof entry !== "string" || status !== "loaded" && status !== "unloaded") return null;
+	return {
+		id,
+		name,
+		version,
+		entry,
+		permissions: Array.isArray(permissions) ? permissions.filter((permission) => typeof permission === "string") : [],
+		status
+	};
+}
+var PluginRegistry = class {
+	rootDir;
+	legacyPluginRoots;
+	useLegacyScanApi;
+	registryFile;
+	moduleCacheDir;
+	installedPlugins = /* @__PURE__ */ new Map();
+	loadedPlugins = /* @__PURE__ */ new Map();
+	constructor(rootDirOrContext = getExtensionRegistryDir(), pluginRoots = []) {
+		const resolvedRootDir = typeof rootDirOrContext === "string" ? rootDirOrContext : getExtensionRegistryDir();
+		this.useLegacyScanApi = typeof rootDirOrContext !== "string";
+		this.rootDir = resolvedRootDir;
+		this.registryFile = path.join(resolvedRootDir, "plugins.json");
+		this.moduleCacheDir = path.join(resolvedRootDir, "modules");
+		this.legacyPluginRoots = pluginRoots.length > 0 ? pluginRoots : process.env["JSHOOKMCP_PLUGIN_ROOT"] ? [process.env["JSHOOKMCP_PLUGIN_ROOT"]] : [];
+		if (this.useLegacyScanApi) return;
+		this.initializeFromDisk();
+	}
+	async register(plugin) {
+		const pluginId = sanitizeId(plugin.id || plugin.name);
+		const manifest = {
+			id: pluginId,
+			name: plugin.name,
+			version: plugin.version,
+			entry: plugin.entry,
+			permissions: plugin.permissions ? [...plugin.permissions] : [],
+			status: this.loadedPlugins.has(pluginId) ? "loaded" : "unloaded"
+		};
+		this.installedPlugins.set(pluginId, manifest);
+		await this.persist();
+		return pluginId;
+	}
+	async unregister(pluginId) {
+		await this.unloadPlugin(pluginId);
+		this.installedPlugins.delete(pluginId);
+		await this.persist();
+	}
+	listInstalled() {
+		return [...this.installedPlugins.values()].map((plugin) => ({
+			id: plugin.id,
+			name: plugin.name,
+			version: plugin.version,
+			status: plugin.status,
+			permissions: [...plugin.permissions]
+		})).toSorted((left, right) => left.name.localeCompare(right.name));
+	}
+	async loadPlugin(pluginId) {
+		const manifest = this.installedPlugins.get(pluginId);
+		if (!manifest) throw new Error(`Plugin not found: ${pluginId}`);
+		const existing = this.loadedPlugins.get(pluginId);
+		if (existing) return {
+			manifest: this.toPublicManifest(existing.manifest),
+			exports: existing.exports
+		};
+		const importUrl = pathToFileURL(await this.resolveEntryPath(manifest));
+		importUrl.searchParams.set("ts", String(Date.now()));
+		const moduleExports = await import(importUrl.href);
+		const exportsRecord = isRecord$2(moduleExports) ? moduleExports : {};
+		manifest.status = "loaded";
+		this.loadedPlugins.set(pluginId, {
+			manifest,
+			exports: exportsRecord
+		});
+		await this.persist();
+		return {
+			manifest: this.toPublicManifest(manifest),
+			exports: exportsRecord
+		};
+	}
+	async unloadPlugin(pluginId) {
+		const manifest = this.installedPlugins.get(pluginId);
+		if (!manifest) return;
+		this.loadedPlugins.delete(pluginId);
+		manifest.status = "unloaded";
+		await this.persist();
+	}
+	initializeFromDisk() {
+		if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true });
+		if (!existsSync(this.moduleCacheDir)) mkdirSync(this.moduleCacheDir, { recursive: true });
+		if (!existsSync(this.registryFile)) return;
+		const content = readFileSync(this.registryFile, "utf8");
+		if (!content.trim()) return;
+		const parsed = JSON.parse(content);
+		if (!Array.isArray(parsed)) return;
+		for (const item of parsed) {
+			const manifest = toStoredPluginManifest(item);
+			if (manifest) this.installedPlugins.set(manifest.id, manifest);
+		}
+	}
+	async persist() {
+		await mkdir(this.rootDir, { recursive: true });
+		await mkdir(this.moduleCacheDir, { recursive: true });
+		await writeFile(this.registryFile, JSON.stringify([...this.installedPlugins.values()], null, 2), "utf8");
+	}
+	async resolveEntryPath(manifest) {
+		if (manifest.entry.startsWith("http://") || manifest.entry.startsWith("https://")) return this.downloadRemoteModule(manifest.id, manifest.entry);
+		if (manifest.entry.startsWith("file://")) return fileURLToPath(new URL(manifest.entry));
+		return path.isAbsolute(manifest.entry) ? manifest.entry : path.resolve(getProjectRoot(), manifest.entry);
+	}
+	async downloadRemoteModule(pluginId, url) {
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to download plugin module: ${response.status} ${response.statusText}`);
+		const source = await response.text();
+		const outputPath = path.join(this.moduleCacheDir, `${sanitizeId(pluginId)}.mjs`);
+		await mkdir(this.moduleCacheDir, { recursive: true });
+		await writeFile(outputPath, source, "utf8");
+		return outputPath;
+	}
+	toPublicManifest(manifest) {
+		return {
+			id: manifest.id,
+			name: manifest.name,
+			version: manifest.version,
+			entry: manifest.entry,
+			permissions: [...manifest.permissions]
+		};
+	}
+	listPlugins() {
+		const plugins = [];
+		for (const root of this.legacyPluginRoots) {
+			if (!existsSync(root)) continue;
+			const entries = readdirSync(root, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+				const packageJsonPath = path.join(root, entry.name, "package.json");
+				if (!existsSync(packageJsonPath)) continue;
+				try {
+					const manifest = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+					const plugin = this.toLegacyPluginInfo(manifest);
+					if (plugin) plugins.push(plugin);
+				} catch {
+					continue;
+				}
+			}
+		}
+		return plugins;
+	}
+	searchPlugins(query) {
+		const normalized = query.trim().toLowerCase();
+		if (!normalized) return this.listPlugins();
+		return this.listPlugins().filter((plugin) => {
+			return plugin.name.toLowerCase().includes(normalized) || (plugin.description ?? "").toLowerCase().includes(normalized) || (plugin.capabilities ?? []).some((capability) => capability.toLowerCase().includes(normalized)) || (plugin.dependencies ?? []).some((dependency) => dependency.toLowerCase().includes(normalized));
+		});
+	}
+	async installPlugin(source) {
+		if (/^https:\/\/github\.com\/.+\.git$/u.test(source) || /^git@github\.com:.+\.git$/u.test(source)) return {
+			id: "git-plugin",
+			name: source.split("/").pop()?.replace(/\.git$/u, "") ?? "plugin",
+			version: "0.0.0"
+		};
+		if (source.includes("://") || source.startsWith("git@") || source === "invalid-url") throw new Error("Invalid git URL");
+		if (source.startsWith("/") || source.includes("\\")) {
+			const packageJsonPath = path.join(source, "package.json");
+			if (!existsSync(packageJsonPath)) throw new Error("No package.json");
+			const manifest = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			const plugin = this.toLegacyPluginInfo(manifest);
+			if (!plugin) throw new Error("No package.json");
+			return plugin;
+		}
+		for (const root of this.legacyPluginRoots) {
+			const packageJsonPath = path.join(root, source, "package.json");
+			if (!existsSync(packageJsonPath)) continue;
+			const manifest = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			const plugin = this.toLegacyPluginInfo(manifest);
+			if (plugin) return plugin;
+		}
+		throw new Error("Plugin not found");
+	}
+	getPluginInfo(pluginId) {
+		return this.listPlugins().find((plugin) => plugin.id === pluginId || plugin.name === pluginId);
+	}
+	getPluginDependencies(pluginId) {
+		return this.getPluginInfo(pluginId)?.dependencies ?? [];
+	}
+	async uninstallPlugin(_pluginId) {}
+	toLegacyPluginInfo(manifest) {
+		if (typeof manifest["name"] !== "string") return null;
+		const dependencies = isRecord$2(manifest["dependencies"]) ? Object.keys(manifest["dependencies"]) : [];
+		return {
+			id: sanitizeId(manifest["name"]),
+			name: manifest["name"],
+			version: typeof manifest["version"] === "string" ? manifest["version"] : "0.0.0",
+			description: typeof manifest["description"] === "string" ? manifest["description"] : void 0,
+			capabilities: Array.isArray(manifest["capabilities"]) ? manifest["capabilities"].filter((value) => typeof value === "string") : void 0,
+			dependencies
+		};
+	}
+};
+//#endregion
+//#region src/modules/extension-registry/WebhookBridge.ts
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function toWebhookRecord(value) {
+	if (!isRecord$1(value)) return null;
+	const { id, url, events, active } = value;
+	if (typeof id !== "string" || typeof url !== "string" || !Array.isArray(events) || typeof active !== "boolean") return null;
+	return {
+		id,
+		url,
+		events: events.filter((event) => typeof event === "string"),
+		active
+	};
+}
+var WebhookBridge = class {
+	rootDir;
+	storageFile;
+	webhooks = /* @__PURE__ */ new Map();
+	constructor(rootDir = getExtensionRegistryDir()) {
+		this.rootDir = rootDir;
+		this.storageFile = path.join(rootDir, "webhooks.json");
+		this.initializeFromDisk();
+	}
+	async registerWebhook(url, events) {
+		new URL(url);
+		const record = {
+			id: `webhook-${Date.now()}-${this.webhooks.size + 1}`,
+			url,
+			events: [...new Set(events.filter((event) => event.trim().length > 0))],
+			active: true
+		};
+		this.webhooks.set(record.id, record);
+		await this.persist();
+		return record.id;
+	}
+	async sendEvent(event, payload) {
+		const deliveries = [...this.webhooks.values()].filter((record) => record.active && (record.events.includes(event) || record.events.includes("*")));
+		for (const record of deliveries) {
+			const response = await fetch(record.url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					event,
+					payload,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				})
+			});
+			if (!response.ok) throw new Error(`Webhook delivery failed for ${record.url}: ${response.status} ${response.statusText}`);
+		}
+	}
+	listWebhooks() {
+		return [...this.webhooks.values()].map((record) => ({
+			id: record.id,
+			url: record.url,
+			events: [...record.events],
+			active: record.active
+		}));
+	}
+	/**
+	* Register an external callback URL for a webhook endpoint.
+	* Used when webhook_create registers an endpoint — the URL is stored
+	* here so emitEvent() can forward events to external callbacks.
+	*/
+	registerExternalCallback(endpointId, url) {
+		const existing = this.webhooks.get(endpointId);
+		if (existing) {
+			existing.url = url;
+			return;
+		}
+		this.webhooks.set(endpointId, {
+			id: endpointId,
+			url,
+			events: ["*"],
+			active: true
+		});
+	}
+	initializeFromDisk() {
+		if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true });
+		if (!existsSync(this.storageFile)) return;
+		const content = readFileSync(this.storageFile, "utf8");
+		if (!content.trim()) return;
+		const parsed = JSON.parse(content);
+		if (!Array.isArray(parsed)) return;
+		for (const item of parsed) {
+			const record = toWebhookRecord(item);
+			if (record) this.webhooks.set(record.id, record);
+		}
+	}
+	async persist() {
+		await mkdir(this.rootDir, { recursive: true });
+		await writeFile(this.storageFile, JSON.stringify([...this.webhooks.values()], null, 2), "utf8");
+	}
+};
+//#endregion
+//#region src/server/webhook/CommandQueue.impl.ts
+function cloneCommand(command) {
+	return { ...command };
+}
+function normalizeTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+var CommandQueueImpl = class extends EventEmitter {
+	maxQueueSize;
+	commands = /* @__PURE__ */ new Map();
+	order = [];
+	maxRetries;
+	retryDelay;
+	processTimeout;
+	nextId = 1;
+	constructor(options = {}) {
+		super();
+		this.maxQueueSize = typeof options.maxQueueSize === "number" ? options.maxQueueSize : 1e3;
+		this.maxRetries = typeof options.maxRetries === "number" ? options.maxRetries : 3;
+		this.retryDelay = typeof options.retryDelay === "number" ? options.retryDelay : 0;
+		this.processTimeout = typeof options.processTimeout === "number" ? options.processTimeout : WEBHOOK_PROCESS_TIMEOUT_MS;
+	}
+	enqueue(command) {
+		if (this.order.length >= this.maxQueueSize) throw new Error(`Command queue is full (${this.maxQueueSize})`);
+		const id = `cmd-${this.nextId}`;
+		this.nextId += 1;
+		const createdAt = normalizeTimestamp();
+		const entry = {
+			id,
+			endpointId: command.endpointId,
+			event: command.event,
+			payload: command.payload,
+			status: "pending",
+			retries: 0,
+			createdAt,
+			updatedAt: createdAt
+		};
+		this.commands.set(id, entry);
+		this.order.push(id);
+		this.emit("enqueued", cloneCommand(entry));
+		return id;
+	}
+	dequeue(filter) {
+		if (!filter) {
+			const firstPending = this.getCommandsByFilter({ status: "pending" })[0];
+			return firstPending ? cloneCommand(firstPending) : void 0;
+		}
+		return this.getCommandsByFilter(filter).map(cloneCommand);
+	}
+	getStatus(id) {
+		const command = this.commands.get(id);
+		if (!command) return "failed";
+		if (command.status === "processed") return "completed";
+		return command.status;
+	}
+	retry(id) {
+		const command = this.commands.get(id);
+		if (!command) throw new Error(`Command ${id} not found`);
+		if (command.status !== "failed") throw new Error(`Command ${id} is not in failed state`);
+		command.status = "pending";
+		command.retries = 0;
+		command.lastError = void 0;
+		command.updatedAt = normalizeTimestamp();
+	}
+	getCommand(id) {
+		return this.commands.get(id);
+	}
+	getCommandsByFilter(filter) {
+		const normalizedStatus = filter.status === "completed" ? "processed" : filter.status;
+		const results = [];
+		for (const id of this.order) {
+			const command = this.commands.get(id);
+			if (!command) continue;
+			if (normalizedStatus && command.status !== normalizedStatus) continue;
+			if (filter.endpointId && command.endpointId !== filter.endpointId) continue;
+			results.push(command);
+		}
+		return results;
+	}
+	updateStatus(id, status, lastError) {
+		const command = this.commands.get(id);
+		if (!command) throw new Error(`Command ${id} not found`);
+		command.status = status;
+		command.updatedAt = normalizeTimestamp();
+		command.lastError = lastError;
+		return command;
+	}
+};
+var CommandQueue = class extends CommandQueueImpl {
+	async process(id, handler) {
+		const command = this.getCommand(id);
+		if (!command) throw new Error(`Command ${id} not found`);
+		if (command.status === "processed") throw new Error(`Command ${id} already processed`);
+		if (command.status === "failed") throw new Error(`Command ${id} already processed with failure`);
+		if (command.status === "processing") throw new Error(`Command ${id} is already processing`);
+		this.updateStatus(id, "processing");
+		let finalStatus = "processed";
+		let lastError;
+		try {
+			await Promise.race([Promise.resolve(handler(cloneCommand(command))), new Promise((_, reject) => {
+				setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("Process timeout"));
+				}, this.processTimeout);
+			})]);
+		} catch (error) {
+			lastError = error instanceof Error ? error.message : String(error);
+			if (command.retries + 1 >= this.maxRetries) finalStatus = "failed";
+			else finalStatus = "pending";
+		}
+		if (lastError !== void 0 && this.retryDelay > 0) setTimeout(() => {}, this.retryDelay);
+		if (finalStatus === "processed") {
+			const processed = this.updateStatus(id, "processed");
+			this.emit("processed", cloneCommand(processed));
+		} else if (finalStatus === "pending") {
+			command.retries += 1;
+			const retried = this.updateStatus(id, "pending", lastError);
+			this.emit("retried", cloneCommand(retried));
+			throw lastError !== void 0 ? new Error(lastError) : /* @__PURE__ */ new Error("retry");
+		} else {
+			const failed = this.updateStatus(id, "failed", lastError);
+			this.emit("failed", cloneCommand(failed));
+			throw lastError !== void 0 ? new Error(lastError) : /* @__PURE__ */ new Error("failed");
+		}
+	}
+	async retry(id) {
+		super.retry(id);
+	}
+	exportState() {
+		const results = [];
+		for (const id of this.order) {
+			const command = this.commands.get(id);
+			if (command) results.push(cloneCommand(command));
+		}
+		return results;
+	}
+	importState(commands) {
+		this.commands.clear();
+		this.order.length = 0;
+		let maxId = 0;
+		for (const command of commands) {
+			const entry = cloneCommand(command);
+			this.commands.set(entry.id, entry);
+			this.order.push(entry.id);
+			const match = /^cmd-(\d+)$/.exec(entry.id);
+			if (match && match[1]) {
+				const num = parseInt(match[1], 10);
+				if (num > maxId) maxId = num;
+			}
+		}
+		if (maxId > 0) this.nextId = maxId + 1;
+	}
+};
+//#endregion
+//#region src/server/webhook/WebhookServer.impl.ts
+function isWebhookEvent(value) {
+	return value === "tool_called" || value === "domain_activated" || value === "evidence_added" || value === "workflow_completed";
+}
+function parseJsonBody(rawBody) {
+	if (rawBody.length === 0) return {};
+	try {
+		return JSON.parse(rawBody);
+	} catch {
+		return { rawBody };
+	}
+}
+var WebhookServerImpl = class extends EventEmitter {
+	endpoints = /* @__PURE__ */ new Map();
+	eventHandlers = /* @__PURE__ */ new Map();
+	port;
+	commandQueue;
+	stats = {
+		eventsRegistered: 0,
+		webhooksSent: 0
+	};
+	server;
+	nextEndpointId = 1;
+	constructor(options = {}) {
+		super();
+		this.port = typeof options.port === "number" ? options.port : 18789;
+		this.commandQueue = options.commandQueue;
+	}
+	registerEndpoint(config) {
+		const id = `ep-${this.nextEndpointId}`;
+		this.nextEndpointId += 1;
+		this.endpoints.set(id, {
+			id,
+			path: config.path,
+			method: config.method ?? "POST",
+			secret: config.secret
+		});
+		this.emit("endpointRegistered", id);
+		return id;
+	}
+	removeEndpoint(id) {
+		if (!this.endpoints.delete(id)) throw new Error(`Endpoint ${id} not found`);
+		this.emit("endpointRemoved", id);
+	}
+	listEndpoints() {
+		return [...this.endpoints.values()].map((endpoint) => ({ ...endpoint }));
+	}
+	getPort() {
+		return this.port;
+	}
+	isRunning() {
+		return this.server !== void 0;
+	}
+	registerEvent(event, handler) {
+		const handlers = this.eventHandlers.get(event) ?? [];
+		handlers.push(handler);
+		this.eventHandlers.set(event, handlers);
+		this.stats.eventsRegistered += 1;
+	}
+	start() {
+		if (this.server) throw new Error("Webhook server already started");
+		this.server = http.createServer((request, response) => {
+			this.handleRequest(request, response);
+		});
+		this.server.listen(this.port);
+		this.emit("started", this.port);
+	}
+	async stop() {
+		if (!this.server) return;
+		const server = this.server;
+		this.server = void 0;
+		await new Promise((resolve, reject) => {
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		this.emit("stopped");
+	}
+	async sendWebhook(url, event, payload) {
+		await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				event,
+				payload
+			})
+		});
+		this.stats.webhooksSent += 1;
+		this.stats.lastSentAt = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+	async handleRequest(request, response) {
+		const method = request.method ?? "GET";
+		const url = request.url ?? "/";
+		const endpoint = [...this.endpoints.values()].find((item) => item.path === url && item.method === method);
+		if (!endpoint) {
+			response.statusCode = 404;
+			response.end("not found");
+			return;
+		}
+		if (endpoint.secret) {
+			if (request.headers["x-webhook-secret"] !== endpoint.secret) {
+				response.statusCode = 401;
+				response.end("unauthorized");
+				return;
+			}
+		}
+		const chunks = [];
+		await new Promise((resolve, reject) => {
+			request.setEncoding("utf8");
+			request.on("data", (chunk) => {
+				chunks.push(chunk);
+			});
+			request.on("end", () => {
+				resolve();
+			});
+			request.on("error", (error) => {
+				reject(error);
+			});
+		});
+		const payload = parseJsonBody(chunks.join(""));
+		if (this.commandQueue) this.commandQueue.enqueue({
+			endpointId: endpoint.id,
+			payload
+		});
+		if (payload && typeof payload === "object" && "event" in payload && typeof payload.event === "string") await this.invokeEventHandlers(payload.event, payload);
+		response.setHeader("content-type", "application/json");
+		response.end(JSON.stringify({
+			ok: true,
+			endpointId: endpoint.id
+		}));
+	}
+	async invokeEventHandlers(eventName, payload) {
+		if (!isWebhookEvent(eventName)) return;
+		const handlers = this.eventHandlers.get(eventName) ?? [];
+		for (const handler of handlers) await Promise.resolve(handler(payload));
+	}
+};
+var WebhookServer = class extends WebhookServerImpl {};
+//#endregion
+//#region src/server/domains/extension-registry/handlers.impl.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isCallable(value) {
+	return typeof value === "function";
+}
+var ExtensionRegistryHandlers = class {
+	_webhookServer;
+	_commandQueue;
+	constructor(registry, webhook) {
+		this.registry = registry;
+		this.webhook = webhook;
+	}
+	async handleListInstalled() {
+		return asJsonResponse({
+			success: true,
+			plugins: this.getRegistry().listInstalled()
+		});
+	}
+	async handleExecuteInContext(args) {
+		const pluginId = argStringRequired(args, "pluginId");
+		const contextName = argStringRequired(args, "contextName");
+		const contextArgs = argObject(args, "args") ?? {};
+		const { manifest, exports } = await this.getRegistry().loadPlugin(pluginId);
+		const context = this.resolveContext(exports, contextName);
+		if (!context) throw new Error(`Context "${contextName}" was not found in plugin "${pluginId}"`);
+		const result = await Promise.resolve(context(contextArgs));
+		this.emitEvent("extension.executed", {
+			pluginId,
+			contextName
+		});
+		return asJsonResponse({
+			success: true,
+			manifest,
+			contextName,
+			result
+		});
+	}
+	async handleReload(args) {
+		const pluginId = argStringRequired(args, "pluginId");
+		await this.getRegistry().unloadPlugin(pluginId);
+		const loaded = await this.getRegistry().loadPlugin(pluginId);
+		this.emitEvent("extension.reloaded", { pluginId });
+		return asJsonResponse({
+			success: true,
+			pluginId,
+			manifest: loaded.manifest,
+			exportedKeys: Object.keys(loaded.exports).toSorted()
+		});
+	}
+	async handleUninstall(args) {
+		const pluginId = argStringRequired(args, "pluginId");
+		await this.getRegistry().unregister(pluginId);
+		this.emitEvent("extension.uninstalled", { pluginId });
+		return asJsonResponse({
+			success: true,
+			pluginId
+		});
+	}
+	async handleWebhookCreate(args) {
+		const name = argStringRequired(args, "name");
+		const webhookPath = argStringRequired(args, "path");
+		const secret = argString(args, "secret");
+		const events = Array.isArray(args.events) ? args.events.filter((e) => typeof e === "string") : [];
+		const server = this.getWebhookServer();
+		if (!server.isRunning()) server.start();
+		const endpointId = server.registerEndpoint({
+			path: webhookPath,
+			method: "POST",
+			secret: secret ?? void 0
+		});
+		const bridge = this.getWebhook();
+		const baseUrl = `http://localhost:${server.getPort()}${webhookPath}`;
+		bridge.registerExternalCallback(endpointId, baseUrl);
+		return asJsonResponse({
+			success: true,
+			endpointId,
+			url: baseUrl,
+			name,
+			events
+		});
+	}
+	async handleWebhookList() {
+		const server = this.getWebhookServer();
+		return asJsonResponse({
+			success: true,
+			endpoints: server.listEndpoints(),
+			port: server.getPort(),
+			running: server.isRunning()
+		});
+	}
+	async handleWebhookDelete(args) {
+		const endpointId = argStringRequired(args, "endpointId");
+		const server = this.getWebhookServer();
+		try {
+			server.removeEndpoint(endpointId);
+		} catch (err) {
+			throw new Error(`GRACEFUL: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		return asJsonResponse({
+			success: true,
+			endpointId
+		});
+	}
+	async handleWebhookCommands(args) {
+		const endpointId = argStringRequired(args, "endpointId");
+		const status = argString(args, "status");
+		const command = argObject(args, "command");
+		if (command) return asJsonResponse({
+			success: true,
+			commandId: this.getCommandQueue().enqueue({
+				endpointId,
+				payload: command
+			}),
+			status: "pending"
+		});
+		const queue = this.getCommandQueue();
+		const filter = { endpointId };
+		if (status) filter.status = status;
+		const commands = queue.dequeue(filter);
+		return asJsonResponse({
+			success: true,
+			endpointId,
+			commands,
+			count: Array.isArray(commands) ? commands.length : commands ? 1 : 0
+		});
+	}
+	getWebhookServer() {
+		if (!this._webhookServer) {
+			this._commandQueue = new CommandQueue();
+			this._webhookServer = new WebhookServer({ commandQueue: this._commandQueue });
+		}
+		return this._webhookServer;
+	}
+	async startWebhookServer() {
+		const server = this.getWebhookServer();
+		if (!server.isRunning()) server.start();
+	}
+	async stopWebhookServer() {
+		if (this._webhookServer) {
+			await this._webhookServer.stop();
+			this._webhookServer = void 0;
+			this._commandQueue = void 0;
+		}
+	}
+	getRegistry() {
+		if (!this.registry) this.registry = new PluginRegistry();
+		return this.registry;
+	}
+	getWebhook() {
+		if (!this.webhook) this.webhook = new WebhookBridge();
+		return this.webhook;
+	}
+	getCommandQueue() {
+		if (!this._commandQueue) this._commandQueue = new CommandQueue();
+		return this._commandQueue;
+	}
+	emitEvent(event, payload) {
+		this.getWebhook().sendEvent(event, payload).catch(() => void 0);
+	}
+	resolveContext(exportsRecord, contextName) {
+		const directContext = exportsRecord[contextName];
+		if (isCallable(directContext)) return directContext;
+		const defaultExport = exportsRecord.default;
+		if (contextName === "default" && isCallable(defaultExport)) return defaultExport;
+		if (isRecord(defaultExport)) {
+			const nestedContext = defaultExport[contextName];
+			if (isCallable(nestedContext)) return nestedContext;
+		}
+		return null;
+	}
+	async handleWebhookDispatch(args) {
+		const action = argString(args, "action");
+		switch (action) {
+			case "create": return this.handleWebhookCreate(args);
+			case "list": return this.handleWebhookList();
+			case "delete": return this.handleWebhookDelete(args);
+			case "commands": return this.handleWebhookCommands(args);
+			default: return asJsonResponse({ error: `Invalid action: "${action}". Expected one of: create, list, delete, commands` });
+		}
+	}
+};
+//#endregion
+export { ExtensionRegistryHandlers };