@gloablehive/ipad-wechat-plugin 2.0.0 → 2.1.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,7 +20,7 @@ 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;
@@ -84,25 +84,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 { }
+        }
     }
-    finally {
+    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();
+    }
+}
+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 +266,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);

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,7 +21,7 @@ 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";
 
@@ -90,25 +90,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 +277,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);
     }

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.1.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);