@gloablehive/ipad-wechat-plugin 2.0.0 → 2.2.0

package/README.md

@@ -114,6 +114,12 @@ All JuHeBot API parameters use **snake_case**:
 
 ## Version History
 
+### 2.1.0
+
+- **Outbound message caching**: Agent replies are written to `@gloablehive/wechat-cache` after successful JuHeBot send (direction: `outbound`, isSelf: `true`)
+- **WS connection pool**: Reuse gateway WebSocket connections instead of opening a new one per RPC call. Pool of up to 3 connections with 30s idle timeout. Reduces connection overhead during `chat.history` polling from ~42 to ~3 connections per message.
+- **Cloudflare named tunnel script**: `scripts/setup-cloudflare-tunnel.sh` for permanent tunnel URL that survives restarts. Auto-updates JuHeBot `notifyUrl` on start.
+
 ### 2.0.0
 
 - Full end-to-end inbound + outbound message flow

package/dist/index.js

@@ -20,16 +20,19 @@ import { homedir } from "os";
 import { randomUUID } from "crypto";
 import WebSocket from "ws";
 import { defineChannelPluginEntry, buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/core";
-import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady } from "./src/channel.js";
+import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady, getCacheManager } from "./src/channel.js";
 import { getIPadClient } from "./src/client-pool.js";
 /** Read OpenClaw main config from disk so standalone server has full cfg */
 let _cfgCache = null;
+let _cfgCacheTs = 0;
+const CFG_CACHE_TTL_MS = 30_000; // re-read config every 30s to pick up binding changes
 function loadOpenClawConfig() {
-    if (_cfgCache)
+    if (_cfgCache && (Date.now() - _cfgCacheTs) < CFG_CACHE_TTL_MS)
         return _cfgCache;
     try {
         const p = join(homedir(), ".openclaw", "openclaw.json");
         _cfgCache = JSON.parse(readFileSync(p, "utf-8"));
+        _cfgCacheTs = Date.now();
         return _cfgCache;
     }
     catch (err) {
@@ -37,6 +40,24 @@ function loadOpenClawConfig() {
         return null;
     }
 }
+/**
+ * Resolve agentId from config bindings for a given channel/accountId.
+ * Falls back to "main" if no binding matches.
+ */
+function resolveAgentFromBindings(cfg, channel, accountId) {
+    const bindings = cfg?.bindings ?? [];
+    // Try specific match first (channel + accountId)
+    if (accountId) {
+        const specific = bindings.find((b) => b.match?.channel === channel && b.match?.accountId === accountId);
+        if (specific?.agentId)
+            return specific.agentId;
+    }
+    // Then try channel-only match
+    const channelOnly = bindings.find((b) => b.match?.channel === channel && !b.match?.accountId);
+    if (channelOnly?.agentId)
+        return channelOnly.agentId;
+    return "main";
+}
 // ── Gateway WebSocket dispatch ──
 const GATEWAY_PORT = parseInt(process.env.OPENCLAW_GATEWAY_PORT || "18789", 10);
 let _gwReqId = 0;
@@ -84,25 +105,104 @@ function extractReplyText(message) {
  * Open a short-lived WS to the gateway, run a single RPC call, and return the result.
  */
 async function gwRpc(token, method, reqParams) {
+    const conn = await gwPoolAcquire(token);
+    try {
+        const result = await rpcCall(conn, method, reqParams);
+        gwPoolRelease(conn);
+        return result;
+    }
+    catch (err) {
+        // On error, discard this connection from the pool
+        gwPoolDiscard(conn);
+        throw err;
+    }
+}
+// ── Gateway WS Connection Pool ──
+const GW_POOL_MAX = 3;
+const GW_POOL_IDLE_MS = 30_000; // close idle connections after 30s
+const _gwPool = [];
+let _gwPoolTimer = null;
+function _gwPoolStartSweep() {
+    if (_gwPoolTimer)
+        return;
+    _gwPoolTimer = setInterval(() => {
+        const now = Date.now();
+        for (let i = _gwPool.length - 1; i >= 0; i--) {
+            const entry = _gwPool[i];
+            if (!entry.busy && now - entry.lastUsed > GW_POOL_IDLE_MS) {
+                _gwPool.splice(i, 1);
+                try {
+                    entry.ws.close();
+                }
+                catch { }
+            }
+        }
+        if (_gwPool.length === 0 && _gwPoolTimer) {
+            clearInterval(_gwPoolTimer);
+            _gwPoolTimer = null;
+        }
+    }, 10_000);
+}
+async function gwPoolAcquire(token) {
+    // Try to reuse an idle connection with the same token
+    for (const entry of _gwPool) {
+        if (!entry.busy && entry.token === token && entry.ws.readyState === WebSocket.OPEN) {
+            entry.busy = true;
+            entry.lastUsed = Date.now();
+            return entry.ws;
+        }
+    }
+    // Create a new connection
     const url = `ws://127.0.0.1:${GATEWAY_PORT}`;
     const ws = new WebSocket(url, { headers: { Origin: `http://127.0.0.1:${GATEWAY_PORT}` } });
     await new Promise((resolve, reject) => { ws.on("open", resolve); ws.on("error", reject); });
-    try {
-        // Handshake
-        const connectRes = await rpcCall(ws, "connect", {
-            minProtocol: 3, maxProtocol: 3,
-            client: { id: "openclaw-control-ui", version: "1.0.0", mode: "webchat", platform: "node" },
-            scopes: ["operator.admin", "operator.read", "operator.write"],
-            ...(token ? { auth: { token } } : {}),
-        });
-        if (!connectRes)
-            throw new Error("Gateway connect failed");
-        // Execute the method
-        return await rpcCall(ws, method, reqParams);
+    // Handshake
+    const connectRes = await rpcCall(ws, "connect", {
+        minProtocol: 3, maxProtocol: 3,
+        client: { id: "openclaw-control-ui", version: "1.0.0", mode: "webchat", platform: "node" },
+        scopes: ["operator.admin", "operator.read", "operator.write"],
+        ...(token ? { auth: { token } } : {}),
+    });
+    if (!connectRes) {
+        ws.close();
+        throw new Error("Gateway connect failed");
+    }
+    // Evict oldest idle if pool is full
+    if (_gwPool.length >= GW_POOL_MAX) {
+        const idleIdx = _gwPool.findIndex(e => !e.busy);
+        if (idleIdx >= 0) {
+            const evicted = _gwPool.splice(idleIdx, 1)[0];
+            try {
+                evicted.ws.close();
+            }
+            catch { }
+        }
+    }
+    const entry = { ws, token, busy: true, lastUsed: Date.now() };
+    _gwPool.push(entry);
+    // Auto-remove on close/error
+    ws.on("close", () => { const idx = _gwPool.indexOf(entry); if (idx >= 0)
+        _gwPool.splice(idx, 1); });
+    ws.on("error", () => { const idx = _gwPool.indexOf(entry); if (idx >= 0)
+        _gwPool.splice(idx, 1); });
+    _gwPoolStartSweep();
+    return ws;
+}
+function gwPoolRelease(ws) {
+    const entry = _gwPool.find(e => e.ws === ws);
+    if (entry) {
+        entry.busy = false;
+        entry.lastUsed = Date.now();
     }
-    finally {
+}
+function gwPoolDiscard(ws) {
+    const idx = _gwPool.findIndex(e => e.ws === ws);
+    if (idx >= 0)
+        _gwPool.splice(idx, 1);
+    try {
         ws.close();
     }
+    catch { }
 }
 /**
  * Send a single WS RPC request and wait for the response (with 30s timeout).
@@ -187,11 +287,31 @@ async function dispatchViaGateway(params) {
             console.error(`[iPad WeChat] Poll ${i + 1} error:`, pollErr);
         }
     }
-    // Step 4: Send outbound via JuHeBot API
+    // Step 4: Send outbound via JuHeBot API + cache
     if (replyText) {
         try {
             await sendToWeChat(cfg, params.from, replyText, params.accountId);
             console.log(`[iPad WeChat] ✅ Outbound sent to ${params.from}`);
+            // Write outbound message to cache
+            try {
+                const cache = getCacheManager(cfg);
+                const isChatroom = params.from.includes("@chatroom");
+                await cache.onMessage({
+                    messageId: `out_${Date.now()}`,
+                    accountId: params.accountId || "default",
+                    conversationType: isChatroom ? "chatroom" : "friend",
+                    conversationId: params.from,
+                    senderId: params.to || "self",
+                    content: replyText,
+                    messageType: 1,
+                    timestamp: Date.now(),
+                    isSelf: true,
+                    direction: "outbound",
+                });
+            }
+            catch (cacheErr) {
+                console.error("[iPad WeChat] Outbound cache write failed:", cacheErr);
+            }
         }
         catch (sendErr) {
             console.error(`[iPad WeChat] ❌ Outbound send failed:`, sendErr);
@@ -347,10 +467,12 @@ export default defineChannelPluginEntry({
                         const isChatroom = !!msg.roomId;
                         const peerId = isChatroom ? msg.roomId : (msg.fromUser || msg.toUser || "");
                         const peerKind = isChatroom ? "group" : "direct";
-                        let sessionKey = `agent:main:ipad-wechat:${peerKind}:${peerId}`;
+                        const resolvedAgent = resolveAgentFromBindings(cfg, "ipad-wechat");
+                        console.log(`[iPad WeChat] Resolved agent: ${resolvedAgent} (from bindings)`);
+                        let sessionKey = `agent:${resolvedAgent}:ipad-wechat:${peerKind}:${peerId}`;
                         try {
                             const route = buildChannelOutboundSessionRoute({
-                                cfg, agentId: "main", channel: "ipad-wechat",
+                                cfg, agentId: resolvedAgent, channel: "ipad-wechat",
                                 peer: { kind: peerKind, id: peerId },
                                 chatType: peerKind,
                                 from: msg.toUser || "", to: msg.fromUser || "",

package/dist/src/channel.js

@@ -58,7 +58,7 @@ function initializeRegistry(cfg) {
 /**
  * Get or create cache manager
  */
-function getCacheManager(cfg) {
+export function getCacheManager(cfg) {
     if (cacheManager)
         return cacheManager;
     const section = getConfigSection(cfg);

package/index.ts

@@ -21,17 +21,20 @@ import { homedir } from "os";
 import { randomUUID } from "crypto";
 import WebSocket from "ws";
 import { defineChannelPluginEntry, buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/core";
-import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady } from "./src/channel.js";
+import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady, getCacheManager } from "./src/channel.js";
 import { getIPadClient } from "./src/client-pool.js";
 import type { WebhookPayload } from "./src/client.js";
 
 /** Read OpenClaw main config from disk so standalone server has full cfg */
 let _cfgCache: any = null;
+let _cfgCacheTs = 0;
+const CFG_CACHE_TTL_MS = 30_000; // re-read config every 30s to pick up binding changes
 function loadOpenClawConfig(): any {
-  if (_cfgCache) return _cfgCache;
+  if (_cfgCache && (Date.now() - _cfgCacheTs) < CFG_CACHE_TTL_MS) return _cfgCache;
   try {
     const p = join(homedir(), ".openclaw", "openclaw.json");
     _cfgCache = JSON.parse(readFileSync(p, "utf-8"));
+    _cfgCacheTs = Date.now();
     return _cfgCache;
   } catch (err) {
     console.error("[iPad WeChat] Failed to load openclaw.json:", err);
@@ -39,6 +42,27 @@ function loadOpenClawConfig(): any {
   }
 }
 
+/**
+ * Resolve agentId from config bindings for a given channel/accountId.
+ * Falls back to "main" if no binding matches.
+ */
+function resolveAgentFromBindings(cfg: any, channel: string, accountId?: string): string {
+  const bindings: any[] = cfg?.bindings ?? [];
+  // Try specific match first (channel + accountId)
+  if (accountId) {
+    const specific = bindings.find(
+      (b: any) => b.match?.channel === channel && b.match?.accountId === accountId
+    );
+    if (specific?.agentId) return specific.agentId;
+  }
+  // Then try channel-only match
+  const channelOnly = bindings.find(
+    (b: any) => b.match?.channel === channel && !b.match?.accountId
+  );
+  if (channelOnly?.agentId) return channelOnly.agentId;
+  return "main";
+}
+
 // ── Gateway WebSocket dispatch ──
 const GATEWAY_PORT = parseInt(process.env.OPENCLAW_GATEWAY_PORT || "18789", 10);
 let _gwReqId = 0;
@@ -90,25 +114,95 @@ function extractReplyText(message: any): string {
  * Open a short-lived WS to the gateway, run a single RPC call, and return the result.
  */
 async function gwRpc(token: string, method: string, reqParams: any): Promise<any> {
+  const conn = await gwPoolAcquire(token);
+  try {
+    const result = await rpcCall(conn, method, reqParams);
+    gwPoolRelease(conn);
+    return result;
+  } catch (err) {
+    // On error, discard this connection from the pool
+    gwPoolDiscard(conn);
+    throw err;
+  }
+}
+
+// ── Gateway WS Connection Pool ──
+const GW_POOL_MAX = 3;
+const GW_POOL_IDLE_MS = 30_000; // close idle connections after 30s
+const _gwPool: { ws: WebSocket; token: string; busy: boolean; lastUsed: number }[] = [];
+let _gwPoolTimer: ReturnType<typeof setInterval> | null = null;
+
+function _gwPoolStartSweep() {
+  if (_gwPoolTimer) return;
+  _gwPoolTimer = setInterval(() => {
+    const now = Date.now();
+    for (let i = _gwPool.length - 1; i >= 0; i--) {
+      const entry = _gwPool[i];
+      if (!entry.busy && now - entry.lastUsed > GW_POOL_IDLE_MS) {
+        _gwPool.splice(i, 1);
+        try { entry.ws.close(); } catch {}
+      }
+    }
+    if (_gwPool.length === 0 && _gwPoolTimer) {
+      clearInterval(_gwPoolTimer);
+      _gwPoolTimer = null;
+    }
+  }, 10_000);
+}
+
+async function gwPoolAcquire(token: string): Promise<WebSocket> {
+  // Try to reuse an idle connection with the same token
+  for (const entry of _gwPool) {
+    if (!entry.busy && entry.token === token && entry.ws.readyState === WebSocket.OPEN) {
+      entry.busy = true;
+      entry.lastUsed = Date.now();
+      return entry.ws;
+    }
+  }
+
+  // Create a new connection
   const url = `ws://127.0.0.1:${GATEWAY_PORT}`;
   const ws = new WebSocket(url, { headers: { Origin: `http://127.0.0.1:${GATEWAY_PORT}` } });
   await new Promise<void>((resolve, reject) => { ws.on("open", resolve); ws.on("error", reject); });
 
-  try {
-    // Handshake
-    const connectRes = await rpcCall(ws, "connect", {
-      minProtocol: 3, maxProtocol: 3,
-      client: { id: "openclaw-control-ui", version: "1.0.0", mode: "webchat", platform: "node" },
-      scopes: ["operator.admin", "operator.read", "operator.write"],
-      ...(token ? { auth: { token } } : {}),
-    });
-    if (!connectRes) throw new Error("Gateway connect failed");
-
-    // Execute the method
-    return await rpcCall(ws, method, reqParams);
-  } finally {
-    ws.close();
+  // Handshake
+  const connectRes = await rpcCall(ws, "connect", {
+    minProtocol: 3, maxProtocol: 3,
+    client: { id: "openclaw-control-ui", version: "1.0.0", mode: "webchat", platform: "node" },
+    scopes: ["operator.admin", "operator.read", "operator.write"],
+    ...(token ? { auth: { token } } : {}),
+  });
+  if (!connectRes) { ws.close(); throw new Error("Gateway connect failed"); }
+
+  // Evict oldest idle if pool is full
+  if (_gwPool.length >= GW_POOL_MAX) {
+    const idleIdx = _gwPool.findIndex(e => !e.busy);
+    if (idleIdx >= 0) {
+      const evicted = _gwPool.splice(idleIdx, 1)[0];
+      try { evicted.ws.close(); } catch {}
+    }
   }
+
+  const entry = { ws, token, busy: true, lastUsed: Date.now() };
+  _gwPool.push(entry);
+
+  // Auto-remove on close/error
+  ws.on("close", () => { const idx = _gwPool.indexOf(entry); if (idx >= 0) _gwPool.splice(idx, 1); });
+  ws.on("error", () => { const idx = _gwPool.indexOf(entry); if (idx >= 0) _gwPool.splice(idx, 1); });
+
+  _gwPoolStartSweep();
+  return ws;
+}
+
+function gwPoolRelease(ws: WebSocket) {
+  const entry = _gwPool.find(e => e.ws === ws);
+  if (entry) { entry.busy = false; entry.lastUsed = Date.now(); }
+}
+
+function gwPoolDiscard(ws: WebSocket) {
+  const idx = _gwPool.findIndex(e => e.ws === ws);
+  if (idx >= 0) _gwPool.splice(idx, 1);
+  try { ws.close(); } catch {}
 }
 
 /**
@@ -207,11 +301,31 @@ async function dispatchViaGateway(params: {
     }
   }
 
-  // Step 4: Send outbound via JuHeBot API
+  // Step 4: Send outbound via JuHeBot API + cache
   if (replyText) {
     try {
       await sendToWeChat(cfg, params.from, replyText, params.accountId);
       console.log(`[iPad WeChat] ✅ Outbound sent to ${params.from}`);
+
+      // Write outbound message to cache
+      try {
+        const cache = getCacheManager(cfg);
+        const isChatroom = params.from.includes("@chatroom");
+        await cache.onMessage({
+          messageId: `out_${Date.now()}`,
+          accountId: params.accountId || "default",
+          conversationType: isChatroom ? "chatroom" : "friend",
+          conversationId: params.from,
+          senderId: params.to || "self",
+          content: replyText,
+          messageType: 1,
+          timestamp: Date.now(),
+          isSelf: true,
+          direction: "outbound",
+        });
+      } catch (cacheErr) {
+        console.error("[iPad WeChat] Outbound cache write failed:", cacheErr);
+      }
     } catch (sendErr) {
       console.error(`[iPad WeChat] ❌ Outbound send failed:`, sendErr);
     }
@@ -373,10 +487,13 @@ export default defineChannelPluginEntry({
             const peerId = isChatroom ? (msg as any).roomId : (msg.fromUser || msg.toUser || "");
             const peerKind = isChatroom ? "group" : "direct";
 
-            let sessionKey = `agent:main:ipad-wechat:${peerKind}:${peerId}`;
+            const resolvedAgent = resolveAgentFromBindings(cfg, "ipad-wechat");
+            console.log(`[iPad WeChat] Resolved agent: ${resolvedAgent} (from bindings)`);
+
+            let sessionKey = `agent:${resolvedAgent}:ipad-wechat:${peerKind}:${peerId}`;
             try {
               const route = buildChannelOutboundSessionRoute({
-                cfg, agentId: "main", channel: "ipad-wechat",
+                cfg, agentId: resolvedAgent, channel: "ipad-wechat",
                 peer: { kind: peerKind as any, id: peerId },
                 chatType: peerKind as any,
                 from: msg.toUser || "", to: msg.fromUser || "",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://openclaw.ai/schema/plugin.json",
   "id": "ipad-wechat",
   "name": "iPad WeChat",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Connect OpenClaw to iPad WeChat protocol for sending and receiving WeChat messages",
   "author": {
     "name": "gloablehive",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gloablehive/ipad-wechat-plugin",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "type": "module",
   "description": "OpenClaw channel plugin for iPad WeChat protocol - enables sending/receiving WeChat messages through JuHeBot API",
   "main": "index.ts",

package/src/channel.ts

@@ -83,7 +83,7 @@ function initializeRegistry(cfg: OpenClawConfig): void {
 /**
  * Get or create cache manager
  */
-function getCacheManager(cfg: OpenClawConfig): CacheManager {
+export function getCacheManager(cfg: OpenClawConfig): CacheManager {
   if (cacheManager) return cacheManager;
 
   const section = getConfigSection(cfg);