@gloablehive/ipad-wechat-plugin 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,40 @@
+/**
+ * OpenClaw Channel Plugin Entry Point
+ *
+ * iPad WeChat Plugin - enables OpenClaw to send/receive WeChat messages
+ * through the iPad protocol (different from WorkPhone/phone protocol)
+ */
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { ipadWeChatPlugin, handleInboundMessage } 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
+        api.registerHttpRoute({
+            path: "/ipad-wechat/webhook",
+            auth: "plugin",
+            handler: async (req, res) => {
+                try {
+                    const payload = req.body;
+                    // Handle inbound message
+                    console.log("[iPad WeChat] Received webhook:", payload);
+                    if (payload) {
+                        await handleInboundMessage(api, payload);
+                    }
+                    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;
+                }
+            },
+        });
+    },
+});

package/dist/openclaw.plugin.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "https://openclaw.ai/schema/plugin.json",
+  "id": "ipad-wechat",
+  "name": "iPad WeChat",
+  "version": "1.0.0",
+  "description": "Connect OpenClaw to iPad WeChat protocol for sending and receiving WeChat messages",
+  "author": {
+    "name": "gloablehive",
+    "url": "https://github.com/gloablehive"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gloablehive/channels/ipad-wechat-plugin"
+  },
+  "keywords": ["openclaw", "channel", "wechat", "ipad", "messaging"],
+  "license": "MIT",
+  "type": "channel",
+  "capabilities": {
+    "inbound": {
+      "message": true,
+      "friend_request": true,
+      "group_invite": true
+    },
+    "outbound": {
+      "text": true,
+      "media": true,
+      "link": true,
+      "location": true,
+      "contact": true
+    },
+    "features": {
+      "pairing": false,
+      "reactions": false,
+      "editing": false,
+      "deleting": false,
+      "threads": true
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "appKey": {
+        "type": "string",
+        "description": "JuHeBot App Key (聚合聊天开放平台)",
+        "secret": true,
+        "required": true
+      },
+      "appSecret": {
+        "type": "string",
+        "description": "JuHeBot App Secret",
+        "secret": true,
+        "required": true
+      },
+      "guid": {
+        "type": "string",
+        "description": "实例/设备 ID (Guid)",
+        "required": true
+      },
+      "accountId": {
+        "type": "string",
+        "description": "Internal account ID for routing"
+      },
+      "wechatAccountId": {
+        "type": "string",
+        "description": "WeChat account ID in the system"
+      },
+      "wechatId": {
+        "type": "string",
+        "description": "WeChat ID (wxid_xxx)"
+      },
+      "nickName": {
+        "type": "string",
+        "description": "Display name for this WeChat account"
+      },
+      "allowFrom": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "List of WeChat IDs that can DM the agent",
+        "default": []
+      },
+      "dmSecurity": {
+        "type": "string",
+        "enum": ["allowlist", "blocklist", "allowall"],
+        "description": "DM security policy",
+        "default": "allowlist"
+      }
+    },
+    "required": ["appKey", "appSecret", "guid"]
+  },
+  "permissions": {
+    "channels": ["ipad-wechat"],
+    "http": {
+      "outbound": ["*"],
+      "inbound": ["/ipad-wechat/webhook"]
+    }
+  },
+  "apiVersion": "1.0.0"
+}

package/dist/src/channel.js

@@ -0,0 +1,229 @@
+/**
+ * iPad WeChat Channel Plugin for OpenClaw
+ *
+ * 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
+ */
+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";
+// Cache manager instance (lazy initialized)
+let cacheManager = null;
+/**
+ * Get or create cache manager
+ */
+function getCacheManager(cfg) {
+    if (cacheManager)
+        return cacheManager;
+    const section = cfg.channels?.["ipad-wechat"];
+    const accounts = (section?.accounts || []);
+    // If no accounts configured, create default from main config
+    if (accounts.length === 0 && section?.wechatAccountId) {
+        accounts.push({
+            accountId: section.accountId || "default",
+            wechatAccountId: section.wechatAccountId,
+            wechatId: section.wechatId || "",
+            nickName: section.nickName || "WeChat User",
+            enabled: true,
+        });
+    }
+    const basePath = section?.cachePath || "./cache/wechat-ipad";
+    cacheManager = createCacheManager({
+        basePath,
+        accounts,
+    });
+    return cacheManager;
+}
+function resolveAccount(cfg, accountId) {
+    const section = cfg.channels?.["ipad-wechat"];
+    const appKey = section?.appKey;
+    const appSecret = section?.appSecret;
+    const guid = section?.guid;
+    if (!appKey || !appSecret || !guid) {
+        throw new Error("ipad-wechat: appKey, appSecret, and guid are required");
+    }
+    return {
+        accountId: accountId ?? null,
+        appKey,
+        appSecret,
+        guid,
+        wechatAccountId: section?.wechatAccountId || "",
+        wechatId: section?.wechatId || "",
+        nickName: section?.nickName || "WeChat User",
+        allowFrom: section?.allowFrom ?? [],
+        dmPolicy: section?.dmSecurity,
+    };
+}
+export const ipadWeChatPlugin = createChatChannelPlugin({
+    base: createChannelPluginBase({
+        id: "ipad-wechat",
+        setup: {
+            resolveAccount,
+            inspectAccount(cfg, accountId) {
+                const section = cfg.channels?.["ipad-wechat"];
+                const hasCredentials = Boolean(section?.appKey && section?.appSecret && section?.guid);
+                return {
+                    enabled: hasCredentials,
+                    configured: hasCredentials,
+                    tokenStatus: hasCredentials ? "available" : "missing",
+                };
+            },
+        },
+    }),
+    security: {
+        dm: {
+            channelKey: "ipad-wechat",
+            resolvePolicy: (account) => account.dmPolicy,
+            resolveAllowFrom: (account) => account.allowFrom,
+            defaultPolicy: "allowlist",
+        },
+    },
+    threading: {
+        topLevelReplyToMode: "reply",
+    },
+    outbound: {
+        attachedResults: {
+            sendText: async (params) => {
+                // Get the resolved account from params
+                const cfg = params.cfg;
+                const section = cfg.channels?.["ipad-wechat"];
+                const client = createIPadClient({
+                    appKey: section?.appKey,
+                    appSecret: section?.appSecret,
+                    guid: section?.guid,
+                });
+                // Check if DM or group
+                const isChatroom = params.to?.includes("@chatroom");
+                if (isChatroom) {
+                    const result = await client.sendRoomMessage({
+                        roomId: params.to,
+                        content: params.text,
+                    });
+                    return { messageId: result.messageId };
+                }
+                else {
+                    const result = await client.sendFriendMessage({
+                        friendWechatId: params.to,
+                        content: params.text,
+                    });
+                    return { messageId: result.messageId };
+                }
+            },
+            sendMedia: async (params) => {
+                const cfg = params.cfg;
+                const section = cfg.channels?.["ipad-wechat"];
+                const client = createIPadClient({
+                    appKey: section?.appKey,
+                    appSecret: section?.appSecret,
+                    guid: section?.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
+                        }
+                    }
+                }
+                if (isChatroom) {
+                    const result = await client.sendRoomMedia({
+                        roomId: params.to,
+                        filePath: filePath,
+                    });
+                    return { messageId: result.messageId };
+                }
+                else {
+                    const result = await client.sendFriendMedia({
+                        friendWechatId: params.to,
+                        filePath: filePath,
+                    });
+                    return { messageId: result.messageId };
+                }
+            },
+        },
+    },
+    capabilities: {
+        supportedMessageTypes: ["text", "image", "video", "file", "link", "location", "contact"],
+        maxAttachmentSize: 25 * 1024 * 1024,
+        supportsMarkdown: false,
+        supportsHtml: false,
+        supportsEmoji: true,
+        supportsReactions: false,
+        supportsThreads: true,
+        supportsEditing: false,
+        supportsDeleting: false,
+    },
+});
+export async function handleInboundMessage(api, payload, cfg) {
+    const { event, message } = payload;
+    if (event === "message" && message) {
+        const isChatroom = !!message.roomId;
+        const conversationId = isChatroom
+            ? message.roomId
+            : message.fromUser || message.toUser || "";
+        const openclawMessage = {
+            id: message.messageId,
+            conversation: {
+                type: isChatroom ? "group" : "dm",
+                id: conversationId,
+            },
+            sender: {
+                id: message.fromUser || "",
+            },
+            content: {
+                type: "text",
+                text: message.content,
+            },
+            timestamp: new Date(message.timestamp || Date.now()),
+            isSelf: message.isSelf || false,
+        };
+        // Write to cache
+        if (cfg) {
+            try {
+                const cache = getCacheManager(cfg);
+                const wechatMessage = {
+                    messageId: message.messageId,
+                    accountId: cfg.channels?.["ipad-wechat"]?.accountId || "default",
+                    conversationType: isChatroom ? "chatroom" : "friend",
+                    conversationId,
+                    senderId: message.fromUser || "",
+                    content: message.content,
+                    messageType: message.type || 1,
+                    timestamp: message.timestamp || Date.now(),
+                    isSelf: message.isSelf || false,
+                    direction: "inbound",
+                };
+                await cache.onMessage(wechatMessage);
+            }
+            catch (error) {
+                console.error("[iPad WeChat] Cache error:", error);
+            }
+        }
+        await api.inbound.dispatchMessage(openclawMessage);
+    }
+}
+export default ipadWeChatPlugin;