@gloablehive/ipad-wechat-plugin 1.0.0

package/index.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 } 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);
+          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/openclaw.plugin.json

@@ -0,0 +1,91 @@
+{
+  "$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": {
+      "apiKey": {
+        "type": "string",
+        "description": "iPad WeChat API key for authentication",
+        "secret": true,
+        "required": true
+      },
+      "baseUrl": {
+        "type": "string",
+        "description": "iPad WeChat API base URL"
+      },
+      "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": ["apiKey", "baseUrl"]
+  },
+  "permissions": {
+    "channels": ["ipad-wechat"],
+    "http": {
+      "outbound": ["*"],
+      "inbound": ["/ipad-wechat/webhook"]
+    }
+  },
+  "apiVersion": "1.0.0"
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@gloablehive/ipad-wechat-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "OpenClaw channel plugin for iPad WeChat protocol - enables sending/receiving WeChat messages through iPad protocol",
+  "main": "index.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "npx tsx test-ipad.ts",
+    "dev": "tsx watch index.ts"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "ipad-wechat",
+      "label": "iPad WeChat",
+      "blurb": "Connect OpenClaw to iPad WeChat protocol for sending and receiving WeChat messages"
+    }
+  },
+  "dependencies": {
+    "@gloablehive/wechat-cache": "^1.0.0",
+    "openclaw": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/channel.ts

@@ -0,0 +1,250 @@
+/**
+ * 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 type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { createIPadClient, type WebhookPayload } from "./client.js";
+
+// Import cache modules from shared package
+import {
+  createCacheManager,
+  CacheManager,
+  WeChatAccount,
+  WeChatMessage,
+} from "@gloablehive/wechat-cache";
+
+// Cache manager instance (lazy initialized)
+let cacheManager: CacheManager | null = null;
+
+/**
+ * Get or create cache manager
+ */
+function getCacheManager(cfg: OpenClawConfig): CacheManager {
+  if (cacheManager) return cacheManager;
+
+  const section = (cfg.channels as Record<string, any>)?.["ipad-wechat"];
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  // 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;
+}
+
+export interface IPadWeChatResolvedAccount {
+  accountId: string | null;
+  apiKey: string;
+  baseUrl: string;
+  wechatAccountId: string;
+  wechatId: string;
+  nickName: string;
+  allowFrom: string[];
+  dmPolicy: string | undefined;
+}
+
+function resolveAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null
+): IPadWeChatResolvedAccount {
+  const section = (cfg.channels as Record<string, any>)?.["ipad-wechat"];
+  const apiKey = section?.apiKey;
+  const baseUrl = section?.baseUrl || "https://api.example.com";
+
+  if (!apiKey) {
+    throw new Error("ipad-wechat: apiKey is required");
+  }
+
+  return {
+    accountId: accountId ?? null,
+    apiKey,
+    baseUrl,
+    wechatAccountId: section?.wechatAccountId || "",
+    wechatId: section?.wechatId || "",
+    nickName: section?.nickName || "WeChat User",
+    allowFrom: section?.allowFrom ?? [],
+    dmPolicy: section?.dmSecurity,
+  };
+}
+
+export const ipadWeChatPlugin = createChatChannelPlugin<IPadWeChatResolvedAccount>({
+  base: createChannelPluginBase({
+    id: "ipad-wechat",
+    setup: {
+      resolveAccount,
+      inspectAccount(cfg, accountId) {
+        const section = (cfg.channels as Record<string, any>)?.["ipad-wechat"];
+        const hasApiKey = Boolean(section?.apiKey);
+        return {
+          enabled: hasApiKey,
+          configured: hasApiKey,
+          tokenStatus: hasApiKey ? "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) => {
+        const client = createIPadClient({
+          baseUrl: params.account.baseUrl,
+          apiKey: params.account.apiKey,
+        });
+
+        // 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 client = createIPadClient({
+          baseUrl: params.account.baseUrl,
+          apiKey: params.account.apiKey,
+        });
+
+        const isChatroom = params.to?.includes("@chatroom");
+
+        if (isChatroom) {
+          const result = await client.sendRoomMedia({
+            roomId: params.to,
+            filePath: params.filePath || "",
+          });
+          return { messageId: result.messageId };
+        } else {
+          const result = await client.sendFriendMedia({
+            friendWechatId: params.to,
+            filePath: params.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: any,
+  payload: WebhookPayload,
+  cfg?: OpenClawConfig
+): Promise<void> {
+  const { event, message } = payload;
+
+  if (event === "message" && message) {
+    const isChatroom = !!(message as any).roomId;
+    const conversationId = isChatroom
+      ? (message as any).roomId
+      : message.fromUser || message.toUser || "";
+
+    const openclawMessage = {
+      id: message.messageId,
+      conversation: {
+        type: isChatroom ? "group" as const : "dm" as const,
+        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: WeChatMessage = {
+          messageId: message.messageId,
+          accountId: (cfg.channels as Record<string, any>)?.["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;

package/src/client.ts

@@ -0,0 +1,272 @@
+/**
+ * iPad WeChat API Client
+ *
+ * Based on wechat/api.md documentation
+ * Different from WorkPhone - uses iPad protocol
+ */
+
+export interface IPadClientConfig {
+  baseUrl: string;
+  apiKey: string;
+}
+
+export interface WebhookPayload {
+  event: string;
+  message?: {
+    messageId: string;
+    fromUser: string;
+    toUser: string;
+    content: string;
+    type: number;
+    timestamp: number;
+    isSelf: boolean;
+    roomId?: string;
+  };
+}
+
+export interface SendTextResponse {
+  messageId: string;
+  msgSvrId: string;
+}
+
+export interface SendMediaResponse {
+  messageId: string;
+  msgSvrId: string;
+}
+
+export interface Contact {
+  wechatId: string;
+  nickName: string;
+  remark: string;
+  avatar?: string;
+}
+
+export interface RoomInfo {
+  roomId: string;
+  name: string;
+  ownerId: string;
+  memberCount: number;
+}
+
+function getHeaders(apiKey: string) {
+  return {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+  };
+}
+
+export function createIPadClient(config: IPadClientConfig) {
+  const { baseUrl, apiKey } = config;
+
+  return {
+    // ========== 消息发送 ==========
+
+    async sendFriendMessage(params: {
+      friendWechatId: string;
+      content: string;
+    }): Promise<SendTextResponse> {
+      // API: 发送文本消息 - api-316658257
+      const response = await fetch(`${baseUrl}/api-316658257`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({
+          toUser: params.friendWechatId,
+          content: params.content,
+        }),
+      });
+      const data = await response.json();
+      return {
+        messageId: data.data?.messageId || `msg_${Date.now()}`,
+        msgSvrId: data.data?.msgSvrId || "",
+      };
+    },
+
+    async sendRoomMessage(params: {
+      roomId: string;
+      content: string;
+    }): Promise<SendTextResponse> {
+      // API: 发送群@消息 - api-316658258
+      const response = await fetch(`${baseUrl}/api-316658258`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({
+          roomId: params.roomId,
+          content: params.content,
+        }),
+      });
+      const data = await response.json();
+      return {
+        messageId: data.data?.messageId || `msg_${Date.now()}`,
+        msgSvrId: data.data?.msgSvrId || "",
+      };
+    },
+
+    async sendFriendMedia(params: {
+      friendWechatId: string;
+      filePath: string;
+    }): Promise<SendMediaResponse> {
+      // API: 发送图片 - api-316658262
+      const response = await fetch(`${baseUrl}/api-316658262`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({
+          toUser: params.friendWechatId,
+          filePath: params.filePath,
+        }),
+      });
+      const data = await response.json();
+      return {
+        messageId: data.data?.messageId || `msg_${Date.now()}`,
+        msgSvrId: data.data?.msgSvrId || "",
+      };
+    },
+
+    async sendRoomMedia(params: {
+      roomId: string;
+      filePath: string;
+    }): Promise<SendMediaResponse> {
+      // API: 发送图片到群 - 复用图片接口
+      const response = await fetch(`${baseUrl}/api-316658262`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({
+          roomId: params.roomId,
+          filePath: params.filePath,
+        }),
+      });
+      const data = await response.json();
+      return {
+        messageId: data.data?.messageId || `msg_${Date.now()}`,
+        msgSvrId: data.data?.msgSvrId || "",
+      };
+    },
+
+    // ========== 联系人管理 ==========
+
+    async syncContacts(): Promise<Contact[]> {
+      // API: 同步联系人 - api-316658212
+      const response = await fetch(`${baseUrl}/api-316658212`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({}),
+      });
+      const data = await response.json();
+      return data.data?.contacts || [];
+    },
+
+    async getContactDetail(wechatId: string): Promise<Contact> {
+      // API: 获取联系人详细 - api-316658219
+      const response = await fetch(`${baseUrl}/api-316658219`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ userId: wechatId }),
+      });
+      const data = await response.json();
+      return data.data || {};
+    },
+
+    async updateFriendRemark(wechatId: string, remark: string): Promise<void> {
+      // API: 修改好友备注 - api-316658224
+      await fetch(`${baseUrl}/api-316658224`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({
+          userId: wechatId,
+          remark,
+        }),
+      });
+    },
+
+    // ========== 群管理 ==========
+
+    async getRoomInfo(roomId: string): Promise<RoomInfo> {
+      // API: 获取群信息 - api-316658229
+      const response = await fetch(`${baseUrl}/api-316658229`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ roomId }),
+      });
+      const data = await response.json();
+      return data.data || {};
+    },
+
+    async getRoomMembers(roomId: string): Promise<string[]> {
+      // API: 获取群成员详细 - api-316658230
+      const response = await fetch(`${baseUrl}/api-316658230`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ roomId }),
+      });
+      const data = await response.json();
+      return data.data?.members || [];
+    },
+
+    async createRoom(memberIds: string[]): Promise<{ roomId: string }> {
+      // API: 创建群组 - api-316658231
+      const response = await fetch(`${baseUrl}/api-316658231`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ memberIds }),
+      });
+      const data = await response.json();
+      return { roomId: data.data?.roomId || "" };
+    },
+
+    async addRoomMember(roomId: string, memberId: string): Promise<void> {
+      // API: 添加群成员 - api-316658232
+      await fetch(`${baseUrl}/api-316658232`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ roomId, memberId }),
+      });
+    },
+
+    async removeRoomMember(roomId: string, memberId: string): Promise<void> {
+      // API: 移除群成员 - api-316658234
+      await fetch(`${baseUrl}/api-316658234`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ roomId, memberId }),
+      });
+    },
+
+    // ========== 账号 ==========
+
+    async getLoginAccountInfo(): Promise<{
+      wechatId: string;
+      nickName: string;
+      avatar: string;
+    }> {
+      // API: 获取登录账号信息 - api-316658209
+      const response = await fetch(`${baseUrl}/api-316658209`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({}),
+      });
+      const data = await response.json();
+      return data.data || {};
+    },
+
+    // ========== 朋友圈 ==========
+
+    async getFriendMoments(wechatId: string, limit: number = 20): Promise<any[]> {
+      // API: 获取好友朋友圈动态 - api-316658314
+      const response = await fetch(`${baseUrl}/api-316658314`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ userId: wechatId, limit }),
+      });
+      const data = await response.json();
+      return data.data?.moments || [];
+    },
+
+    async publishMoment(content: string, images: string[]): Promise<void> {
+      // API: 发布朋友圈 - api-316658315
+      await fetch(`${baseUrl}/api-316658315`, {
+        method: "POST",
+        headers: getHeaders(apiKey),
+        body: JSON.stringify({ content, images }),
+      });
+    },
+  };
+}

package/tsconfig.json

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