@gloablehive/ipad-wechat-plugin 1.0.23 → 1.0.25

package/dist/index.js

@@ -7,38 +7,252 @@
  * Multi-account support:
  * - cfg is passed to handleInboundMessage for cache isolation
  * - Each account's guid can have a dedicated webhook path
+ *
+ * Webhook strategy:
+ * - registerHttpRoute kept for forward-compatibility
+ * - Standalone HTTP server on port 18790 as primary receiver (bypasses OpenClaw routing bug)
+ * - JuHeBot notify_type → WebhookPayload transformer included
  */
-import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { createServer } from "http";
+import { readFileSync } from "fs";
+import { join } from "path";
+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";
+/** Read OpenClaw main config from disk so standalone server has full cfg */
+let _cfgCache = null;
+function loadOpenClawConfig() {
+    if (_cfgCache)
+        return _cfgCache;
+    try {
+        const p = join(homedir(), ".openclaw", "openclaw.json");
+        _cfgCache = JSON.parse(readFileSync(p, "utf-8"));
+        return _cfgCache;
+    }
+    catch (err) {
+        console.error("[iPad WeChat] Failed to load openclaw.json:", err);
+        return null;
+    }
+}
+// ── 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 || "";
+    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) => {
+            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 */ }
+        });
+        ws.on("error", (err) => { clearTimeout(timeout); reject(err); });
+        ws.on("close", () => { clearTimeout(timeout); if (!connected)
+            reject(new Error("Gateway closed before connect")); });
+    });
+}
+// JuHeBot notify_type constants (from doc-6966894.md)
+const NOTIFY_NEW_MSG = 1010;
+const NOTIFY_BATCH_NEW_MSG = 1011;
+/**
+ * Transform JuHeBot callback payload → WebhookPayload
+ * Handles both JuHeBot native format and our own test format.
+ */
+function transformPayload(raw) {
+    // Already in our expected format
+    if (raw.event && raw.message) {
+        return raw;
+    }
+    const notifyType = raw.notify_type ?? raw.notifyType ?? raw.type;
+    if (notifyType === NOTIFY_NEW_MSG || notifyType === NOTIFY_BATCH_NEW_MSG) {
+        const data = raw.data || raw;
+        const msgs = notifyType === NOTIFY_BATCH_NEW_MSG
+            ? (data.msgs || data.messages || [data])
+            : [data];
+        if (!msgs || msgs.length === 0)
+            return null;
+        const m = msgs[0];
+        return {
+            event: "message",
+            message: {
+                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 ?? "",
+                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,
+            },
+        };
+    }
+    // Non-message events – log for future handling
+    console.log(`[iPad WeChat] notify_type=${notifyType} (non-message)`, JSON.stringify(raw).slice(0, 300));
+    return null;
+}
+const WEBHOOK_PORT = parseInt(process.env.IPAD_WECHAT_WEBHOOK_PORT || "18790", 10);
+let _webhookServerStarted = false;
 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) {
-        console.log("[iPad WeChat] registerFull called, registering webhook route");
-        // Register webhook endpoint - use the standard path pattern with plugin auth
+        console.log("[iPad WeChat] registerFull called");
+        // ── 1. Standard OpenClaw route (kept for forward-compat) ──
         api.registerHttpRoute({
-            path: "/api/channels/ipad-wechat/webhook",
-            auth: "plugin", // Plugin auth - we verify ourselves
-            match: "exact",
+            path: "/ipad-wechat/webhook",
+            auth: "plugin",
             handler: async (req, res) => {
-                console.log("[iPad WeChat] Handler called, url:", req.url);
+                console.log("[iPad WeChat] OpenClaw route hit:", req.url);
                 const cfg = req.cfg;
                 const ready = getCacheManagerReady();
-                if (ready) {
+                if (ready)
                     await ready;
-                }
-                const payload = req.body;
-                console.log("[iPad WeChat] Received webhook:", payload);
-                if (payload) {
+                const payload = transformPayload(req.body || {});
+                if (payload)
                     await handleInboundMessage(api, payload, cfg);
-                }
                 res.statusCode = 200;
                 res.end("ok");
                 return true;
             },
         });
-        console.log("[iPad WeChat] Webhook route registered");
+        // ── 2. Standalone HTTP server (primary – bypasses OpenClaw routing bug) ──
+        if (_webhookServerStarted) {
+            console.log("[iPad WeChat] Webhook server already running, skipping duplicate start");
+            return;
+        }
+        _webhookServerStarted = true;
+        const server = createServer((req, res) => {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+            if (req.method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.method === "GET") {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "ok", service: "ipad-wechat-webhook", port: WEBHOOK_PORT }));
+                return;
+            }
+            if (req.method !== "POST") {
+                res.writeHead(405);
+                res.end("Method not allowed");
+                return;
+            }
+            let body = "";
+            req.on("data", (chunk) => { body += chunk; });
+            req.on("end", async () => {
+                try {
+                    const raw = JSON.parse(body);
+                    console.log("[iPad WeChat] Webhook received:", JSON.stringify(raw).slice(0, 500));
+                    const payload = transformPayload(raw);
+                    if (payload && payload.message) {
+                        const cfg = loadOpenClawConfig();
+                        const msg = payload.message;
+                        const isChatroom = !!msg.roomId;
+                        const peerId = isChatroom ? msg.roomId : (msg.fromUser || msg.toUser || "");
+                        const peerKind = isChatroom ? "group" : "direct";
+                        let sessionKey = `agent:main:ipad-wechat:${peerKind}:${peerId}`;
+                        try {
+                            const route = buildChannelOutboundSessionRoute({
+                                cfg, agentId: "main", channel: "ipad-wechat",
+                                peer: { kind: peerKind, id: peerId },
+                                chatType: peerKind,
+                                from: msg.toUser || "", to: msg.fromUser || "",
+                            });
+                            sessionKey = route.sessionKey;
+                        }
+                        catch { /* fallback to manual key */ }
+                        try {
+                            await dispatchViaGateway({
+                                sessionKey,
+                                message: msg.content || "",
+                                from: msg.fromUser || "",
+                                to: msg.toUser || "",
+                            });
+                            console.log(`[iPad WeChat] Message dispatched → session=${sessionKey}`);
+                        }
+                        catch (dispatchErr) {
+                            console.error("[iPad WeChat] Gateway dispatch error:", dispatchErr);
+                        }
+                    }
+                    res.writeHead(200, { "Content-Type": "text/plain" });
+                    res.end("ok");
+                }
+                catch (err) {
+                    console.error("[iPad WeChat] Webhook error:", err);
+                    res.writeHead(500, { "Content-Type": "text/plain" });
+                    res.end("error");
+                }
+            });
+        });
+        server.on("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                console.error(`[iPad WeChat] Port ${WEBHOOK_PORT} in use. Set IPAD_WECHAT_WEBHOOK_PORT to change.`);
+            }
+            else {
+                console.error("[iPad WeChat] Server error:", err);
+            }
+        });
+        server.listen(WEBHOOK_PORT, "0.0.0.0", () => {
+            console.log(`[iPad WeChat] ✅ Webhook server listening on 0.0.0.0:${WEBHOOK_PORT}`);
+            console.log(`[iPad WeChat] Set JuHeBot notifyUrl → http://<public-ip>:${WEBHOOK_PORT}/`);
+        });
+        console.log("[iPad WeChat] registerFull complete");
     },
 });

package/dist/src/channel.js

@@ -79,9 +79,19 @@ function getCacheManager(cfg) {
     // Initialize registry with accounts
     initializeRegistry(cfg);
     const basePath = section?.cachePath || "./cache/wechat-ipad";
+    // Build knowledge config if provided in section
+    let knowledgeConfig;
+    if (section?.knowledge) {
+        knowledgeConfig = {
+            ...section.knowledge,
+            nodeId: section.knowledge.nodeId || 'ipad-wechat-node',
+            agentId: section.knowledge.agentId || section.agentId || 'default-agent',
+        };
+    }
     cacheManager = createCacheManager({
         basePath,
         accounts,
+        knowledgeConfig,
     });
     // Initialize cache manager - await for ready state
     cacheManagerReady = cacheManager.init().catch(err => {

package/index.ts

@@ -7,10 +7,151 @@
  * Multi-account support:
  * - cfg is passed to handleInboundMessage for cache isolation
  * - Each account's guid can have a dedicated webhook path
+ *
+ * Webhook strategy:
+ * - registerHttpRoute kept for forward-compatibility
+ * - Standalone HTTP server on port 18790 as primary receiver (bypasses OpenClaw routing bug)
+ * - JuHeBot notify_type → WebhookPayload transformer included
  */
 
-import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { createServer } from "http";
+import { readFileSync } from "fs";
+import { join } from "path";
+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 type { WebhookPayload } from "./src/client.js";
+
+/** Read OpenClaw main config from disk so standalone server has full cfg */
+let _cfgCache: any = null;
+function loadOpenClawConfig(): any {
+  if (_cfgCache) return _cfgCache;
+  try {
+    const p = join(homedir(), ".openclaw", "openclaw.json");
+    _cfgCache = JSON.parse(readFileSync(p, "utf-8"));
+    return _cfgCache;
+  } catch (err) {
+    console.error("[iPad WeChat] Failed to load openclaw.json:", err);
+    return null;
+  }
+}
+
+// ── Gateway WebSocket dispatch ──
+const GATEWAY_PORT = parseInt(process.env.OPENCLAW_GATEWAY_PORT || "18789", 10);
+let _gwReqId = 0;
+
+function dispatchViaGateway(params: {
+  sessionKey: string;
+  message: string;
+  from: string;
+  to: string;
+  accountId?: string;
+}): Promise<void> {
+  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 } } : {}),
+        },
+      }));
+    });
+
+    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 */ }
+    });
+
+    ws.on("error", (err) => { clearTimeout(timeout); reject(err); });
+    ws.on("close", () => { clearTimeout(timeout); if (!connected) reject(new Error("Gateway closed before connect")); });
+  });
+}
+
+// JuHeBot notify_type constants (from doc-6966894.md)
+const NOTIFY_NEW_MSG = 1010;
+const NOTIFY_BATCH_NEW_MSG = 1011;
+
+/**
+ * Transform JuHeBot callback payload → WebhookPayload
+ * Handles both JuHeBot native format and our own test format.
+ */
+function transformPayload(raw: any): WebhookPayload | null {
+  // Already in our expected format
+  if (raw.event && raw.message) {
+    return raw as WebhookPayload;
+  }
+
+  const notifyType = raw.notify_type ?? raw.notifyType ?? raw.type;
+
+  if (notifyType === NOTIFY_NEW_MSG || notifyType === NOTIFY_BATCH_NEW_MSG) {
+    const data = raw.data || raw;
+    const msgs = notifyType === NOTIFY_BATCH_NEW_MSG
+      ? (data.msgs || data.messages || [data])
+      : [data];
+
+    if (!msgs || msgs.length === 0) return null;
+    const m = msgs[0];
+
+    return {
+      event: "message",
+      message: {
+        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 ?? "",
+        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,
+      },
+    };
+  }
+
+  // Non-message events – log for future handling
+  console.log(`[iPad WeChat] notify_type=${notifyType} (non-message)`, JSON.stringify(raw).slice(0, 300));
+  return null;
+}
+
+const WEBHOOK_PORT = parseInt(process.env.IPAD_WECHAT_WEBHOOK_PORT || "18790", 10);
+let _webhookServerStarted = false;
 
 export default defineChannelPluginEntry({
   id: "ipad-wechat",
@@ -19,28 +160,20 @@ export default defineChannelPluginEntry({
   plugin: ipadWeChatPlugin,
 
   registerFull(api) {
-    console.log("[iPad WeChat] registerFull called, registering webhook route");
+    console.log("[iPad WeChat] registerFull called");
 
-    // Register webhook endpoint - use the standard path pattern with plugin auth
+    // ── 1. Standard OpenClaw route (kept for forward-compat) ──
     api.registerHttpRoute({
-      path: "/api/channels/ipad-wechat/webhook",
-      auth: "plugin", // Plugin auth - we verify ourselves
-      match: "exact",
+      path: "/ipad-wechat/webhook",
+      auth: "plugin",
       handler: async (req, res) => {
-        console.log("[iPad WeChat] Handler called, url:", (req as any).url);
-
+        console.log("[iPad WeChat] OpenClaw route hit:", (req as any).url);
         const cfg = (req as any).cfg;
         const ready = getCacheManagerReady();
-        if (ready) {
-          await ready;
-        }
+        if (ready) await ready;
 
-        const payload = (req as any).body;
-        console.log("[iPad WeChat] Received webhook:", payload);
-
-        if (payload) {
-          await handleInboundMessage(api, payload, cfg);
-        }
+        const payload = transformPayload((req as any).body || {});
+        if (payload) await handleInboundMessage(api, payload, cfg);
 
         res.statusCode = 200;
         res.end("ok");
@@ -48,6 +181,90 @@ export default defineChannelPluginEntry({
       },
     });
 
-    console.log("[iPad WeChat] Webhook route registered");
+    // ── 2. Standalone HTTP server (primary – bypasses OpenClaw routing bug) ──
+    if (_webhookServerStarted) {
+      console.log("[iPad WeChat] Webhook server already running, skipping duplicate start");
+      return;
+    }
+    _webhookServerStarted = true;
+
+    const server = createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+      if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+      if (req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", service: "ipad-wechat-webhook", port: WEBHOOK_PORT }));
+        return;
+      }
+
+      if (req.method !== "POST") { res.writeHead(405); res.end("Method not allowed"); return; }
+
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk; });
+      req.on("end", async () => {
+        try {
+          const raw = JSON.parse(body);
+          console.log("[iPad WeChat] Webhook received:", JSON.stringify(raw).slice(0, 500));
+
+          const payload = transformPayload(raw);
+          if (payload && payload.message) {
+            const cfg = loadOpenClawConfig();
+            const msg = payload.message;
+            const isChatroom = !!(msg as any).roomId;
+            const peerId = isChatroom ? (msg as any).roomId : (msg.fromUser || msg.toUser || "");
+            const peerKind = isChatroom ? "group" : "direct";
+
+            let sessionKey = `agent:main:ipad-wechat:${peerKind}:${peerId}`;
+            try {
+              const route = buildChannelOutboundSessionRoute({
+                cfg, agentId: "main", channel: "ipad-wechat",
+                peer: { kind: peerKind as any, id: peerId },
+                chatType: peerKind as any,
+                from: msg.toUser || "", to: msg.fromUser || "",
+              });
+              sessionKey = route.sessionKey;
+            } catch { /* fallback to manual key */ }
+
+            try {
+              await dispatchViaGateway({
+                sessionKey,
+                message: msg.content || "",
+                from: msg.fromUser || "",
+                to: msg.toUser || "",
+              });
+              console.log(`[iPad WeChat] Message dispatched → session=${sessionKey}`);
+            } catch (dispatchErr) {
+              console.error("[iPad WeChat] Gateway dispatch error:", dispatchErr);
+            }
+          }
+
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end("ok");
+        } catch (err) {
+          console.error("[iPad WeChat] Webhook error:", err);
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("error");
+        }
+      });
+    });
+
+    server.on("error", (err: NodeJS.ErrnoException) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(`[iPad WeChat] Port ${WEBHOOK_PORT} in use. Set IPAD_WECHAT_WEBHOOK_PORT to change.`);
+      } else {
+        console.error("[iPad WeChat] Server error:", err);
+      }
+    });
+
+    server.listen(WEBHOOK_PORT, "0.0.0.0", () => {
+      console.log(`[iPad WeChat] ✅ Webhook server listening on 0.0.0.0:${WEBHOOK_PORT}`);
+      console.log(`[iPad WeChat] Set JuHeBot notifyUrl → http://<public-ip>:${WEBHOOK_PORT}/`);
+    });
+
+    console.log("[iPad WeChat] registerFull complete");
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gloablehive/ipad-wechat-plugin",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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.2",
+    "@gloablehive/wechat-cache": "file:../wechat-cache",
     "openclaw": ">=1.0.0"
   },
   "devDependencies": {

package/src/channel.ts

@@ -26,6 +26,7 @@ import {
   AccountRegistry,
   createAccountRegistry,
   RegisteredAccount,
+  KnowledgeConfig,
 } from "@gloablehive/wechat-cache";
 
 // Import client pool
@@ -107,9 +108,20 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
 
   const basePath = section?.cachePath || "./cache/wechat-ipad";
 
+  // Build knowledge config if provided in section
+  let knowledgeConfig: (Partial<KnowledgeConfig> & { nodeId: string; agentId: string }) | undefined;
+  if (section?.knowledge) {
+    knowledgeConfig = {
+      ...section.knowledge,
+      nodeId: section.knowledge.nodeId || 'ipad-wechat-node',
+      agentId: section.knowledge.agentId || section.agentId || 'default-agent',
+    };
+  }
+
   cacheManager = createCacheManager({
     basePath,
     accounts,
+    knowledgeConfig,
   });
 
   // Initialize cache manager - await for ready state