@alfe.ai/openclaw 0.0.1

package/dist/plugin.d.ts

@@ -0,0 +1,38 @@
+import { TSchema } from "@sinclair/typebox";
+
+//#region src/plugin.d.ts
+
+interface ToolDef {
+  name: string;
+  description: string;
+  label: string;
+  parameters: TSchema;
+  execute: (toolCallId: string, params: Record<string, unknown>) => Promise<unknown>;
+}
+interface PluginLogger {
+  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 PluginApi {
+  logger: PluginLogger;
+  config?: {
+    plugins?: {
+      entries?: Record<string, {
+        config?: Record<string, string | undefined>;
+      }>;
+    };
+  };
+  registerTool(tool: ToolDef): void;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  activate(api: PluginApi): void;
+  deactivate(api: PluginApi): void;
+};
+//#endregion
+export { plugin as default };

package/dist/plugin.js

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

package/dist/plugin2.js

@@ -0,0 +1,455 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { Type } from "@sinclair/typebox";
+import { createConnection } from "node:net";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { createLogger } from "@auriclabs/logger";
+//#region src/types.ts
+function isIPCRequest(msg) {
+	return typeof msg === "object" && msg !== null && msg.type === "req" && typeof msg.id === "string" && typeof msg.method === "string";
+}
+function isIPCResponse(msg) {
+	return typeof msg === "object" && msg !== null && typeof msg.id === "string" && typeof msg.ok === "boolean" && !("type" in msg);
+}
+function isIPCEvent(msg) {
+	return typeof msg === "object" && msg !== null && msg.type === "event" && typeof msg.event === "string";
+}
+/** IPC protocol version — must match daemon's PROTOCOL_VERSION */
+const PROTOCOL_VERSION = 1;
+//#endregion
+//#region src/ipc-client.ts
+/**
+* IPC Client — connects to the Alfe gateway daemon via Unix socket.
+*
+* Protocol: newline-delimited JSON over Unix socket.
+*   Request:  { type: 'req', id, method, params }
+*   Response: { id, ok, payload?, error? }
+*   Event:    { type: 'event', event, payload }
+*
+* Features:
+* - Automatic reconnection with exponential backoff (1s → 30s)
+* - Request/response correlation via message ID
+* - Event emission for incoming daemon events + requests
+* - Graceful handling if daemon not running (warns, retries, doesn't crash)
+*/
+const MIN_BACKOFF_MS = 1e3;
+const MAX_BACKOFF_MS = 3e4;
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var IPCClient = class extends EventEmitter {
+	socket = null;
+	socketPath;
+	buffer = "";
+	backoffMs = MIN_BACKOFF_MS;
+	closed = false;
+	_connected = false;
+	reconnectTimer = null;
+	pending = /* @__PURE__ */ new Map();
+	log = createLogger("IpcClient");
+	constructor(socketPath) {
+		super();
+		this.socketPath = socketPath;
+	}
+	get connected() {
+		return this._connected;
+	}
+	/**
+	* Start the IPC connection with auto-reconnect.
+	*/
+	start() {
+		this.closed = false;
+		this.doConnect();
+	}
+	/**
+	* Stop the IPC connection and all timers.
+	*/
+	stop() {
+		this.closed = true;
+		this.clearReconnectTimer();
+		for (const [id, pending] of this.pending) {
+			clearTimeout(pending.timer);
+			pending.resolve({
+				id,
+				ok: false,
+				error: {
+					code: "CLIENT_STOPPED",
+					message: "IPC client stopped"
+				}
+			});
+		}
+		this.pending.clear();
+		if (this.socket) {
+			try {
+				this.socket.end();
+			} catch {}
+			this.socket = null;
+		}
+		this._connected = false;
+	}
+	/**
+	* Send a request to the daemon and wait for a response.
+	*/
+	async request(method, params = {}, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+		if (!this._connected || !this.socket) return {
+			id: "",
+			ok: false,
+			error: {
+				code: "NOT_CONNECTED",
+				message: "Not connected to daemon"
+			}
+		};
+		const id = randomUUID();
+		const request = {
+			type: "req",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				resolve({
+					id,
+					ok: false,
+					error: {
+						code: "TIMEOUT",
+						message: `Request ${method} timed out after ${String(timeoutMs)}ms`
+					}
+				});
+			}, timeoutMs);
+			this.pending.set(id, {
+				resolve,
+				timer
+			});
+			try {
+				const socket = this.socket;
+				if (socket) socket.write(JSON.stringify(request) + "\n");
+			} catch (err) {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				resolve({
+					id,
+					ok: false,
+					error: {
+						code: "SEND_FAILED",
+						message: `Failed to send: ${err instanceof Error ? err.message : String(err)}`
+					}
+				});
+			}
+		});
+	}
+	/**
+	* Send a response to a daemon request.
+	* Used internally by the request event handler.
+	*/
+	sendResponse(response) {
+		if (!this._connected || !this.socket) return;
+		try {
+			this.socket.write(JSON.stringify(response) + "\n");
+		} catch {}
+	}
+	doConnect() {
+		if (this.closed) return;
+		this.log.debug(`Connecting to daemon at ${this.socketPath}...`);
+		this.socket = createConnection(this.socketPath, () => {
+			this.log.info(`Connected to daemon (${this.socketPath})`);
+			this._connected = true;
+			this.backoffMs = MIN_BACKOFF_MS;
+			this.buffer = "";
+			this.emit("connected");
+		});
+		this.socket.on("data", (data) => {
+			this.buffer += data.toString();
+			this.processBuffer();
+		});
+		this.socket.on("close", () => {
+			const wasConnected = this._connected;
+			this._connected = false;
+			for (const [id, pending] of this.pending) {
+				clearTimeout(pending.timer);
+				pending.resolve({
+					id,
+					ok: false,
+					error: {
+						code: "DISCONNECTED",
+						message: "Connection closed"
+					}
+				});
+			}
+			this.pending.clear();
+			if (wasConnected) {
+				this.log.warn("Disconnected from daemon");
+				this.emit("disconnected", "connection closed");
+			}
+			this.scheduleReconnect();
+		});
+		this.socket.on("error", (err) => {
+			if (err.code === "ECONNREFUSED" || err.code === "ENOENT" || err.code === "ECONNRESET") this.log.debug(`Daemon not available: ${err.code}`);
+			else {
+				this.log.error(`IPC socket error: ${err.message}`);
+				this.emit("error", err);
+			}
+		});
+	}
+	processBuffer() {
+		let newlineIdx;
+		while ((newlineIdx = this.buffer.indexOf("\n")) !== -1) {
+			const line = this.buffer.slice(0, newlineIdx).trim();
+			this.buffer = this.buffer.slice(newlineIdx + 1);
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				this.log.warn("Received invalid JSON from daemon");
+				continue;
+			}
+			if (isIPCResponse(parsed)) {
+				this.handleResponse(parsed);
+				continue;
+			}
+			if (isIPCEvent(parsed)) {
+				this.emit("event", parsed.event, parsed.payload);
+				continue;
+			}
+			if (isIPCRequest(parsed)) {
+				this.handleIncomingRequest(parsed);
+				continue;
+			}
+			this.log.debug({ msg: parsed }, "Unhandled message from daemon");
+		}
+	}
+	handleResponse(response) {
+		const pending = this.pending.get(response.id);
+		if (!pending) return;
+		clearTimeout(pending.timer);
+		this.pending.delete(response.id);
+		pending.resolve(response);
+	}
+	handleIncomingRequest(request) {
+		const respond = (partial) => {
+			const response = {
+				id: request.id,
+				...partial
+			};
+			this.sendResponse(response);
+		};
+		this.emit("request", request.method, request.params, respond);
+	}
+	scheduleReconnect() {
+		if (this.closed) return;
+		this.clearReconnectTimer();
+		const delay = this.backoffMs;
+		this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);
+		this.log.debug(`Reconnecting in ${String(delay)}ms...`);
+		this.reconnectTimer = setTimeout(() => {
+			this.doConnect();
+		}, delay);
+	}
+	clearReconnectTimer() {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+	}
+};
+//#endregion
+//#region src/capability-reporter.ts
+const PLUGIN_VERSION = "0.1.0";
+const OPENCLAW_CAPABILITIES = [
+	"sessions",
+	"tools",
+	"plugins"
+];
+/**
+* Register this OpenClaw plugin with the daemon.
+* Should be called on every (re)connect.
+*
+* @returns Registration result or null on failure
+*/
+async function registerWithDaemon(client, log) {
+	const response = await client.request("register", {
+		framework: "openclaw",
+		name: "@alfe.ai/openclaw",
+		version: PLUGIN_VERSION,
+		protocolVersion: 1,
+		capabilities: [...OPENCLAW_CAPABILITIES],
+		pid: process.pid
+	});
+	if (!response.ok) {
+		const err = response.error;
+		if (err?.code === "PROTOCOL_MISMATCH") {
+			log.error(`Daemon protocol version mismatch: ${err.message}`);
+			log.error("Update @alfe.ai/openclaw or the daemon to a compatible version.");
+		} else log.error(`Registration failed: ${err?.message ?? "unknown error"}`);
+		return null;
+	}
+	const result = response.payload;
+	log.info(`Registered with daemon v${result.daemonVersion} (protocol v${String(result.protocolVersion)})`);
+	return result;
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw — OpenClaw plugin for Alfe.
+*
+* Connects to the local Alfe gateway daemon via IPC socket and:
+* 1. Registers OpenClaw capabilities with the daemon on connect
+* 2. Handles incoming requests from the daemon
+* 3. Re-registers on reconnect (daemon may restart)
+* 4. Gracefully handles daemon being unavailable
+*
+* Follows the same plugin pattern as @alfe.ai/openclaw-voice.
+*/
+const DEFAULT_SOCKET_PATH = join(homedir(), ".alfe", "gateway.sock");
+let ipcClient = null;
+let integrationsApiUrl = "";
+let integrationsApiKey = "";
+let pluginAgentId = "";
+function ok(result) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+}
+function errResult(message) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: message })
+	}] };
+}
+function defineTool(def) {
+	return {
+		name: def.name,
+		description: def.description,
+		label: def.name,
+		parameters: def.parameters,
+		execute: async (_toolCallId, params) => {
+			try {
+				return ok(await def.handler(params));
+			} catch (e) {
+				return errResult(e.message);
+			}
+		}
+	};
+}
+async function integrationsApiFetch(path, options) {
+	const url = `${integrationsApiUrl}${path}`;
+	const res = await fetch(url, {
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${integrationsApiKey}`,
+			...options?.headers
+		}
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new Error(`Integrations API ${String(res.status)}: ${text}`);
+	}
+	return res.json();
+}
+const integrationTools = [
+	defineTool({
+		name: "list_integrations",
+		description: "List all integrations installed for this agent, including their status and available config fields.",
+		parameters: Type.Object({}),
+		handler: async () => {
+			return integrationsApiFetch(`/integrations/agents/${pluginAgentId}`);
+		}
+	}),
+	defineTool({
+		name: "get_integration_config",
+		description: "Get the current configuration and editable fields for a specific integration.",
+		parameters: Type.Object({ integrationId: Type.String({ description: "The integration to inspect (e.g. \"voice\", \"slack\")" }) }),
+		handler: async (params) => {
+			const integrationId = params.integrationId;
+			return integrationsApiFetch(`/integrations/agents/${pluginAgentId}/${integrationId}/config`);
+		}
+	}),
+	defineTool({
+		name: "update_integration_config",
+		description: "Update configuration for an installed integration. Only agent-editable fields can be changed.",
+		parameters: Type.Object({
+			integrationId: Type.String({ description: "The integration to update" }),
+			fields: Type.Record(Type.String(), Type.Unknown(), { description: "Key-value pairs of config fields to update" })
+		}),
+		handler: async (params) => {
+			const integrationId = params.integrationId;
+			const fields = params.fields;
+			return integrationsApiFetch(`/integrations/agents/${pluginAgentId}/${integrationId}`, {
+				method: "PATCH",
+				body: JSON.stringify({ config: fields })
+			});
+		}
+	})
+];
+const plugin = {
+	id: "@alfe.ai/openclaw",
+	name: "Alfe OpenClaw Plugin",
+	description: "Connects OpenClaw to the local Alfe gateway daemon",
+	version: "0.1.0",
+	activate(api) {
+		const log = api.logger;
+		log.info("Alfe OpenClaw Plugin activating...");
+		const pluginConfig = (api.config ?? {}).plugins?.entries?.["@alfe.ai/openclaw"]?.config ?? {};
+		const socketPath = pluginConfig.socketPath ?? process.env.ALFE_GATEWAY_SOCKET ?? DEFAULT_SOCKET_PATH;
+		integrationsApiUrl = pluginConfig.apiUrl ?? process.env.ALFE_API_URL ?? "";
+		integrationsApiKey = pluginConfig.apiKey ?? process.env.ALFE_API_KEY ?? "";
+		pluginAgentId = pluginConfig.agentId ?? process.env.ALFE_AGENT_ID ?? "";
+		if (integrationsApiUrl && integrationsApiKey && pluginAgentId) {
+			for (const tool of integrationTools) api.registerTool(tool);
+			log.info(`Registered ${String(integrationTools.length)} integration tools: ${integrationTools.map((t) => t.name).join(", ")}`);
+		} else log.warn("Integration tools not registered — missing apiUrl, apiKey, or agentId config");
+		ipcClient = new IPCClient(socketPath);
+		ipcClient.on("event", (event, payload) => {
+			switch (event) {
+				case "cloud.status": {
+					const status = payload;
+					log.info(`Alfe cloud: ${status.connected ? "connected" : "disconnected"}`);
+					break;
+				}
+				case "daemon.shutdown":
+					log.info("Daemon shutting down — will reconnect when available");
+					break;
+				default: log.debug(`Daemon event: ${event}`, payload);
+			}
+		});
+		ipcClient.on("request", (method, _params, respond) => {
+			log.info(`Daemon request: ${method}`);
+			respond({
+				ok: false,
+				error: {
+					code: "UNKNOWN_METHOD",
+					message: `Plugin does not handle method: ${method}`
+				}
+			});
+		});
+		const client = ipcClient;
+		ipcClient.on("connected", () => {
+			log.info("Connected to Alfe daemon — registering capabilities...");
+			registerWithDaemon(client, log).then((result) => {
+				if (!result) log.error("Failed to register with daemon — commands may not be routed");
+			});
+		});
+		ipcClient.on("disconnected", (reason) => {
+			log.warn(`Disconnected from Alfe daemon: ${reason}`);
+		});
+		ipcClient.on("error", (err) => {
+			log.error(`IPC error: ${err.message}`);
+		});
+		ipcClient.start();
+		log.info(`Alfe OpenClaw Plugin activated (socket: ${socketPath})`);
+	},
+	deactivate(api) {
+		const log = api.logger;
+		log.info("Alfe OpenClaw Plugin deactivating...");
+		if (ipcClient) {
+			ipcClient.stop();
+			ipcClient = null;
+		}
+		log.info("Alfe OpenClaw Plugin deactivated");
+	}
+};
+//#endregion
+export { isIPCEvent as a, PROTOCOL_VERSION as i, registerWithDaemon as n, isIPCRequest as o, IPCClient as r, isIPCResponse as s, plugin as t };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@alfe.ai/openclaw",
+  "version": "0.0.1",
+  "description": "OpenClaw plugin for Alfe — connects to local gateway daemon via IPC for integration management",
+  "type": "module",
+  "main": "./dist/index.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"
+    ]
+  },
+  "dependencies": {
+    "@auriclabs/logger": "^0.1.1",
+    "@sinclair/typebox": "^0.34.48",
+    "@alfe.ai/integrations": "^0.0.1"
+  },
+  "devDependencies": {
+    "@alfe/agent-client": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}