@alfe.ai/openclaw-webhooks 0.0.1

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,2 @@
+import plugin from "./plugin.js";
+export { plugin };

package/dist/plugin.d.ts

@@ -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): Promise<void>;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { WebhooksPluginConfig as i, Logger as n, OpenClawPluginApi as r, plugin as t };

package/dist/plugin.js

@@ -0,0 +1,175 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { WebhooksServiceClient } from "@alfe.ai/webhooks";
+//#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 DEFAULT_SOCKET_PATH = join(homedir(), ".alfe", "gateway.sock");
+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",
+	async activate(api) {
+		if (globalThis.__alfeWebhooksPluginActivated) {
+			api.logger.debug("Alfe Webhooks plugin already activated, skipping re-init");
+			return;
+		}
+		globalThis.__alfeWebhooksPluginActivated = true;
+		const log = api.logger;
+		log.info("Alfe Webhooks plugin activating...");
+		const pluginConfig = (api.config ?? {}).plugins?.entries?.["@alfe.ai/openclaw-webhooks"]?.config ?? {};
+		daemonIpcClient = await connectToDaemon(pluginConfig.daemonSocket ?? process.env.ALFE_GATEWAY_SOCKET ?? DEFAULT_SOCKET_PATH, log);
+		const webhooksWsUrl = pluginConfig.webhooksWsUrl ?? process.env.ALFE_WEBHOOKS_WS_URL;
+		const apiKey = pluginConfig.apiKey ?? process.env.ALFE_API_KEY;
+		if (webhooksWsUrl && apiKey) {
+			log.info(`Connecting to webhooks service: ${webhooksWsUrl}`);
+			webhooksClient = new 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
+export { plugin as default };

package/dist/plugin2.d.ts

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

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@alfe.ai/openclaw-webhooks",
+  "version": "0.0.1",
+  "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"
+    },
+    "./plugin": {
+      "import": "./dist/plugin.js",
+      "types": "./dist/plugin.d.ts"
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/plugin.js"
+    ]
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ws": "^8.18.0",
+    "@alfe.ai/webhooks": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}