@gloablehive/ipad-wechat-plugin 1.0.9 → 1.0.11

package/dist/index.js

@@ -3,26 +3,69 @@
  *
  * iPad WeChat Plugin - enables OpenClaw to send/receive WeChat messages
  * through the iPad protocol (different from WorkPhone/phone protocol)
+ *
+ * Multi-account support:
+ * - cfg is passed to handleInboundMessage for cache isolation
+ * - Each account's guid can have a dedicated webhook path
  */
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
-import { ipadWeChatPlugin, handleInboundMessage } from "./src/channel.js";
+import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady } from "./src/channel.js";
 export default defineChannelPluginEntry({
     id: "ipad-wechat",
     name: "iPad WeChat",
     description: "Connect OpenClaw to iPad WeChat protocol for sending and receiving WeChat messages",
     plugin: ipadWeChatPlugin,
     registerFull(api) {
-        // Register webhook endpoint for receiving messages
+        // Register main webhook endpoint for receiving messages
         api.registerHttpRoute({
             path: "/ipad-wechat/webhook",
             auth: "plugin",
             handler: async (req, res) => {
                 try {
+                    // Get config from request
+                    const cfg = req.cfg;
+                    // Wait for cache manager to be ready
+                    const ready = getCacheManagerReady();
+                    if (ready) {
+                        await ready;
+                    }
                     const payload = req.body;
-                    // Handle inbound message
                     console.log("[iPad WeChat] Received webhook:", payload);
                     if (payload) {
-                        await handleInboundMessage(api, payload);
+                        await handleInboundMessage(api, payload, cfg);
+                    }
+                    res.statusCode = 200;
+                    res.end("ok");
+                    return true;
+                }
+                catch (error) {
+                    console.error("[iPad WeChat] Webhook error:", error);
+                    res.statusCode = 500;
+                    res.end("Internal error");
+                    return true;
+                }
+            },
+        });
+        // Register per-guid webhook endpoints for multi-account routing
+        // These paths allow distinguishing which account received the message
+        // Path format: /ipad-wechat/webhook/guid-12345
+        api.registerHttpRoute({
+            path: "/ipad-wechat/webhook/:guid",
+            auth: "plugin",
+            handler: async (req, res) => {
+                try {
+                    const cfg = req.cfg;
+                    const guid = req.params?.guid;
+                    // Wait for cache manager to be ready
+                    const ready = getCacheManagerReady();
+                    if (ready) {
+                        await ready;
+                    }
+                    const payload = req.body;
+                    console.log(`[iPad WeChat] Received webhook for guid ${guid}:`, payload);
+                    if (payload) {
+                        // Pass the guid as overrideAccountId so handleInboundMessage knows which account
+                        await handleInboundMessage(api, payload, cfg, guid);
                     }
                     res.statusCode = 200;
                     res.end("ok");

package/dist/src/channel.js

@@ -4,21 +4,21 @@
  * Uses iPad protocol (different from phone/WorkPhone protocol)
  * API documentation: wechat/api.md
  *
- * Includes Local Cache (shared with celphone-wechat-plugin):
- * - Per-account, per-user/conversation MD files
- * - YAML frontmatter (aligned with Claude Code)
- * - MEMORY.md indexing
- * - 4-layer compression
- * - AI summary extraction
- * - SAAS connectivity + offline fallback
- * - Cloud sync
+ * Multi-account support:
+ * - Config supports accounts array with per-account credentials
+ * - Each account can be bound to a different agent
+ * - Security policies are per-account isolated
  */
 import { createChatChannelPlugin, createChannelPluginBase, } from "openclaw/plugin-sdk/core";
-import { createIPadClient } from "./client.js";
 // Import cache modules from shared package
-import { createCacheManager, } from "@gloablehive/wechat-cache";
+import { createCacheManager, createAccountRegistry, } from "@gloablehive/wechat-cache";
+// Import client pool
+import { getIPadClient } from "./client-pool.js";
 // Cache manager instance (lazy initialized)
 let cacheManager = null;
+let cacheManagerReady = null;
+// Account registry for routing
+let accountRegistry = null;
 /**
  * Get config section from either channels or plugins.entries
  */
@@ -26,6 +26,35 @@ function getConfigSection(cfg) {
     return cfg?.channels?.["ipad-wechat"]
         || cfg?.plugins?.entries?.["ipad-wechat"]?.config;
 }
+/**
+ * Get or create account registry
+ */
+function getAccountRegistry() {
+    if (!accountRegistry) {
+        accountRegistry = createAccountRegistry();
+    }
+    return accountRegistry;
+}
+/**
+ * Initialize account registry from config
+ */
+function initializeRegistry(cfg) {
+    const registry = getAccountRegistry();
+    registry.clear();
+    const section = getConfigSection(cfg);
+    const accounts = (section?.accounts || []);
+    // Register each account
+    for (const account of accounts) {
+        if (account.enabled !== false) {
+            const registeredAccount = {
+                ...account,
+                channelType: "ipad-wechat",
+                registeredAt: Date.now(),
+            };
+            registry.register(registeredAccount);
+        }
+    }
+}
 /**
  * Get or create cache manager
  */
@@ -35,24 +64,82 @@ function getCacheManager(cfg) {
     const section = getConfigSection(cfg);
     const accounts = (section?.accounts || []);
     // If no accounts configured, create default from main config
-    if (accounts.length === 0 && section?.wechatAccountId) {
+    if (accounts.length === 0 && section?.guid) {
         accounts.push({
             accountId: section.accountId || "default",
-            wechatAccountId: section.wechatAccountId,
+            wechatAccountId: section.wechatAccountId || "",
             wechatId: section.wechatId || "",
             nickName: section.nickName || "WeChat User",
             enabled: true,
+            appKey: section.appKey,
+            appSecret: section.appSecret,
+            guid: section.guid,
         });
     }
+    // Initialize registry with accounts
+    initializeRegistry(cfg);
     const basePath = section?.cachePath || "./cache/wechat-ipad";
     cacheManager = createCacheManager({
         basePath,
         accounts,
     });
+    // Initialize cache manager - await for ready state
+    cacheManagerReady = cacheManager.init().catch(err => {
+        console.error("[iPad WeChat] Cache manager init failed:", err);
+        throw err;
+    });
     return cacheManager;
 }
+/**
+ * Get cache manager ready promise
+ */
+export function getCacheManagerReady() {
+    return cacheManagerReady;
+}
+/**
+ * List all account IDs from config
+ */
+function listAccountIds(cfg) {
+    const section = getConfigSection(cfg);
+    const accounts = (section?.accounts || []);
+    if (accounts.length > 0) {
+        return accounts.map(a => a.accountId).filter(Boolean);
+    }
+    // Backward compatibility: single account
+    if (section?.guid) {
+        return [section.accountId || "default"];
+    }
+    return [];
+}
+/**
+ * Resolve account from OpenClaw config
+ *
+ * Supports both multi-account (accounts array) and legacy (single) formats.
+ */
 function resolveAccount(cfg, accountId) {
     const section = getConfigSection(cfg);
+    const accounts = (section?.accounts || []);
+    // Multi-account mode: look up from accounts array
+    if (accounts.length > 0) {
+        const targetAccountId = accountId || accounts[0]?.accountId;
+        const account = accounts.find(a => a.accountId === targetAccountId);
+        if (!account) {
+            throw new Error(`ipad-wechat: account not found - ${targetAccountId}`);
+        }
+        return {
+            accountId: account.accountId,
+            agentId: account.agentId || null,
+            appKey: account.appKey || section?.appKey || "",
+            appSecret: account.appSecret || section?.appSecret || "",
+            guid: account.guid || section?.guid || "",
+            wechatAccountId: account.wechatAccountId || "",
+            wechatId: account.wechatId || "",
+            nickName: account.nickName || "WeChat User",
+            allowFrom: account.allowFrom ?? [],
+            dmPolicy: account.dmPolicy,
+        };
+    }
+    // Legacy single-account mode
     const appKey = section?.appKey;
     const appSecret = section?.appSecret;
     const guid = section?.guid;
@@ -61,6 +148,7 @@ function resolveAccount(cfg, accountId) {
     }
     return {
         accountId: accountId ?? null,
+        agentId: null,
         appKey,
         appSecret,
         guid,
@@ -85,25 +173,17 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
             supportsEditing: false,
             supportsDeleting: false,
         },
-        // Config adapter - for runtime account management
         config: {
-            listAccountIds: (cfg) => {
-                const section = getConfigSection(cfg);
-                if (section?.wechatAccountId) {
-                    return [section.wechatAccountId];
-                }
-                return ["default"];
-            },
-            resolveAccount: (cfg, accountId) => {
-                return resolveAccount(cfg, accountId);
-            },
+            listAccountIds: (cfg) => listAccountIds(cfg),
+            resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
             defaultAccountId: (cfg) => {
                 const section = getConfigSection(cfg);
-                return section?.wechatAccountId || "default";
+                const accounts = (section?.accounts || []);
+                return accounts[0]?.accountId || section?.accountId || "default";
             },
             inspectAccount: (cfg, accountId) => {
-                const section = getConfigSection(cfg);
-                const hasCredentials = Boolean(section?.appKey && section?.appSecret && section?.guid);
+                const account = resolveAccount(cfg, accountId);
+                const hasCredentials = Boolean(account.appKey && account.appSecret && account.guid);
                 return {
                     enabled: hasCredentials,
                     configured: hasCredentials,
@@ -111,15 +191,11 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
                 };
             },
         },
-        // Setup adapter - for initial configuration
         setup: {
             resolveAccountId: (params) => {
                 return resolveAccount(params.cfg, params.accountId)?.accountId || "";
             },
-            applyAccountConfig: (params) => {
-                const { cfg, accountId, input } = params;
-                return cfg;
-            },
+            applyAccountConfig: (params) => params.cfg,
         },
     }),
     security: {
@@ -136,7 +212,6 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
     outbound: {
         deliveryMode: "gateway",
         channel: "ipad-wechat",
-        // Resolve target - for WeChat, just pass through the ID
         resolveTarget: (params) => {
             const target = params.to?.trim();
             if (!target) {
@@ -146,15 +221,16 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
         },
         attachedResults: {
             sendText: async (params) => {
-                // Get config from params.cfg
                 const cfg = params.cfg;
-                const section = getConfigSection(cfg);
-                const client = createIPadClient({
-                    appKey: section?.appKey,
-                    appSecret: section?.appSecret,
-                    guid: section?.guid,
+                const accountId = params.accountId;
+                // Resolve account to get credentials
+                const account = resolveAccount(cfg, accountId);
+                // Use client pool for connection reuse
+                const client = getIPadClient(account.accountId || "default", {
+                    appKey: account.appKey,
+                    appSecret: account.appSecret,
+                    guid: account.guid,
                 });
-                // Check if DM or group
                 const isChatroom = params.to?.includes("@chatroom");
                 if (isChatroom) {
                     const result = await client.sendRoomMessage({
@@ -173,34 +249,17 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
             },
             sendMedia: async (params) => {
                 const cfg = params.cfg;
-                const section = getConfigSection(cfg);
-                const client = createIPadClient({
-                    appKey: section?.appKey,
-                    appSecret: section?.appSecret,
-                    guid: section?.guid,
+                const accountId = params.accountId;
+                // Resolve account to get credentials
+                const account = resolveAccount(cfg, accountId);
+                // Use client pool
+                const client = getIPadClient(account.accountId || "default", {
+                    appKey: account.appKey,
+                    appSecret: account.appSecret,
+                    guid: account.guid,
                 });
                 const isChatroom = params.to?.includes("@chatroom");
-                // Get file path from mediaUrl or mediaReadFile
-                let filePath = "";
-                if (params.mediaUrl) {
-                    filePath = params.mediaUrl;
-                }
-                else if (params.mediaReadFile) {
-                    // Read file from local roots
-                    const roots = params.mediaLocalRoots || ["./"];
-                    for (const root of roots) {
-                        try {
-                            const fullPath = `${root}/${filePath}`;
-                            const buffer = await params.mediaReadFile(fullPath);
-                            // In a real implementation, we'd upload the file first
-                            filePath = fullPath;
-                            break;
-                        }
-                        catch {
-                            // Try next root
-                        }
-                    }
-                }
+                let filePath = params.mediaUrl || "";
                 if (isChatroom) {
                     const result = await client.sendRoomMedia({
                         roomId: params.to,
@@ -218,6 +277,60 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
             },
         },
     },
+    directory: {
+        self: async (params) => {
+            const account = resolveAccount(params.cfg, params.accountId);
+            return {
+                id: account.wechatId || "",
+                name: account.nickName || "WeChat User",
+                accountId: params.accountId || "default",
+            };
+        },
+        listPeers: async (params) => {
+            const account = resolveAccount(params.cfg, params.accountId);
+            const client = getIPadClient(account.accountId || "default", {
+                appKey: account.appKey,
+                appSecret: account.appSecret,
+                guid: account.guid,
+            });
+            try {
+                const contacts = await client.syncContacts();
+                return contacts.map((contact) => ({
+                    id: contact.wechatId || contact.wxid,
+                    name: contact.nickName || contact.remark || contact.wechatId,
+                    accountId: params.accountId || "default",
+                }));
+            }
+            catch (error) {
+                console.error("[iPad WeChat] Failed to list peers:", error);
+                return [];
+            }
+        },
+        listGroups: async (params) => {
+            console.log("[iPad WeChat] listGroups: API not available, returning empty");
+            return [];
+        },
+        listGroupMembers: async (params) => {
+            const account = resolveAccount(params.cfg, params.accountId);
+            const client = getIPadClient(account.accountId || "default", {
+                appKey: account.appKey,
+                appSecret: account.appSecret,
+                guid: account.guid,
+            });
+            try {
+                const members = await client.getRoomMembers(params.groupId);
+                return members.map((member) => ({
+                    id: member.userId || member.wxid,
+                    name: member.nickName || member.displayName || member.userId,
+                    accountId: params.accountId || "default",
+                }));
+            }
+            catch (error) {
+                console.error("[iPad WeChat] Failed to list group members:", error);
+                return [];
+            }
+        },
+    },
     capabilities: {
         supportedMessageTypes: ["text", "image", "video", "file", "link", "location", "contact"],
         maxAttachmentSize: 25 * 1024 * 1024,
@@ -230,13 +343,32 @@ export const ipadWeChatPlugin = createChatChannelPlugin({
         supportsDeleting: false,
     },
 });
-export async function handleInboundMessage(api, payload, cfg) {
+/**
+ * Handle inbound webhook message
+ * Supports multi-account routing via AccountRegistry
+ */
+export async function handleInboundMessage(api, payload, cfg, overrideAccountId) {
     const { event, message } = payload;
     if (event === "message" && message) {
         const isChatroom = !!message.roomId;
         const conversationId = isChatroom
             ? message.roomId
             : message.fromUser || message.toUser || "";
+        // Determine account ID - use override from webhook path or resolve from registry
+        let resolvedAccountId = overrideAccountId;
+        let agentId = null;
+        if (cfg && !resolvedAccountId) {
+            const registry = getAccountRegistry();
+            // Try by guid if available in message
+            const messageGuid = message.guid;
+            if (messageGuid) {
+                agentId = registry.getAgentIdByGuid(messageGuid);
+                const regAccount = registry.getByGuid(messageGuid);
+                resolvedAccountId = regAccount?.accountId || null;
+            }
+        }
+        // Default account ID if not resolved
+        resolvedAccountId = resolvedAccountId || "default";
         const openclawMessage = {
             id: message.messageId,
             conversation: {
@@ -252,15 +384,16 @@ export async function handleInboundMessage(api, payload, cfg) {
             },
             timestamp: new Date(message.timestamp || Date.now()),
             isSelf: message.isSelf || false,
+            agentId,
+            accountId: resolvedAccountId,
         };
         // Write to cache
         if (cfg) {
             try {
                 const cache = getCacheManager(cfg);
-                const section = getConfigSection(cfg);
                 const wechatMessage = {
                     messageId: message.messageId,
-                    accountId: section?.wechatAccountId || "default",
+                    accountId: resolvedAccountId,
                     conversationType: isChatroom ? "chatroom" : "friend",
                     conversationId,
                     senderId: message.fromUser || "",

package/dist/src/client-pool.js

@@ -0,0 +1,83 @@
+/**
+ * Client Pool - Per-account client management for iPad WeChat
+ *
+ * Manages iPad (JuHeBot) API clients per account to avoid creating
+ * new clients for each message and ensure credential isolation.
+ */
+import { createIPadClient } from "./client.js";
+/**
+ * Client pool for iPad WeChat clients
+ */
+class IPadClientPool {
+    clients = new Map();
+    configs = new Map();
+    /**
+     * Get or create a client for the given account
+     */
+    getClient(accountId, config) {
+        // Check if we already have a client and configs match
+        const existingConfig = this.configs.get(accountId);
+        if (this.clients.has(accountId) && existingConfig) {
+            // Verify configs are the same
+            if (existingConfig.appKey === config.appKey &&
+                existingConfig.appSecret === config.appSecret &&
+                existingConfig.guid === config.guid) {
+                return this.clients.get(accountId);
+            }
+        }
+        // Create new client
+        const client = createIPadClient(config);
+        this.clients.set(accountId, client);
+        this.configs.set(accountId, config);
+        return client;
+    }
+    /**
+     * Check if client exists
+     */
+    hasClient(accountId) {
+        return this.clients.has(accountId);
+    }
+    /**
+     * Remove a client by accountId
+     */
+    removeClient(accountId) {
+        this.configs.delete(accountId);
+        return this.clients.delete(accountId);
+    }
+    /**
+     * Clear all clients
+     */
+    clear() {
+        this.clients.clear();
+        this.configs.clear();
+    }
+    /**
+     * Get all account IDs with active clients
+     */
+    getActiveAccountIds() {
+        return Array.from(this.clients.keys());
+    }
+    /**
+     * Get pool size
+     */
+    get size() {
+        return this.clients.size;
+    }
+}
+// Singleton instance
+let clientPool = null;
+/**
+ * Get or create the client pool singleton
+ */
+function getClientPool() {
+    if (!clientPool) {
+        clientPool = new IPadClientPool();
+    }
+    return clientPool;
+}
+/**
+ * Get a client for a specific account
+ */
+export function getIPadClient(accountId, config) {
+    return getClientPool().getClient(accountId, config);
+}

package/index.ts

@@ -3,10 +3,14 @@
  *
  * iPad WeChat Plugin - enables OpenClaw to send/receive WeChat messages
  * through the iPad protocol (different from WorkPhone/phone protocol)
+ *
+ * Multi-account support:
+ * - cfg is passed to handleInboundMessage for cache isolation
+ * - Each account's guid can have a dedicated webhook path
  */
 
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
-import { ipadWeChatPlugin, handleInboundMessage } from "./src/channel.js";
+import { ipadWeChatPlugin, handleInboundMessage, getCacheManagerReady } from "./src/channel.js";
 
 export default defineChannelPluginEntry({
   id: "ipad-wechat",
@@ -15,18 +19,63 @@ export default defineChannelPluginEntry({
   plugin: ipadWeChatPlugin,
 
   registerFull(api) {
-    // Register webhook endpoint for receiving messages
+    // Register main webhook endpoint for receiving messages
     api.registerHttpRoute({
       path: "/ipad-wechat/webhook",
       auth: "plugin",
       handler: async (req, res) => {
         try {
+          // Get config from request
+          const cfg = (req as any).cfg;
+
+          // Wait for cache manager to be ready
+          const ready = getCacheManagerReady();
+          if (ready) {
+            await ready;
+          }
+
           const payload = (req as any).body;
-          // Handle inbound message
           console.log("[iPad WeChat] Received webhook:", payload);
 
           if (payload) {
-            await handleInboundMessage(api, payload);
+            await handleInboundMessage(api, payload, cfg);
+          }
+
+          res.statusCode = 200;
+          res.end("ok");
+          return true;
+        } catch (error) {
+          console.error("[iPad WeChat] Webhook error:", error);
+          res.statusCode = 500;
+          res.end("Internal error");
+          return true;
+        }
+      },
+    });
+
+    // Register per-guid webhook endpoints for multi-account routing
+    // These paths allow distinguishing which account received the message
+    // Path format: /ipad-wechat/webhook/guid-12345
+    api.registerHttpRoute({
+      path: "/ipad-wechat/webhook/:guid",
+      auth: "plugin",
+      handler: async (req, res) => {
+        try {
+          const cfg = (req as any).cfg;
+          const guid = (req as any).params?.guid;
+
+          // Wait for cache manager to be ready
+          const ready = getCacheManagerReady();
+          if (ready) {
+            await ready;
+          }
+
+          const payload = (req as any).body;
+          console.log(`[iPad WeChat] Received webhook for guid ${guid}:`, payload);
+
+          if (payload) {
+            // Pass the guid as overrideAccountId so handleInboundMessage knows which account
+            await handleInboundMessage(api, payload, cfg, guid);
           }
 
           res.statusCode = 200;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gloablehive/ipad-wechat-plugin",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "type": "module",
   "description": "OpenClaw channel plugin for iPad WeChat protocol - enables sending/receiving WeChat messages through iPad protocol",
   "main": "index.ts",
@@ -20,7 +20,7 @@
     }
   },
   "dependencies": {
-    "@gloablehive/wechat-cache": "^1.0.1",
+    "@gloablehive/wechat-cache": "^1.0.2",
     "openclaw": ">=1.0.0"
   },
   "devDependencies": {

package/src/channel.ts

@@ -4,14 +4,10 @@
  * Uses iPad protocol (different from phone/WorkPhone protocol)
  * API documentation: wechat/api.md
  *
- * Includes Local Cache (shared with celphone-wechat-plugin):
- * - Per-account, per-user/conversation MD files
- * - YAML frontmatter (aligned with Claude Code)
- * - MEMORY.md indexing
- * - 4-layer compression
- * - AI summary extraction
- * - SAAS connectivity + offline fallback
- * - Cloud sync
+ * Multi-account support:
+ * - Config supports accounts array with per-account credentials
+ * - Each account can be bound to a different agent
+ * - Security policies are per-account isolated
  */
 
 import {
@@ -19,7 +15,7 @@ import {
   createChannelPluginBase,
 } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { createIPadClient, type WebhookPayload } from "./client.js";
+import type { WebhookPayload } from "./client.js";
 
 // Import cache modules from shared package
 import {
@@ -27,10 +23,20 @@ import {
   CacheManager,
   WeChatAccount,
   WeChatMessage,
+  AccountRegistry,
+  createAccountRegistry,
+  RegisteredAccount,
 } from "@gloablehive/wechat-cache";
 
+// Import client pool
+import { getIPadClient } from "./client-pool.js";
+
 // Cache manager instance (lazy initialized)
 let cacheManager: CacheManager | null = null;
+let cacheManagerReady: Promise<void> | null = null;
+
+// Account registry for routing
+let accountRegistry: AccountRegistry | null = null;
 
 /**
  * Get config section from either channels or plugins.entries
@@ -40,6 +46,39 @@ function getConfigSection(cfg: any): any {
     || cfg?.plugins?.entries?.["ipad-wechat"]?.config;
 }
 
+/**
+ * Get or create account registry
+ */
+function getAccountRegistry(): AccountRegistry {
+  if (!accountRegistry) {
+    accountRegistry = createAccountRegistry();
+  }
+  return accountRegistry;
+}
+
+/**
+ * Initialize account registry from config
+ */
+function initializeRegistry(cfg: OpenClawConfig): void {
+  const registry = getAccountRegistry();
+  registry.clear();
+
+  const section = getConfigSection(cfg);
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  // Register each account
+  for (const account of accounts) {
+    if (account.enabled !== false) {
+      const registeredAccount: RegisteredAccount = {
+        ...account,
+        channelType: "ipad-wechat",
+        registeredAt: Date.now(),
+      };
+      registry.register(registeredAccount);
+    }
+  }
+}
+
 /**
  * Get or create cache manager
  */
@@ -50,16 +89,22 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
   const accounts = (section?.accounts || []) as WeChatAccount[];
 
   // If no accounts configured, create default from main config
-  if (accounts.length === 0 && section?.wechatAccountId) {
+  if (accounts.length === 0 && section?.guid) {
     accounts.push({
       accountId: section.accountId || "default",
-      wechatAccountId: section.wechatAccountId,
+      wechatAccountId: section.wechatAccountId || "",
       wechatId: section.wechatId || "",
       nickName: section.nickName || "WeChat User",
       enabled: true,
+      appKey: section.appKey,
+      appSecret: section.appSecret,
+      guid: section.guid,
     });
   }
 
+  // Initialize registry with accounts
+  initializeRegistry(cfg);
+
   const basePath = section?.cachePath || "./cache/wechat-ipad";
 
   cacheManager = createCacheManager({
@@ -67,11 +112,25 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
     accounts,
   });
 
+  // Initialize cache manager - await for ready state
+  cacheManagerReady = cacheManager.init().catch(err => {
+    console.error("[iPad WeChat] Cache manager init failed:", err);
+    throw err;
+  });
+
   return cacheManager;
 }
 
+/**
+ * Get cache manager ready promise
+ */
+export function getCacheManagerReady(): Promise<void> | null {
+  return cacheManagerReady;
+}
+
 export interface IPadWeChatResolvedAccount {
   accountId: string | null;
+  agentId: string | null;
   appKey: string;
   appSecret: string;
   guid: string;
@@ -82,12 +141,61 @@ export interface IPadWeChatResolvedAccount {
   dmPolicy: string | undefined;
 }
 
+/**
+ * List all account IDs from config
+ */
+function listAccountIds(cfg: OpenClawConfig): string[] {
+  const section = getConfigSection(cfg);
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  if (accounts.length > 0) {
+    return accounts.map(a => a.accountId).filter(Boolean);
+  }
+
+  // Backward compatibility: single account
+  if (section?.guid) {
+    return [section.accountId || "default"];
+  }
+
+  return [];
+}
+
+/**
+ * Resolve account from OpenClaw config
+ *
+ * Supports both multi-account (accounts array) and legacy (single) formats.
+ */
 function resolveAccount(
   cfg: OpenClawConfig,
   accountId?: string | null
 ): IPadWeChatResolvedAccount {
   const section = getConfigSection(cfg);
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  // Multi-account mode: look up from accounts array
+  if (accounts.length > 0) {
+    const targetAccountId = accountId || accounts[0]?.accountId;
+    const account = accounts.find(a => a.accountId === targetAccountId);
+
+    if (!account) {
+      throw new Error(`ipad-wechat: account not found - ${targetAccountId}`);
+    }
+
+    return {
+      accountId: account.accountId,
+      agentId: account.agentId || null,
+      appKey: account.appKey || section?.appKey || "",
+      appSecret: account.appSecret || section?.appSecret || "",
+      guid: account.guid || section?.guid || "",
+      wechatAccountId: account.wechatAccountId || "",
+      wechatId: account.wechatId || "",
+      nickName: account.nickName || "WeChat User",
+      allowFrom: account.allowFrom ?? [],
+      dmPolicy: account.dmPolicy,
+    };
+  }
 
+  // Legacy single-account mode
   const appKey = section?.appKey;
   const appSecret = section?.appSecret;
   const guid = section?.guid;
@@ -98,6 +206,7 @@ function resolveAccount(
 
   return {
     accountId: accountId ?? null,
+    agentId: null,
     appKey,
     appSecret,
     guid,
@@ -123,25 +232,17 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
       supportsEditing: false,
       supportsDeleting: false,
     } as any,
-    // Config adapter - for runtime account management
     config: {
-      listAccountIds: (cfg: any) => {
-        const section = getConfigSection(cfg);
-        if (section?.wechatAccountId) {
-          return [section.wechatAccountId];
-        }
-        return ["default"];
-      },
-      resolveAccount: (cfg: any, accountId?: string | null) => {
-        return resolveAccount(cfg, accountId);
-      },
+      listAccountIds: (cfg: any) => listAccountIds(cfg),
+      resolveAccount: (cfg: any, accountId?: string | null) => resolveAccount(cfg, accountId),
       defaultAccountId: (cfg: any) => {
         const section = getConfigSection(cfg);
-        return section?.wechatAccountId || "default";
+        const accounts = (section?.accounts || []) as WeChatAccount[];
+        return accounts[0]?.accountId || section?.accountId || "default";
       },
       inspectAccount: (cfg: any, accountId?: string | null) => {
-        const section = getConfigSection(cfg);
-        const hasCredentials = Boolean(section?.appKey && section?.appSecret && section?.guid);
+        const account = resolveAccount(cfg, accountId);
+        const hasCredentials = Boolean(account.appKey && account.appSecret && account.guid);
         return {
           enabled: hasCredentials,
           configured: hasCredentials,
@@ -149,15 +250,11 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
         };
       },
     } as any,
-    // Setup adapter - for initial configuration
     setup: {
       resolveAccountId: (params: any) => {
         return resolveAccount(params.cfg, params.accountId)?.accountId || "";
       },
-      applyAccountConfig: (params: any) => {
-        const { cfg, accountId, input } = params;
-        return cfg;
-      },
+      applyAccountConfig: (params: any) => params.cfg,
     },
   }) as any,
 
@@ -177,7 +274,6 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
   outbound: {
     deliveryMode: "gateway",
     channel: "ipad-wechat",
-    // Resolve target - for WeChat, just pass through the ID
     resolveTarget: (params: any) => {
       const target = params.to?.trim();
       if (!target) {
@@ -187,17 +283,19 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
     },
     attachedResults: {
       sendText: async (params: any) => {
-        // Get config from params.cfg
         const cfg = params.cfg;
-        const section = getConfigSection(cfg);
+        const accountId = params.accountId;
+
+        // Resolve account to get credentials
+        const account = resolveAccount(cfg, accountId);
 
-        const client = createIPadClient({
-          appKey: section?.appKey,
-          appSecret: section?.appSecret,
-          guid: section?.guid,
+        // Use client pool for connection reuse
+        const client = getIPadClient(account.accountId || "default", {
+          appKey: account.appKey,
+          appSecret: account.appSecret,
+          guid: account.guid,
         });
 
-        // Check if DM or group
         const isChatroom = params.to?.includes("@chatroom");
 
         if (isChatroom) {
@@ -217,35 +315,21 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
 
       sendMedia: async (params: any) => {
         const cfg = params.cfg;
-        const section = getConfigSection(cfg);
+        const accountId = params.accountId;
+
+        // Resolve account to get credentials
+        const account = resolveAccount(cfg, accountId);
 
-        const client = createIPadClient({
-          appKey: section?.appKey,
-          appSecret: section?.appSecret,
-          guid: section?.guid,
+        // Use client pool
+        const client = getIPadClient(account.accountId || "default", {
+          appKey: account.appKey,
+          appSecret: account.appSecret,
+          guid: account.guid,
         });
 
         const isChatroom = params.to?.includes("@chatroom");
 
-        // Get file path from mediaUrl or mediaReadFile
-        let filePath = "";
-        if (params.mediaUrl) {
-          filePath = params.mediaUrl;
-        } else if (params.mediaReadFile) {
-          // Read file from local roots
-          const roots = params.mediaLocalRoots || ["./"];
-          for (const root of roots) {
-            try {
-              const fullPath = `${root}/${filePath}`;
-              const buffer = await params.mediaReadFile(fullPath);
-              // In a real implementation, we'd upload the file first
-              filePath = fullPath;
-              break;
-            } catch {
-              // Try next root
-            }
-          }
-        }
+        let filePath = params.mediaUrl || "";
 
         if (isChatroom) {
           const result = await client.sendRoomMedia({
@@ -264,6 +348,59 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
     },
   },
 
+  directory: {
+    self: async (params: any) => {
+      const account = resolveAccount(params.cfg, params.accountId);
+      return {
+        id: account.wechatId || "",
+        name: account.nickName || "WeChat User",
+        accountId: params.accountId || "default",
+      };
+    },
+    listPeers: async (params: any) => {
+      const account = resolveAccount(params.cfg, params.accountId);
+      const client = getIPadClient(account.accountId || "default", {
+        appKey: account.appKey,
+        appSecret: account.appSecret,
+        guid: account.guid,
+      });
+      try {
+        const contacts = await client.syncContacts();
+        return contacts.map((contact: any) => ({
+          id: contact.wechatId || contact.wxid,
+          name: contact.nickName || contact.remark || contact.wechatId,
+          accountId: params.accountId || "default",
+        }));
+      } catch (error) {
+        console.error("[iPad WeChat] Failed to list peers:", error);
+        return [];
+      }
+    },
+    listGroups: async (params: any) => {
+      console.log("[iPad WeChat] listGroups: API not available, returning empty");
+      return [];
+    },
+    listGroupMembers: async (params: any) => {
+      const account = resolveAccount(params.cfg, params.accountId);
+      const client = getIPadClient(account.accountId || "default", {
+        appKey: account.appKey,
+        appSecret: account.appSecret,
+        guid: account.guid,
+      });
+      try {
+        const members = await client.getRoomMembers(params.groupId);
+        return members.map((member: any) => ({
+          id: member.userId || member.wxid,
+          name: member.nickName || member.displayName || member.userId,
+          accountId: params.accountId || "default",
+        }));
+      } catch (error) {
+        console.error("[iPad WeChat] Failed to list group members:", error);
+        return [];
+      }
+    },
+  },
+
   capabilities: {
     supportedMessageTypes: ["text", "image", "video", "file", "link", "location", "contact"],
     maxAttachmentSize: 25 * 1024 * 1024,
@@ -277,10 +414,15 @@ export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccoun
   },
 } as any);
 
+/**
+ * Handle inbound webhook message
+ * Supports multi-account routing via AccountRegistry
+ */
 export async function handleInboundMessage(
   api: any,
   payload: WebhookPayload,
-  cfg?: OpenClawConfig
+  cfg?: OpenClawConfig,
+  overrideAccountId?: string
 ): Promise<void> {
   const { event, message } = payload;
 
@@ -290,6 +432,24 @@ export async function handleInboundMessage(
       ? (message as any).roomId
       : message.fromUser || message.toUser || "";
 
+    // Determine account ID - use override from webhook path or resolve from registry
+    let resolvedAccountId = overrideAccountId;
+    let agentId: string | null = null;
+
+    if (cfg && !resolvedAccountId) {
+      const registry = getAccountRegistry();
+      // Try by guid if available in message
+      const messageGuid = (message as any).guid;
+      if (messageGuid) {
+        agentId = registry.getAgentIdByGuid(messageGuid);
+        const regAccount = registry.getByGuid(messageGuid);
+        resolvedAccountId = regAccount?.accountId || null;
+      }
+    }
+
+    // Default account ID if not resolved
+    resolvedAccountId = resolvedAccountId || "default";
+
     const openclawMessage = {
       id: message.messageId,
       conversation: {
@@ -305,16 +465,17 @@ export async function handleInboundMessage(
       },
       timestamp: new Date(message.timestamp || Date.now()),
       isSelf: message.isSelf || false,
+      agentId,
+      accountId: resolvedAccountId,
     };
 
     // Write to cache
     if (cfg) {
       try {
         const cache = getCacheManager(cfg);
-        const section = getConfigSection(cfg);
         const wechatMessage: WeChatMessage = {
           messageId: message.messageId,
-          accountId: section?.wechatAccountId || "default",
+          accountId: resolvedAccountId,
           conversationType: isChatroom ? "chatroom" : "friend",
           conversationId,
           senderId: message.fromUser || "",

package/src/client-pool.ts

@@ -0,0 +1,98 @@
+/**
+ * Client Pool - Per-account client management for iPad WeChat
+ *
+ * Manages iPad (JuHeBot) API clients per account to avoid creating
+ * new clients for each message and ensure credential isolation.
+ */
+
+import { createIPadClient, type JuHeBotConfig } from "./client.js";
+
+/**
+ * Client pool for iPad WeChat clients
+ */
+class IPadClientPool {
+  private clients: Map<string, ReturnType<typeof createIPadClient>> = new Map();
+  private configs: Map<string, JuHeBotConfig> = new Map();
+
+  /**
+   * Get or create a client for the given account
+   */
+  getClient(accountId: string, config: JuHeBotConfig): ReturnType<typeof createIPadClient> {
+    // Check if we already have a client and configs match
+    const existingConfig = this.configs.get(accountId);
+    if (this.clients.has(accountId) && existingConfig) {
+      // Verify configs are the same
+      if (existingConfig.appKey === config.appKey &&
+          existingConfig.appSecret === config.appSecret &&
+          existingConfig.guid === config.guid) {
+        return this.clients.get(accountId)!;
+      }
+    }
+
+    // Create new client
+    const client = createIPadClient(config);
+    this.clients.set(accountId, client);
+    this.configs.set(accountId, config);
+    return client;
+  }
+
+  /**
+   * Check if client exists
+   */
+  hasClient(accountId: string): boolean {
+    return this.clients.has(accountId);
+  }
+
+  /**
+   * Remove a client by accountId
+   */
+  removeClient(accountId: string): boolean {
+    this.configs.delete(accountId);
+    return this.clients.delete(accountId);
+  }
+
+  /**
+   * Clear all clients
+   */
+  clear(): void {
+    this.clients.clear();
+    this.configs.clear();
+  }
+
+  /**
+   * Get all account IDs with active clients
+   */
+  getActiveAccountIds(): string[] {
+    return Array.from(this.clients.keys());
+  }
+
+  /**
+   * Get pool size
+   */
+  get size(): number {
+    return this.clients.size;
+  }
+}
+
+// Singleton instance
+let clientPool: IPadClientPool | null = null;
+
+/**
+ * Get or create the client pool singleton
+ */
+function getClientPool(): IPadClientPool {
+  if (!clientPool) {
+    clientPool = new IPadClientPool();
+  }
+  return clientPool;
+}
+
+/**
+ * Get a client for a specific account
+ */
+export function getIPadClient(
+  accountId: string,
+  config: JuHeBotConfig
+): ReturnType<typeof createIPadClient> {
+  return getClientPool().getClient(accountId, config);
+}