@gloablehive/ipad-wechat-plugin 1.0.26 → 2.1.0

package/README.md

@@ -0,0 +1,141 @@
+# @gloablehive/ipad-wechat-plugin
+
+OpenClaw channel plugin for iPad WeChat protocol — enables sending and receiving WeChat messages through the JuHeBot API.
+
+## Features
+
+- **Inbound**: Receive WeChat messages via JuHeBot webhook callbacks
+- **Outbound**: Auto-reply via agent → JuHeBot `send_text` API
+- **Multi-account**: Support multiple WeChat accounts via config
+- **Deduplication**: Prevents duplicate message processing (msg_id TTL)
+- **Chatroom support**: Direct messages and group chats
+- **Message caching**: Integrated with `@gloablehive/wechat-cache`
+
+## Architecture
+
+```
+WeChat User
+    ↓ (message)
+JuHeBot Cloud (notify_type=1010)
+    ↓ (HTTP POST callback)
+Cloudflare Tunnel / Public IP
+    ↓
+Standalone HTTP Server (:18790)
+    ↓ transformPayload() + dedup
+Gateway WebSocket (chat.send → chat.history polling)
+    ↓
+OpenClaw Agent (processes message)
+    ↓ (agent reply detected via polling)
+JuHeBot API (/msg/send_text, to_username)
+    ↓
+WeChat User (receives reply)
+```
+
+## Setup
+
+### 1. Install
+
+```bash
+npm install @gloablehive/ipad-wechat-plugin
+```
+
+### 2. Configure OpenClaw
+
+Add to your `openclaw.json` under `plugins.entries`:
+
+```json
+{
+  "ipad-wechat": {
+    "config": {
+      "appKey": "<your-juhebot-app-key>",
+      "appSecret": "<your-juhebot-app-secret>",
+      "guid": "<your-instance-guid>"
+    }
+  }
+}
+```
+
+### 3. Set JuHeBot Notify URL
+
+After the plugin starts (webhook server on port 18790), set the callback URL:
+
+```bash
+curl -X POST "https://chat-api.juhebot.com/open/GuidRequest" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "app_key": "<appKey>",
+    "app_secret": "<appSecret>",
+    "path": "/client/set_notify_url",
+    "data": {
+      "guid": "<guid>",
+      "notify_url": "https://<your-public-url>/"
+    }
+  }'
+```
+
+> Use a Cloudflare tunnel (`cloudflared tunnel --url http://127.0.0.1:18790`) if you don't have a public IP.
+
+### 4. Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `IPAD_WECHAT_WEBHOOK_PORT` | `18790` | Standalone webhook server port |
+| `OPENCLAW_GATEWAY_PORT` | `18789` | OpenClaw gateway WS port |
+
+## JuHeBot API Notes
+
+All JuHeBot API parameters use **snake_case**:
+
+| Method | Path | Key Params |
+|---|---|---|
+| Send text | `/msg/send_text` | `to_username`, `content` |
+| Send room @ | `/msg/send_room_at` | `to_username`, `content`, `at_list` |
+| Set notify URL | `/client/set_notify_url` | `notify_url` |
+
+### Callback Format (notify_type=1010)
+
+```json
+{
+  "guid": "...",
+  "notify_type": 1010,
+  "data": {
+    "from_username": "wxid_xxx",
+    "to_username": "wxid_yyy",
+    "desc": "NickName : message content",
+    "msg_id": "123456",
+    "msg_type": 1,
+    "is_chatroom_msg": 0,
+    "chatroom": ""
+  }
+}
+```
+
+> Note: There is **no `content` field** — text is extracted from `desc` by stripping the `"NickName : "` prefix.
+
+## 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
+- Real JuHeBot callback format support (`desc` field parsing)
+- Fixed all API params to snake_case (`to_username`, `notify_url`)
+- Message deduplication by `msg_id`
+- Chatroom field mapping (`is_chatroom_msg` + `chatroom`)
+- Gateway WS polling strategy for agent reply detection
+- Short-lived WS connections per RPC call
+
+### 1.x
+
+- Initial implementation with webhook receiver
+- Cache integration
+- Multi-account scaffolding
+
+## License
+
+MIT

package/dist/index.js

@@ -20,7 +20,8 @@ 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;
 function loadOpenClawConfig() {
@@ -39,73 +40,287 @@ function loadOpenClawConfig() {
 // ── Gateway WebSocket dispatch ──
 const GATEWAY_PORT = parseInt(process.env.OPENCLAW_GATEWAY_PORT || "18789", 10);
 let _gwReqId = 0;
-function dispatchViaGateway(params) {
-    const cfg = loadOpenClawConfig();
-    const token = cfg?.gateway?.controlUi?.auth?.token || cfg?.gateway?.auth?.token || "";
+/**
+ * Resolve JuHeBot credentials from OpenClaw config and send a text message
+ * to a WeChat user/room via the JuHeBot API.
+ */
+async function sendToWeChat(cfg, toUser, text, accountId) {
+    const entry = cfg?.plugins?.entries?.["ipad-wechat"] || {};
+    const section = entry.config || cfg?.channels?.["ipad-wechat"] || {};
+    const accounts = (section.accounts || []);
+    const account = accounts.find((a) => a.accountId === (accountId || "default")) || accounts[0] || {};
+    const appKey = account.appKey || section.appKey || "";
+    const appSecret = account.appSecret || section.appSecret || "";
+    const guid = account.guid || section.guid || "";
+    if (!appKey || !appSecret || !guid) {
+        throw new Error("Missing JuHeBot credentials (appKey/appSecret/guid)");
+    }
+    const client = getIPadClient(account.accountId || "default", { appKey, appSecret, guid });
+    const isChatroom = toUser.includes("@chatroom");
+    if (isChatroom) {
+        await client.sendRoomMessage({ roomId: toUser, content: text });
+    }
+    else {
+        await client.sendFriendMessage({ friendWechatId: toUser, content: text });
+    }
+}
+/**
+ * Extract text content from a gateway chat event message object.
+ */
+function extractReplyText(message) {
+    if (!message?.content)
+        return "";
+    if (typeof message.content === "string")
+        return message.content;
+    if (Array.isArray(message.content)) {
+        return message.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text || "")
+            .join("\n");
+    }
+    return "";
+}
+/**
+ * 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); });
+    // 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();
+    }
+}
+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).
+ */
+function rpcCall(ws, method, reqParams) {
     return new Promise((resolve, reject) => {
-        const url = `ws://127.0.0.1:${GATEWAY_PORT}`;
-        const ws = new WebSocket(url, { headers: { Origin: `http://127.0.0.1:${GATEWAY_PORT}` } });
-        const timeout = setTimeout(() => { ws.close(); reject(new Error("Gateway dispatch timeout")); }, 30000);
-        let connected = false;
-        let sendId = null;
-        ws.on("open", () => {
-            const connectId = `ipad-wechat-${++_gwReqId}`;
-            ws.send(JSON.stringify({
-                type: "req", id: connectId, method: "connect",
-                params: {
-                    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 } } : {}),
-                },
-            }));
-        });
-        ws.on("message", (data) => {
+        const id = `ipad-wechat-${++_gwReqId}`;
+        const timer = setTimeout(() => { ws.off("message", handler); reject(new Error(`${method} timed out`)); }, 30000);
+        const handler = (data) => {
             try {
                 const frame = JSON.parse(data.toString());
-                if (frame.type === "res" && !connected) {
-                    connected = true;
-                    if (!frame.ok) {
-                        clearTimeout(timeout);
-                        ws.close();
-                        reject(new Error("Gateway connect failed: " + (frame.error?.message || "unknown")));
-                        return;
-                    }
-                    sendId = `ipad-wechat-${++_gwReqId}`;
-                    ws.send(JSON.stringify({
-                        type: "req", id: sendId, method: "chat.send",
-                        params: {
-                            idempotencyKey: randomUUID(),
-                            sessionKey: params.sessionKey,
-                            message: params.message,
-                            deliver: true,
-                            originatingChannel: "ipad-wechat",
-                            originatingTo: params.from,
-                            originatingAccountId: params.accountId || "default",
-                        },
-                    }));
-                }
-                else if (frame.type === "res" && frame.id === sendId) {
-                    clearTimeout(timeout);
-                    ws.close();
-                    if (frame.ok) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error("chat.send failed: " + (frame.error?.message || "unknown")));
-                    }
+                if (frame.type === "res" && frame.id === id) {
+                    clearTimeout(timer);
+                    ws.off("message", handler);
+                    if (frame.ok)
+                        resolve(frame.payload ?? frame);
+                    else
+                        reject(new Error(`${method} failed: ${frame.error?.message || "unknown"}`));
                 }
             }
-            catch { /* ignore parse errors */ }
-        });
-        ws.on("error", (err) => { clearTimeout(timeout); reject(err); });
-        ws.on("close", () => { clearTimeout(timeout); if (!connected)
-            reject(new Error("Gateway closed before connect")); });
+            catch { /* ignore non-matching frames */ }
+        };
+        ws.on("message", handler);
+        ws.send(JSON.stringify({ type: "req", id, method, params: reqParams }));
     });
 }
+/**
+ * Dispatch an inbound message to the agent via the Gateway WebSocket protocol.
+ *
+ * Strategy:
+ * 1. Fire chat.send via a short-lived WS connection (triggers agent)
+ * 2. Poll chat.history via separate WS connections to detect the reply
+ * 3. Extract reply text, strip NO_REPLY token
+ * 4. If there is content, call JuHeBot API to send to WeChat
+ */
+async function dispatchViaGateway(params) {
+    const cfg = loadOpenClawConfig();
+    const token = cfg?.gateway?.controlUi?.auth?.token || cfg?.gateway?.auth?.token || "";
+    // Step 1: Get baseline message count
+    const baselineHistory = await gwRpc(token, "chat.history", {
+        sessionKey: params.sessionKey, limit: 50,
+    });
+    const baselineCount = Array.isArray(baselineHistory?.messages)
+        ? baselineHistory.messages.length : 0;
+    console.log(`[iPad WeChat] Baseline history: ${baselineCount} messages`);
+    // Step 2: Send user message (triggers agent processing)
+    const sendResult = await gwRpc(token, "chat.send", {
+        idempotencyKey: randomUUID(),
+        sessionKey: params.sessionKey,
+        message: params.message,
+        deliver: true,
+        originatingChannel: "ipad-wechat",
+        originatingTo: params.from,
+        originatingAccountId: params.accountId || "default",
+    });
+    console.log(`[iPad WeChat] chat.send accepted, runId=${sendResult?.runId}, polling for reply…`);
+    // Step 3: Poll chat.history via fresh connections
+    const POLL_INTERVAL = 3000;
+    const MAX_POLLS = 40; // 3s × 40 = 120s max
+    let replyText = "";
+    for (let i = 0; i < MAX_POLLS; i++) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        try {
+            const history = await gwRpc(token, "chat.history", {
+                sessionKey: params.sessionKey, limit: 50,
+            });
+            const messages = Array.isArray(history?.messages) ? history.messages : [];
+            if (messages.length <= baselineCount)
+                continue;
+            // Look for new assistant messages after the baseline
+            // chat.history returns messages with role/content at top level
+            const newMessages = messages.slice(baselineCount);
+            const assistantMsg = newMessages.find((m) => m?.role === "assistant" || m?.message?.role === "assistant");
+            if (assistantMsg) {
+                const rawText = extractReplyText(assistantMsg);
+                replyText = rawText.replace(/\s*NO_REPLY\s*/gi, "").trim();
+                console.log(`[iPad WeChat] Agent reply found on poll ${i + 1}: "${replyText.slice(0, 200)}"`);
+                break;
+            }
+        }
+        catch (pollErr) {
+            console.error(`[iPad WeChat] Poll ${i + 1} error:`, pollErr);
+        }
+    }
+    // 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);
+        }
+    }
+    else {
+        console.log("[iPad WeChat] No non-silent agent reply found after polling, skipping outbound");
+    }
+}
 // JuHeBot notify_type constants (from doc-6966894.md)
 const NOTIFY_NEW_MSG = 1010;
 const NOTIFY_BATCH_NEW_MSG = 1011;
+/**
+ * Extract message content from JuHeBot `desc` field.
+ * Real callback format: "NickName : actualContent"
+ * For chatroom: "NickName:\nactualContent"
+ */
+function extractContentFromDesc(desc) {
+    if (!desc)
+        return "";
+    // Private chat: "NickName : content"
+    const colonIdx = desc.indexOf(" : ");
+    if (colonIdx >= 0)
+        return desc.slice(colonIdx + 3);
+    // Chatroom: "NickName:\ncontent"
+    const nlIdx = desc.indexOf(":\n");
+    if (nlIdx >= 0)
+        return desc.slice(nlIdx + 2);
+    return desc;
+}
 /**
  * Transform JuHeBot callback payload → WebhookPayload
  * Handles both JuHeBot native format and our own test format.
@@ -130,11 +345,11 @@ function transformPayload(raw) {
                 messageId: String(m.msg_id ?? m.msgId ?? m.new_msg_id ?? m.newMsgId ?? `msg_${Date.now()}`),
                 fromUser: m.from_username ?? m.fromUsername ?? m.from_user ?? m.fromUser ?? "",
                 toUser: m.to_username ?? m.toUsername ?? m.to_user ?? m.toUser ?? "",
-                content: m.content ?? m.msg_content ?? m.msgContent ?? "",
+                content: m.content ?? m.msg_content ?? m.msgContent ?? extractContentFromDesc(m.desc) ?? "",
                 type: m.msg_type ?? m.msgType ?? m.type ?? 1,
                 timestamp: m.timestamp ?? m.create_time ?? m.createTime ?? Date.now(),
                 isSelf: m.is_self === 1 || m.is_self === true || m.isSelf === true,
-                roomId: m.room_username ?? m.roomUsername ?? m.roomId ?? undefined,
+                roomId: m.room_username ?? m.roomUsername ?? m.roomId ?? (m.is_chatroom_msg === 1 && m.chatroom ? m.chatroom : undefined),
             },
         };
     }
@@ -144,6 +359,22 @@ function transformPayload(raw) {
 }
 const WEBHOOK_PORT = parseInt(process.env.IPAD_WECHAT_WEBHOOK_PORT || "18790", 10);
 let _webhookServerStarted = false;
+// Deduplication: track recently processed msg_ids (TTL 60s)
+const _processedMsgIds = new Map();
+function isDuplicate(msgId) {
+    const now = Date.now();
+    // Prune old entries every check
+    if (_processedMsgIds.size > 500) {
+        for (const [k, t] of _processedMsgIds) {
+            if (now - t > 60000)
+                _processedMsgIds.delete(k);
+        }
+    }
+    if (_processedMsgIds.has(msgId))
+        return true;
+    _processedMsgIds.set(msgId, now);
+    return false;
+}
 export default defineChannelPluginEntry({
     id: "ipad-wechat",
     name: "iPad WeChat",
@@ -202,8 +433,16 @@ export default defineChannelPluginEntry({
                     console.log("[iPad WeChat] Webhook received:", JSON.stringify(raw).slice(0, 500));
                     const payload = transformPayload(raw);
                     if (payload && payload.message) {
+                        // Deduplicate by msg_id
+                        if (isDuplicate(payload.message.messageId)) {
+                            console.log(`[iPad WeChat] Duplicate msg_id=${payload.message.messageId}, skipping`);
+                            res.writeHead(200, { "Content-Type": "text/plain" });
+                            res.end("ok");
+                            return;
+                        }
                         const cfg = loadOpenClawConfig();
                         const msg = payload.message;
+                        console.log(`[iPad WeChat] Parsed: from=${msg.fromUser}, content="${msg.content?.slice(0, 100)}", type=${msg.type}`);
                         const isChatroom = !!msg.roomId;
                         const peerId = isChatroom ? msg.roomId : (msg.fromUser || msg.toUser || "");
                         const peerKind = isChatroom ? "group" : "direct";

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/dist/src/client.js

@@ -64,10 +64,10 @@ export function createIPadClient(config) {
         },
         /**
          * 设置实例通知地址 (回调地址)
-         * Path: /instance/set_notify_url
+         * Path: /client/set_notify_url
          */
         async setNotifyUrl(notifyUrl) {
-            await callApi(config, "/instance/set_notify_url", { notifyUrl });
+            await callApi(config, "/client/set_notify_url", { notify_url: notifyUrl });
         },
         /**
          * 设置实例桥接ID
@@ -180,7 +180,7 @@ export function createIPadClient(config) {
          */
         async sendFriendMessage(params) {
             const res = await callApi(config, "/msg/send_text", {
-                toUser: params.friendWechatId,
+                to_username: params.friendWechatId,
                 content: params.content,
             });
             return {
@@ -194,7 +194,7 @@ export function createIPadClient(config) {
          */
         async sendRoomMessage(params) {
             const res = await callApi(config, "/msg/send_room_at", {
-                roomId: params.roomId,
+                to_username: params.roomId,
                 content: params.content,
             });
             return {
@@ -543,7 +543,7 @@ export const API_PATHS = {
     instanceGetStatus: "/instance/get_status",
     instanceRestore: "/instance/restore",
     instanceStop: "/instance/stop",
-    instanceSetNotifyUrl: "/instance/set_notify_url",
+    instanceSetNotifyUrl: "/client/set_notify_url",
     instanceSetBridgeId: "/instance/set_bridge_id",
     // 用户
     userGetProfile: "/user/get_profile",

package/index.ts

@@ -21,7 +21,8 @@ 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 */
@@ -42,7 +43,177 @@ function loadOpenClawConfig(): any {
 const GATEWAY_PORT = parseInt(process.env.OPENCLAW_GATEWAY_PORT || "18789", 10);
 let _gwReqId = 0;
 
-function dispatchViaGateway(params: {
+/**
+ * Resolve JuHeBot credentials from OpenClaw config and send a text message
+ * to a WeChat user/room via the JuHeBot API.
+ */
+async function sendToWeChat(cfg: any, toUser: string, text: string, accountId?: string): Promise<void> {
+  const entry = cfg?.plugins?.entries?.["ipad-wechat"] || {};
+  const section = entry.config || cfg?.channels?.["ipad-wechat"] || {};
+  const accounts = (section.accounts || []) as any[];
+  const account = accounts.find((a: any) => a.accountId === (accountId || "default")) || accounts[0] || {};
+
+  const appKey = account.appKey || section.appKey || "";
+  const appSecret = account.appSecret || section.appSecret || "";
+  const guid = account.guid || section.guid || "";
+
+  if (!appKey || !appSecret || !guid) {
+    throw new Error("Missing JuHeBot credentials (appKey/appSecret/guid)");
+  }
+
+  const client = getIPadClient(account.accountId || "default", { appKey, appSecret, guid });
+  const isChatroom = toUser.includes("@chatroom");
+
+  if (isChatroom) {
+    await client.sendRoomMessage({ roomId: toUser, content: text });
+  } else {
+    await client.sendFriendMessage({ friendWechatId: toUser, content: text });
+  }
+}
+
+/**
+ * Extract text content from a gateway chat event message object.
+ */
+function extractReplyText(message: any): string {
+  if (!message?.content) return "";
+  if (typeof message.content === "string") return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content
+      .filter((c: any) => c.type === "text")
+      .map((c: any) => c.text || "")
+      .join("\n");
+  }
+  return "";
+}
+
+/**
+ * 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); });
+
+  // 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 {}
+}
+
+/**
+ * Send a single WS RPC request and wait for the response (with 30s timeout).
+ */
+function rpcCall(ws: WebSocket, method: string, reqParams: any): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const id = `ipad-wechat-${++_gwReqId}`;
+    const timer = setTimeout(() => { ws.off("message", handler); reject(new Error(`${method} timed out`)); }, 30000);
+    const handler = (data: Buffer) => {
+      try {
+        const frame = JSON.parse(data.toString());
+        if (frame.type === "res" && frame.id === id) {
+          clearTimeout(timer);
+          ws.off("message", handler);
+          if (frame.ok) resolve(frame.payload ?? frame);
+          else reject(new Error(`${method} failed: ${frame.error?.message || "unknown"}`));
+        }
+      } catch { /* ignore non-matching frames */ }
+    };
+    ws.on("message", handler);
+    ws.send(JSON.stringify({ type: "req", id, method, params: reqParams }));
+  });
+}
+
+/**
+ * Dispatch an inbound message to the agent via the Gateway WebSocket protocol.
+ *
+ * Strategy:
+ * 1. Fire chat.send via a short-lived WS connection (triggers agent)
+ * 2. Poll chat.history via separate WS connections to detect the reply
+ * 3. Extract reply text, strip NO_REPLY token
+ * 4. If there is content, call JuHeBot API to send to WeChat
+ */
+async function dispatchViaGateway(params: {
   sessionKey: string;
   message: string;
   from: string;
@@ -52,63 +223,113 @@ function dispatchViaGateway(params: {
   const cfg = loadOpenClawConfig();
   const token = cfg?.gateway?.controlUi?.auth?.token || cfg?.gateway?.auth?.token || "";
 
-  return new Promise((resolve, reject) => {
-    const url = `ws://127.0.0.1:${GATEWAY_PORT}`;
-    const ws = new WebSocket(url, { headers: { Origin: `http://127.0.0.1:${GATEWAY_PORT}` } });
-    const timeout = setTimeout(() => { ws.close(); reject(new Error("Gateway dispatch timeout")); }, 30000);
-
-    let connected = false;
-    let sendId: string | null = null;
-
-    ws.on("open", () => {
-      const connectId = `ipad-wechat-${++_gwReqId}`;
-      ws.send(JSON.stringify({
-        type: "req", id: connectId, method: "connect",
-        params: {
-          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 } } : {}),
-        },
-      }));
-    });
+  // Step 1: Get baseline message count
+  const baselineHistory = await gwRpc(token, "chat.history", {
+    sessionKey: params.sessionKey, limit: 50,
+  });
+  const baselineCount = Array.isArray(baselineHistory?.messages)
+    ? baselineHistory.messages.length : 0;
+  console.log(`[iPad WeChat] Baseline history: ${baselineCount} messages`);
+
+  // Step 2: Send user message (triggers agent processing)
+  const sendResult = await gwRpc(token, "chat.send", {
+    idempotencyKey: randomUUID(),
+    sessionKey: params.sessionKey,
+    message: params.message,
+    deliver: true,
+    originatingChannel: "ipad-wechat",
+    originatingTo: params.from,
+    originatingAccountId: params.accountId || "default",
+  });
+  console.log(`[iPad WeChat] chat.send accepted, runId=${sendResult?.runId}, polling for reply…`);
 
-    ws.on("message", (data: Buffer) => {
-      try {
-        const frame = JSON.parse(data.toString());
-        if (frame.type === "res" && !connected) {
-          connected = true;
-          if (!frame.ok) { clearTimeout(timeout); ws.close(); reject(new Error("Gateway connect failed: " + (frame.error?.message || "unknown"))); return; }
-          sendId = `ipad-wechat-${++_gwReqId}`;
-          ws.send(JSON.stringify({
-            type: "req", id: sendId, method: "chat.send",
-            params: {
-              idempotencyKey: randomUUID(),
-              sessionKey: params.sessionKey,
-              message: params.message,
-              deliver: true,
-              originatingChannel: "ipad-wechat",
-              originatingTo: params.from,
-              originatingAccountId: params.accountId || "default",
-            },
-          }));
-        } else if (frame.type === "res" && frame.id === sendId) {
-          clearTimeout(timeout);
-          ws.close();
-          if (frame.ok) { resolve(); } else { reject(new Error("chat.send failed: " + (frame.error?.message || "unknown"))); }
-        }
-      } catch { /* ignore parse errors */ }
-    });
+  // Step 3: Poll chat.history via fresh connections
+  const POLL_INTERVAL = 3000;
+  const MAX_POLLS = 40; // 3s × 40 = 120s max
+  let replyText = "";
 
-    ws.on("error", (err) => { clearTimeout(timeout); reject(err); });
-    ws.on("close", () => { clearTimeout(timeout); if (!connected) reject(new Error("Gateway closed before connect")); });
-  });
+  for (let i = 0; i < MAX_POLLS; i++) {
+    await new Promise(r => setTimeout(r, POLL_INTERVAL));
+
+    try {
+      const history = await gwRpc(token, "chat.history", {
+        sessionKey: params.sessionKey, limit: 50,
+      });
+      const messages = Array.isArray(history?.messages) ? history.messages : [];
+
+      if (messages.length <= baselineCount) continue;
+
+      // Look for new assistant messages after the baseline
+      // chat.history returns messages with role/content at top level
+      const newMessages = messages.slice(baselineCount);
+      const assistantMsg = newMessages.find(
+        (m: any) => m?.role === "assistant" || m?.message?.role === "assistant"
+      );
+
+      if (assistantMsg) {
+        const rawText = extractReplyText(assistantMsg);
+        replyText = rawText.replace(/\s*NO_REPLY\s*/gi, "").trim();
+        console.log(`[iPad WeChat] Agent reply found on poll ${i + 1}: "${replyText.slice(0, 200)}"`);
+        break;
+      }
+    } catch (pollErr) {
+      console.error(`[iPad WeChat] Poll ${i + 1} error:`, pollErr);
+    }
+  }
+
+  // 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);
+    }
+  } else {
+    console.log("[iPad WeChat] No non-silent agent reply found after polling, skipping outbound");
+  }
 }
 
 // JuHeBot notify_type constants (from doc-6966894.md)
 const NOTIFY_NEW_MSG = 1010;
 const NOTIFY_BATCH_NEW_MSG = 1011;
 
+/**
+ * Extract message content from JuHeBot `desc` field.
+ * Real callback format: "NickName : actualContent"
+ * For chatroom: "NickName:\nactualContent"
+ */
+function extractContentFromDesc(desc: string | undefined): string {
+  if (!desc) return "";
+  // Private chat: "NickName : content"
+  const colonIdx = desc.indexOf(" : ");
+  if (colonIdx >= 0) return desc.slice(colonIdx + 3);
+  // Chatroom: "NickName:\ncontent"
+  const nlIdx = desc.indexOf(":\n");
+  if (nlIdx >= 0) return desc.slice(nlIdx + 2);
+  return desc;
+}
+
 /**
  * Transform JuHeBot callback payload → WebhookPayload
  * Handles both JuHeBot native format and our own test format.
@@ -136,11 +357,11 @@ function transformPayload(raw: any): WebhookPayload | null {
         messageId: String(m.msg_id ?? m.msgId ?? m.new_msg_id ?? m.newMsgId ?? `msg_${Date.now()}`),
         fromUser: m.from_username ?? m.fromUsername ?? m.from_user ?? m.fromUser ?? "",
         toUser: m.to_username ?? m.toUsername ?? m.to_user ?? m.toUser ?? "",
-        content: m.content ?? m.msg_content ?? m.msgContent ?? "",
+        content: m.content ?? m.msg_content ?? m.msgContent ?? extractContentFromDesc(m.desc) ?? "",
         type: m.msg_type ?? m.msgType ?? m.type ?? 1,
         timestamp: m.timestamp ?? m.create_time ?? m.createTime ?? Date.now(),
         isSelf: m.is_self === 1 || m.is_self === true || m.isSelf === true,
-        roomId: m.room_username ?? m.roomUsername ?? m.roomId ?? undefined,
+        roomId: m.room_username ?? m.roomUsername ?? m.roomId ?? (m.is_chatroom_msg === 1 && m.chatroom ? m.chatroom : undefined),
       },
     };
   }
@@ -153,6 +374,21 @@ function transformPayload(raw: any): WebhookPayload | null {
 const WEBHOOK_PORT = parseInt(process.env.IPAD_WECHAT_WEBHOOK_PORT || "18790", 10);
 let _webhookServerStarted = false;
 
+// Deduplication: track recently processed msg_ids (TTL 60s)
+const _processedMsgIds = new Map<string, number>();
+function isDuplicate(msgId: string): boolean {
+  const now = Date.now();
+  // Prune old entries every check
+  if (_processedMsgIds.size > 500) {
+    for (const [k, t] of _processedMsgIds) {
+      if (now - t > 60000) _processedMsgIds.delete(k);
+    }
+  }
+  if (_processedMsgIds.has(msgId)) return true;
+  _processedMsgIds.set(msgId, now);
+  return false;
+}
+
 export default defineChannelPluginEntry({
   id: "ipad-wechat",
   name: "iPad WeChat",
@@ -212,8 +448,17 @@ export default defineChannelPluginEntry({
 
           const payload = transformPayload(raw);
           if (payload && payload.message) {
+            // Deduplicate by msg_id
+            if (isDuplicate(payload.message.messageId)) {
+              console.log(`[iPad WeChat] Duplicate msg_id=${payload.message.messageId}, skipping`);
+              res.writeHead(200, { "Content-Type": "text/plain" });
+              res.end("ok");
+              return;
+            }
+
             const cfg = loadOpenClawConfig();
             const msg = payload.message;
+            console.log(`[iPad WeChat] Parsed: from=${msg.fromUser}, content="${msg.content?.slice(0, 100)}", type=${msg.type}`);
             const isChatroom = !!(msg as any).roomId;
             const peerId = isChatroom ? (msg as any).roomId : (msg.fromUser || msg.toUser || "");
             const peerKind = isChatroom ? "group" : "direct";

package/openclaw.plugin.json

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

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "@gloablehive/ipad-wechat-plugin",
-  "version": "1.0.26",
+  "version": "2.1.0",
   "type": "module",
-  "description": "OpenClaw channel plugin for iPad WeChat protocol - enables sending/receiving WeChat messages through iPad protocol",
+  "description": "OpenClaw channel plugin for iPad WeChat protocol - enables sending/receiving WeChat messages through JuHeBot API",
   "main": "index.ts",
+  "files": [
+    "index.ts",
+    "src/",
+    "dist/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "npx tsx test-ipad.ts",
     "dev": "tsx watch index.ts"
   },
@@ -19,6 +27,13 @@
       "blurb": "Connect OpenClaw to iPad WeChat protocol for sending and receiving WeChat messages"
     }
   },
+  "keywords": ["openclaw", "wechat", "ipad", "channel", "plugin", "juhebot", "messaging"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tbuijibing/gloablehive",
+    "directory": "channels/ipad-wechat-plugin"
+  },
   "dependencies": {
     "@gloablehive/wechat-cache": "^1.2.0",
     "openclaw": ">=1.0.0"

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

package/src/client.ts

@@ -140,10 +140,10 @@ export function createIPadClient(config: JuHeBotConfig) {
 
     /**
      * 设置实例通知地址 (回调地址)
-     * Path: /instance/set_notify_url
+     * Path: /client/set_notify_url
      */
     async setNotifyUrl(notifyUrl: string): Promise<void> {
-      await callApi(config, "/instance/set_notify_url", { notifyUrl });
+      await callApi(config, "/client/set_notify_url", { notify_url: notifyUrl });
     },
 
     /**
@@ -280,7 +280,7 @@ export function createIPadClient(config: JuHeBotConfig) {
       content: string;
     }): Promise<SendTextResponse> {
       const res = await callApi(config, "/msg/send_text", {
-        toUser: params.friendWechatId,
+        to_username: params.friendWechatId,
         content: params.content,
       });
 
@@ -299,7 +299,7 @@ export function createIPadClient(config: JuHeBotConfig) {
       content: string;
     }): Promise<SendTextResponse> {
       const res = await callApi(config, "/msg/send_room_at", {
-        roomId: params.roomId,
+        to_username: params.roomId,
         content: params.content,
       });
 
@@ -704,7 +704,7 @@ export const API_PATHS = {
   instanceGetStatus: "/instance/get_status",
   instanceRestore: "/instance/restore",
   instanceStop: "/instance/stop",
-  instanceSetNotifyUrl: "/instance/set_notify_url",
+  instanceSetNotifyUrl: "/client/set_notify_url",
   instanceSetBridgeId: "/instance/set_bridge_id",
 
   // 用户

package/test-ipad-real.ts

@@ -1,77 +0,0 @@
-/**
- * Test Script for iPad WeChat Plugin - Real API Test
- * Run: npx tsx test-ipad-real.ts
- */
-
-import { createIPadClient } from './src/client.js';
-
-const CONFIG = {
-  appKey: 'app84l4hKvqmUphNX1H',
-  appSecret: 'CztidspJSiunhw7BVWnKiTgwVFV55nbaPVcBMRa34IT7hRvyxtJLsgMM0C3XMfbD',
-  guid: '0e7d1810-2b76-3c2b-8cab-74d94a951af9',
-};
-
-async function test1_GetLoginAccountInfo() {
-  console.log('\n📋 Test 1: Get Login Account Info');
-
-  const client = createIPadClient(CONFIG);
-
-  try {
-    const info = await client.getLoginAccountInfo();
-    console.log('✅ Account Info:');
-    console.log('  WeChat ID:', (info as any).userName?.string);
-    console.log('  NickName:', (info as any).nickName?.string);
-    console.log('  Mobile:', (info as any).bindMobile?.string);
-    console.log('  Signature:', (info as any).signature?.string);
-    return info;
-  } catch (error: any) {
-    console.log('❌ Error:', error.message);
-    return null;
-  }
-}
-
-async function test2_SyncContacts() {
-  console.log('\n📋 Test 2: Sync Contacts');
-
-  const client = createIPadClient(CONFIG);
-
-  try {
-    const contacts = await client.syncContacts();
-    console.log('✅ Contacts count:', contacts.length);
-    if (contacts.length > 0) {
-      console.log('Sample contact:', contacts[0]);
-    }
-    return contacts;
-  } catch (error: any) {
-    console.log('❌ Error:', error.message);
-    return [];
-  }
-}
-
-async function test3_GetRoomList() {
-  console.log('\n📋 Test 3: Get Room Info (sample room ID needed)');
-  console.log('⚠️  Skipping - requires a valid room ID');
-  return null;
-}
-
-async function test4_SendTextMessage() {
-  console.log('\n📋 Test 4: Send Text Message');
-  console.log('⚠️  Skipping - requires a valid friend wechat ID');
-  return null;
-}
-
-async function main() {
-  console.log('🚀 iPad WeChat Plugin - Real API Test');
-  console.log('=======================================');
-  console.log('Config:', { appKey: CONFIG.appKey, guid: CONFIG.guid });
-
-  await test1_GetLoginAccountInfo();
-  await test2_SyncContacts();
-  await test3_GetRoomList();
-  await test4_SendTextMessage();
-
-  console.log('\n=======================================');
-  console.log('✅ Tests completed!');
-}
-
-main();

package/test-ipad.ts

@@ -1,150 +0,0 @@
-/**
- * Test Script for iPad WeChat Plugin
- * Run: npx tsx test-ipad.ts
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import {
-  createCacheManager,
-  CacheManager,
-  WeChatAccount,
-  WeChatMessage,
-} from "@gloablehive/wechat-cache";
-import { createIPadClient, type WebhookPayload } from './src/client.js';
-
-const TEST_CACHE_PATH = '/tmp/wechat-cache-ipad-test';
-
-async function cleanup() {
-  try {
-    await fs.rm(TEST_CACHE_PATH, { recursive: true, force: true });
-  } catch {}
-}
-
-async function test1_CacheSystem() {
-  console.log('\n📋 Test 1: iPad WeChat Cache System');
-
-  const accounts: WeChatAccount[] = [
-    {
-      accountId: 'ipad-account-001',
-      wechatAccountId: 'ipad-wechat-001',
-      wechatId: 'wxid_ipad001',
-      nickName: 'iPad客服',
-      enabled: true,
-    },
-  ];
-
-  const manager = createCacheManager({
-    basePath: TEST_CACHE_PATH,
-    accounts,
-  });
-
-  await manager.init();
-  console.log('✅ Cache manager initialized');
-
-  // Test message
-  const message: WeChatMessage = {
-    messageId: 'ipad-msg-001',
-    accountId: 'ipad-account-001',
-    conversationType: 'friend',
-    conversationId: 'wxid_friend001',
-    senderId: 'wxid_friend001',
-    content: '你好，这是iPad协议测试消息',
-    messageType: 1,
-    timestamp: Date.now(),
-    isSelf: false,
-    direction: 'inbound',
-  };
-
-  await manager.onMessage(message);
-  console.log('✅ Message cached');
-
-  // Verify file exists
-  const friendPath = path.join(TEST_CACHE_PATH, 'accounts', 'ipad-account-001', 'friends', 'wxid_friend001');
-  const files = await fs.readdir(friendPath);
-  console.log('✅ Cached files:', files);
-
-  return manager;
-}
-
-async function test2_WebhookPayload() {
-  console.log('\n📋 Test 2: Webhook Payload Parsing');
-
-  // Simulate iPad webhook payload
-  const payload: WebhookPayload = {
-    event: 'message',
-    message: {
-      messageId: 'ipad-msg-002',
-      fromUser: 'wxid_testfriend',
-      toUser: 'wxid_ipad001',
-      content: '收到一条测试消息',
-      type: 1,
-      timestamp: Date.now(),
-      isSelf: false,
-    },
-  };
-
-  console.log('✅ Payload:', JSON.stringify(payload, null, 2));
-  console.log('✅ Webhook payload structure valid');
-}
-
-async function test3_ClientCreation() {
-  console.log('\n📋 Test 3: iPad Client Creation');
-
-  const client = createIPadClient({
-    baseUrl: 'https://api.example.com',
-    apiKey: 'test-api-key',
-  });
-
-  console.log('✅ Client created with methods:', Object.keys(client));
-
-  // Check all methods exist
-  const expectedMethods = [
-    'sendFriendMessage',
-    'sendRoomMessage',
-    'sendFriendMedia',
-    'sendRoomMedia',
-    'syncContacts',
-    'getContactDetail',
-    'updateFriendRemark',
-    'getRoomInfo',
-    'getRoomMembers',
-    'createRoom',
-    'addRoomMember',
-    'removeRoomMember',
-    'getLoginAccountInfo',
-    'getFriendMoments',
-    'publishMoment',
-  ];
-
-  for (const method of expectedMethods) {
-    if (typeof (client as any)[method] === 'function') {
-      console.log(`  ✅ ${method}`);
-    } else {
-      console.log(`  ❌ ${method} - missing`);
-    }
-  }
-}
-
-async function main() {
-  console.log('🚀 iPad WeChat Plugin Tests');
-  console.log('============================');
-
-  await cleanup();
-
-  try {
-    await test1_CacheSystem();
-    await test2_WebhookPayload();
-    await test3_ClientCreation();
-
-    console.log('\n============================');
-    console.log('✅ All tests passed!');
-  } catch (error) {
-    console.error('\n❌ Test failed:', error);
-    process.exit(1);
-  } finally {
-    await cleanup();
-  }
-}
-
-main();

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": ".",
-    "declaration": false,
-    "strict": false,
-    "noImplicitAny": false,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "noEmit": false,
-    "noEmitOnError": false
-  },
-  "include": ["*.ts", "src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "test*.ts"]
-}