@jshookmcp/jshook 0.3.0 → 0.3.2

package/dist/handlers-BzgcB4iv.mjs

@@ -1,799 +0,0 @@
-import { kr as WEBHOOK_PROCESS_TIMEOUT_MS } from "./constants-CDZLOoVv.mjs";
-import { n as asJsonResponse } from "./response-CWhh2aLo.mjs";
-import { i as getProjectRoot, r as getExtensionRegistryDir } from "./outputPaths-um7lCRY3.mjs";
-import { a as argString, i as argObject, s as argStringRequired } from "./parse-args-B4cY5Vx5.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({ action: "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 };