@alfe.ai/openclaw-chat 0.0.1 → 0.0.3

package/dist/plugin.d.ts

@@ -149,6 +149,12 @@ interface AlfePluginConfig {
   daemonSocket?: string;
   /** Agent ID this plugin is associated with. */
   agentId?: string;
+  /** Chat service WebSocket URL (e.g. wss://chat.dev.alfe.ai/ws) */
+  chatWsUrl?: string;
+  /** API key for chat service auth */
+  apiKey?: string;
+  /** OpenClaw local gateway URL override (default: ws://127.0.0.1:18789) */
+  openclawGatewayUrl?: string;
 }
 interface Logger {
   info(msg: string, ...args: unknown[]): void;

package/dist/plugin2.js

@@ -1,5 +1,8 @@
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { ChatServiceClient } from "@alfe.ai/chat";
+import WebSocket from "ws";
+import { randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 //#region src/alfe-channel.ts
@@ -134,6 +137,239 @@ function createAlfeChannelPlugin() {
 	};
 }
 //#endregion
+//#region src/runtime-relay.ts
+/**
+* RuntimeRelay — bridges the chat service to the local OpenClaw runtime.
+*
+* Connects to OpenClaw's local WebSocket server (typically ws://127.0.0.1:18789),
+* performs the protocol handshake, and forwards RPC requests from the chat
+* service to the runtime. Responses and streaming events are routed back
+* via callbacks.
+*
+* Modeled after the voice relay's LocalGatewayClient pattern.
+*/
+const RECONNECT_DELAYS = [
+	500,
+	1e3,
+	2e3,
+	4e3,
+	8e3,
+	15e3,
+	3e4
+];
+var RuntimeRelay = class {
+	ws = null;
+	pending = /* @__PURE__ */ new Map();
+	connected = false;
+	stopped = false;
+	retryCount = 0;
+	retryTimer = null;
+	connectSent = false;
+	wsUrl;
+	token;
+	log;
+	constructor(options) {
+		this.options = options;
+		this.wsUrl = options.wsUrl ?? "ws://127.0.0.1:18789";
+		this.token = options.token ?? "";
+		this.log = options.logger;
+	}
+	get isConnected() {
+		return this.connected && this.ws?.readyState === WebSocket.OPEN;
+	}
+	start() {
+		this.log.debug("RuntimeRelay starting...");
+		this.stopped = false;
+		this.doConnect();
+	}
+	stop() {
+		this.log.debug("RuntimeRelay stopping...");
+		this.stopped = true;
+		if (this.retryTimer) {
+			clearTimeout(this.retryTimer);
+			this.retryTimer = null;
+		}
+		if (this.ws) {
+			try {
+				this.ws.close(1e3);
+			} catch {}
+			this.ws = null;
+		}
+		this.connected = false;
+		this.flushPending(/* @__PURE__ */ new Error("RuntimeRelay stopped"));
+	}
+	/**
+	* Forward an RPC request from the chat service to the runtime.
+	* The response routes back via the callback.
+	*/
+	forwardRequest(msg, onResponse) {
+		if (this.ws?.readyState !== WebSocket.OPEN) {
+			onResponse({
+				id: msg.id,
+				ok: false,
+				error: { message: "Runtime not connected" }
+			});
+			return;
+		}
+		const timeoutMs = msg.method === "agent" ? 13e4 : 3e4;
+		const timer = setTimeout(() => {
+			this.pending.delete(msg.id);
+			onResponse({
+				id: msg.id,
+				ok: false,
+				error: { message: `'${msg.method}' timed out` }
+			});
+		}, timeoutMs);
+		this.pending.set(msg.id, {
+			resolve: (payload) => {
+				clearTimeout(timer);
+				onResponse({
+					id: msg.id,
+					ok: true,
+					payload
+				});
+			},
+			reject: (err) => {
+				clearTimeout(timer);
+				onResponse({
+					id: msg.id,
+					ok: false,
+					error: { message: err.message }
+				});
+			},
+			expectFinal: msg.method === "agent"
+		});
+		this.ws.send(JSON.stringify({
+			type: "req",
+			id: msg.id,
+			method: msg.method,
+			params: msg.params
+		}));
+	}
+	doConnect() {
+		if (this.stopped) return;
+		this.log.info(`Connecting to runtime at ${this.wsUrl}...`);
+		this.ws = new WebSocket(this.wsUrl, { maxPayload: 25 * 1024 * 1024 });
+		this.ws.on("open", () => {
+			this.log.info("Connected to runtime — authenticating...");
+			this.retryCount = 0;
+			setTimeout(() => {
+				this.sendConnect();
+			}, 750);
+		});
+		this.ws.on("message", (data) => {
+			const text = Buffer.isBuffer(data) ? data.toString("utf-8") : Buffer.from(data).toString("utf-8");
+			this.handleMessage(text);
+		});
+		this.ws.on("close", (code) => {
+			this.log.warn(`Runtime disconnected (${String(code)})`);
+			this.connected = false;
+			this.flushPending(/* @__PURE__ */ new Error(`Runtime closed (${String(code)})`));
+			this.scheduleReconnect();
+		});
+		this.ws.on("error", (err) => {
+			this.log.error(`Runtime WS error: ${err.message}`);
+		});
+	}
+	async sendConnect() {
+		if (this.connectSent) return;
+		this.connectSent = true;
+		const id = randomUUID();
+		const timeoutMs = 1e4;
+		try {
+			await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					this.pending.delete(id);
+					reject(/* @__PURE__ */ new Error("Connect handshake timed out"));
+				}, timeoutMs);
+				this.pending.set(id, {
+					resolve: () => {
+						clearTimeout(timer);
+						resolve();
+					},
+					reject: (err) => {
+						clearTimeout(timer);
+						reject(err);
+					},
+					expectFinal: false
+				});
+				this.ws?.send(JSON.stringify({
+					type: "req",
+					id,
+					method: "connect",
+					params: {
+						minProtocol: 3,
+						maxProtocol: 3,
+						client: {
+							id: "chat-relay",
+							displayName: "Alfe Chat Relay",
+							version: "1.0.0",
+							platform: process.platform,
+							mode: "backend",
+							instanceId: `chat-${Date.now().toString(36)}`
+						},
+						caps: [],
+						role: "operator",
+						scopes: ["operator.admin"],
+						auth: this.token ? { token: this.token } : void 0
+					}
+				}));
+			});
+			this.connected = true;
+			this.log.info("Runtime authenticated — relay active");
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			this.log.error(`Runtime connect failed: ${errMsg}`);
+			this.ws?.close(1008, "connect failed");
+		}
+	}
+	handleMessage(raw) {
+		try {
+			const parsed = JSON.parse(raw);
+			if (parsed.event) {
+				const payload = parsed.payload;
+				if (parsed.event === "connect.challenge" && payload?.nonce) {
+					this.connectSent = false;
+					this.sendConnect();
+					return;
+				}
+				if (payload) this.options.onEvent(parsed.event, payload);
+				return;
+			}
+			if ("id" in parsed && "ok" in parsed) {
+				const pending = this.pending.get(parsed.id);
+				if (!pending) return;
+				const payload = parsed.payload;
+				if (pending.expectFinal && payload?.status === "accepted") return;
+				this.pending.delete(parsed.id);
+				if (parsed.ok) pending.resolve(payload);
+				else {
+					const error = parsed.error;
+					pending.reject(new Error(error?.message ?? "unknown error"));
+				}
+			}
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			this.log.error(`Runtime message parse error: ${errMsg}`);
+		}
+	}
+	scheduleReconnect() {
+		if (this.stopped) return;
+		const delay = RECONNECT_DELAYS[Math.min(this.retryCount, RECONNECT_DELAYS.length - 1)];
+		this.retryCount++;
+		this.connectSent = false;
+		this.log.info(`Reconnecting to runtime in ${String(delay)}ms (attempt ${String(this.retryCount)})...`);
+		this.retryTimer = setTimeout(() => {
+			this.retryTimer = null;
+			this.doConnect();
+		}, delay);
+	}
+	flushPending(err) {
+		for (const [, p] of this.pending) p.reject(err);
+		this.pending.clear();
+	}
+};
+//#endregion
 //#region src/session-store.ts
 /**
 * Session Store — persists chat sessions to the local filesystem.
@@ -246,6 +482,8 @@ const CHAT_CAPABILITIES = [
 	"chat.sessions"
 ];
 let daemonIpcClient = null;
+let chatClient = null;
+let runtimeRelay = null;
 /**
 * Attempt to connect to the Alfe daemon IPC socket.
 * Returns null if @alfe.ai/openclaw is not available or daemon is unreachable.
@@ -294,6 +532,41 @@ const plugin = {
 		api.registerChannel(alfeChannel);
 		log.info(`Registered channel: ${alfeChannel.id} (${alfeChannel.meta.label})`);
 		daemonIpcClient = await connectToDaemon(pluginConfig.daemonSocket ?? process.env.ALFE_GATEWAY_SOCKET ?? DEFAULT_SOCKET_PATH, log);
+		const chatWsUrl = pluginConfig.chatWsUrl ?? process.env.ALFE_CHAT_WS_URL;
+		const apiKey = pluginConfig.apiKey ?? process.env.ALFE_API_KEY;
+		const runtimeUrl = pluginConfig.openclawGatewayUrl ?? process.env.OPENCLAW_GATEWAY_URL ?? "ws://127.0.0.1:18789";
+		const runtimeToken = process.env.OPENCLAW_GATEWAY_TOKEN ?? "";
+		if (chatWsUrl && apiKey) {
+			log.info(`Connecting to chat service: ${chatWsUrl}`);
+			runtimeRelay = new RuntimeRelay({
+				wsUrl: runtimeUrl,
+				token: runtimeToken,
+				onEvent: (event, payload) => {
+					chatClient?.sendEvent(event, payload);
+				},
+				logger: log
+			});
+			chatClient = new ChatServiceClient({
+				wsUrl: chatWsUrl,
+				apiKey,
+				onRequest: (request) => {
+					if (!runtimeRelay?.isConnected) {
+						chatClient?.sendResponse(request.id, false, { message: "Runtime not connected" });
+						return;
+					}
+					runtimeRelay.forwardRequest(request, (response) => {
+						chatClient?.send(response);
+					});
+				},
+				onConnectionChange: (connected) => {
+					log.info(`Chat service connection: ${connected ? "connected" : "disconnected"}`);
+				},
+				logger: log
+			});
+			runtimeRelay.start();
+			chatClient.start();
+			log.info("Chat service relay started");
+		} else log.info("Chat service URL not configured — running without chat service relay");
 		if (typeof api.registerGatewayMethod === "function") {
 			api.registerGatewayMethod("chat.send", (...args) => {
 				const { sessionId, content, clientType } = args[0];
@@ -365,6 +638,16 @@ const plugin = {
 		globalThis.__alfeChatPluginActivated = false;
 		const log = api.logger;
 		log.info("Alfe Chat plugin deactivating...");
+		if (chatClient) {
+			chatClient.stop();
+			chatClient = null;
+			log.info("Chat service client stopped");
+		}
+		if (runtimeRelay) {
+			runtimeRelay.stop();
+			runtimeRelay = null;
+			log.info("Runtime relay stopped");
+		}
 		if (daemonIpcClient) {
 			try {
 				daemonIpcClient.stop();

package/openclaw.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "@alfe.ai/openclaw-chat",
+  "channels": ["alfe"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-chat",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -21,13 +21,21 @@
     ]
   },
   "files": [
-    "dist"
+    "dist",
+    "openclaw.plugin.json"
   ],
+  "dependencies": {
+    "ws": "^8.18.0",
+    "@alfe.ai/chat": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13"
+  },
   "license": "UNLICENSED",
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "test": "vitest run",
+    "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "lint": "eslint ."