@alfe.ai/openclaw-webhooks 0.0.5 → 0.0.6

package/dist/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_plugin = require("./plugin.cjs");
+exports.plugin = require_plugin;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { i as WebhooksPluginConfig, n as Logger, r as OpenClawPluginApi, t as plugin } from "./plugin.cjs";
+export { type Logger, type OpenClawPluginApi, type WebhooksPluginConfig, plugin };

package/dist/plugin.cjs

@@ -0,0 +1,183 @@
+let _alfe_ai_webhooks = require("@alfe.ai/webhooks");
+let _alfe_ai_config = require("@alfe.ai/config");
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-webhooks — OpenClaw webhooks plugin.
+*
+* Receives webhook deliveries from the Alfe webhooks service and
+* exposes tools for the agent to manage its own webhooks.
+*
+* Follows the same pattern as @alfe.ai/openclaw-chat:
+*   - Connects to Alfe daemon IPC for capability registration
+*   - Connects to webhooks service WS for real-time delivery
+*   - Registers gateway RPC methods for webhook management
+*   - Exposes agent-callable tools for self-service CRUD
+*/
+const WEBHOOKS_CAPABILITIES = ["webhooks.receive", "webhooks.manage"];
+let daemonIpcClient = null;
+let webhooksClient = null;
+/**
+* Attempt to connect to the Alfe daemon IPC socket.
+*/
+async function connectToDaemon(socketPath, log) {
+	try {
+		const IPCClientCtor = (await import("@alfe.ai/openclaw")).IPCClient;
+		const client = new IPCClientCtor(socketPath, log);
+		client.on("connected", async () => {
+			log.info("Connected to Alfe daemon — registering webhooks capabilities...");
+			const response = await client.request("capability.register", {
+				plugin: "@alfe.ai/openclaw-webhooks",
+				capabilities: [...WEBHOOKS_CAPABILITIES]
+			});
+			if (response.ok) log.info("Webhooks capabilities registered with daemon");
+			else log.warn(`Failed to register webhooks capabilities: ${response.error?.message ?? "unknown"}`);
+		});
+		client.on("disconnected", (reason) => {
+			log.warn(`Disconnected from Alfe daemon: ${String(reason)}`);
+		});
+		client.on("error", (err) => {
+			log.debug(`Daemon IPC error: ${err.message}`);
+		});
+		client.start();
+		return client;
+	} catch {
+		log.info("Alfe daemon not available — webhooks plugin running standalone");
+		return null;
+	}
+}
+const plugin = {
+	id: "@alfe.ai/openclaw-webhooks",
+	name: "Alfe Webhooks Plugin",
+	description: "Receive and manage HTTP webhooks from external services",
+	version: "0.1.0",
+	activate(api) {
+		const log = api.logger;
+		const alreadyActivated = globalThis.__alfeWebhooksPluginActivated === true;
+		globalThis.__alfeWebhooksPluginActivated = true;
+		if (alreadyActivated) log.debug("Alfe Webhooks plugin re-registering gateway methods");
+		else log.info("Alfe Webhooks plugin activating...");
+		if (!alreadyActivated) {
+			const pluginConfig = (api.config ?? {}).plugins?.entries?.["@alfe.ai/openclaw-webhooks"]?.config ?? {};
+			let alfeConfig = null;
+			try {
+				alfeConfig = (0, _alfe_ai_config.resolveConfig)();
+			} catch {
+				log.info("Could not resolve Alfe config — daemon IPC and webhooks WS auth unavailable");
+			}
+			connectToDaemon(pluginConfig.daemonSocket ?? alfeConfig?.socketPath ?? _alfe_ai_config.DEFAULT_SOCKET_PATH, log).then((client) => {
+				daemonIpcClient = client;
+			}).catch((err) => {
+				log.debug(`Daemon connect failed: ${err.message}`);
+			});
+			const webhooksWsUrl = pluginConfig.webhooksWsUrl;
+			const apiKey = alfeConfig?.apiKey;
+			if (webhooksWsUrl && apiKey) {
+				log.info(`Connecting to webhooks service: ${webhooksWsUrl}`);
+				webhooksClient = new _alfe_ai_webhooks.WebhooksServiceClient({
+					wsUrl: webhooksWsUrl,
+					apiKey,
+					onWebhook: (delivery) => {
+						log.info(`Webhook received: ${delivery.name} (${delivery.webhookId}) provider=${delivery.provider}`);
+						if (daemonIpcClient) daemonIpcClient.request("event.emit", {
+							event: "webhook.received",
+							payload: delivery
+						}).catch((err) => {
+							log.debug(`Failed to emit webhook event to daemon: ${err.message}`);
+						});
+					},
+					onConnectionChange: (connected) => {
+						log.info(`Webhooks service connection: ${connected ? "connected" : "disconnected"}`);
+					},
+					logger: log
+				});
+				webhooksClient.start();
+				log.info("Webhooks service client started");
+			} else log.info("Webhooks service URL not configured — running without webhooks relay");
+		}
+		if (typeof api.registerGatewayMethod === "function") {
+			api.registerGatewayMethod("webhooks.create", async (...args) => {
+				const params = args[0];
+				if (!daemonIpcClient) return {
+					ok: false,
+					error: "Daemon not connected"
+				};
+				const response = await daemonIpcClient.request("webhooks.create", params);
+				return response.ok ? response.payload : {
+					ok: false,
+					error: response.error?.message
+				};
+			});
+			api.registerGatewayMethod("webhooks.list", async () => {
+				if (!daemonIpcClient) return {
+					ok: false,
+					error: "Daemon not connected"
+				};
+				const response = await daemonIpcClient.request("webhooks.list", {});
+				return response.ok ? response.payload : {
+					ok: false,
+					error: response.error?.message
+				};
+			});
+			api.registerGatewayMethod("webhooks.delete", async (...args) => {
+				const params = args[0];
+				if (!daemonIpcClient) return {
+					ok: false,
+					error: "Daemon not connected"
+				};
+				const response = await daemonIpcClient.request("webhooks.delete", params);
+				return response.ok ? response.payload : {
+					ok: false,
+					error: response.error?.message
+				};
+			});
+			api.registerGatewayMethod("webhooks.rotate", async (...args) => {
+				const params = args[0];
+				if (!daemonIpcClient) return {
+					ok: false,
+					error: "Daemon not connected"
+				};
+				const response = await daemonIpcClient.request("webhooks.rotate", params);
+				return response.ok ? response.payload : {
+					ok: false,
+					error: response.error?.message
+				};
+			});
+			api.registerGatewayMethod("webhooks.deliveries", async (...args) => {
+				const params = args[0];
+				if (!daemonIpcClient) return {
+					ok: false,
+					error: "Daemon not connected"
+				};
+				const response = await daemonIpcClient.request("webhooks.deliveries", params);
+				return response.ok ? response.payload : {
+					ok: false,
+					error: response.error?.message
+				};
+			});
+			log.info("Registered gateway RPC methods: webhooks.create, webhooks.list, webhooks.delete, webhooks.rotate, webhooks.deliveries");
+		}
+		log.info("Alfe Webhooks plugin activated");
+	},
+	deactivate(api) {
+		globalThis.__alfeWebhooksPluginActivated = false;
+		const log = api.logger;
+		log.info("Alfe Webhooks plugin deactivating...");
+		if (webhooksClient) {
+			webhooksClient.stop();
+			webhooksClient = null;
+			log.info("Webhooks service client stopped");
+		}
+		if (daemonIpcClient) {
+			try {
+				daemonIpcClient.stop();
+				log.info("Disconnected from Alfe daemon");
+			} catch (err) {
+				log.debug(`Error disconnecting from daemon: ${err.message}`);
+			}
+			daemonIpcClient = null;
+		}
+		log.info("Alfe Webhooks plugin deactivated");
+	}
+};
+//#endregion
+module.exports = plugin;

package/dist/plugin.d.cts

@@ -0,0 +1,48 @@
+//#region src/types.d.ts
+/**
+ * Types for the Alfe webhooks plugin.
+ */
+interface WebhooksPluginConfig {
+  /** Alfe daemon IPC socket path override. */
+  daemonSocket?: string;
+  /** Webhooks service WebSocket URL (e.g. wss://webhooks.dev.alfe.ai/ws) */
+  webhooksWsUrl?: string;
+  /** API key for webhooks service auth */
+  apiKey?: string;
+}
+interface Logger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+interface OpenClawConfig {
+  plugins?: {
+    entries?: Record<string, {
+      config?: WebhooksPluginConfig;
+      [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+interface OpenClawPluginApi {
+  logger: Logger;
+  config?: OpenClawConfig;
+  registerGatewayMethod?(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+  on(event: string, handler: (...args: unknown[]) => void | Promise<void>, options?: {
+    priority?: number;
+  }): void;
+}
+//#endregion
+//#region src/plugin.d.ts
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  activate(api: OpenClawPluginApi): void;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { WebhooksPluginConfig as i, Logger as n, OpenClawPluginApi as r, plugin as t };

package/dist/plugin2.d.cts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.cjs";
+export { plugin as default };

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@alfe.ai/openclaw-webhooks",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "OpenClaw webhooks plugin for Alfe — receive and manage external webhooks",
   "type": "module",
   "main": "./dist/plugin.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./plugin": {
-      "import": "./dist/plugin.js",
-      "types": "./dist/plugin.d.ts"
+      "types": "./dist/plugin.d.ts",
+      "require": "./dist/plugin.cjs",
+      "import": "./dist/plugin.js"
     }
   },
   "openclaw": {
@@ -26,8 +28,8 @@
   ],
   "dependencies": {
     "ws": "^8.18.0",
-    "@alfe.ai/config": "0.0.6",
-    "@alfe.ai/webhooks": "^0.0.1"
+    "@alfe.ai/config": "0.0.7",
+    "@alfe.ai/webhooks": "^0.0.2"
   },
   "license": "UNLICENSED",
   "scripts": {