@gloablehive/celphone-wechat-plugin 1.0.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@gloablehive/celphone-wechat-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "OpenClaw channel plugin for workphone-wechat API - enables sending/receiving WeChat messages through workphone",
+  "main": "index.ts",
+  "scripts": {
+    "test": "npx tsx test-cache.ts",
+    "test:cache": "npx tsx test-cache.ts",
+    "test:integration": "npx tsx test-integration.ts",
+    "test:mock": "npx tsx mock-server.ts",
+    "build": "tsc",
+    "clean": "rm -rf /tmp/wechat-cache-test*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "setupEntry": "./setup-entry.ts",
+    "channel": {
+      "id": "celphone-wechat",
+      "label": "WorkPhone WeChat",
+      "blurb": "Connect OpenClaw to WorkPhone WeChat API for sending and receiving WeChat messages"
+    }
+  },
+  "dependencies": {
+    "@gloablehive/wechat-cache": "^1.0.0",
+    "openclaw": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.0",
+    "@types/node": "^20.0.0",
+    "express": "^4.18.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.0.0"
+  }
+}

package/setup-entry.ts

@@ -0,0 +1,10 @@
+/**
+ * Setup Entry Point
+ *
+ * Lightweight entry for loading during onboarding/config when channel is disabled
+ */
+
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
+import { celPhoneWeChatPlugin } from "./src/channel.js";
+
+export default defineSetupPluginEntry(celPhoneWeChatPlugin);

package/src/channel.ts

@@ -0,0 +1,398 @@
+/**
+ * WorkPhone WeChat Channel Plugin for OpenClaw
+ *
+ * This channel plugin connects OpenClaw to WorkPhone's WeChat API,
+ * enabling sending and receiving WeChat messages through the WorkPhone platform.
+ *
+ * IMPORTANT - Human Account Model:
+ * Unlike Telegram/WhatsApp bots, this connects to a real human WeChat account.
+ * The agent communicates with ALL friends and groups under that WeChat account,
+ * not just one DM context. This is "human mode" vs "bot mode".
+ *
+ * Includes Local Cache:
+ * - 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 { createWorkPhoneClient, type WebhookPayload } from "./client.js";
+
+// Import cache modules from shared package
+import {
+  createCacheManager,
+  CacheManager,
+  WeChatAccount,
+} 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>)?.["celphone-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 || section.wechatAccountId,
+      nickName: section.nickName || 'WeChat User',
+      enabled: true,
+    });
+  }
+
+  const basePath = (globalThis as any)?.process?.env?.OPENCLAW_CACHE_PATH
+    || '~/.openclaw/channels/celphone-wechat';
+
+  cacheManager = createCacheManager({
+    basePath,
+    accounts,
+    saasConfig: section?.saas ? {
+      apiBaseUrl: section.saas.apiBaseUrl,
+      apiKey: section.saas.apiKey,
+      timeout: section.saas.timeout || 5000,
+    } : undefined,
+    syncConfig: section?.sync ? {
+      databaseUrl: section.sync.databaseUrl,
+      syncMode: section.sync.syncMode || 'interval',
+      syncIntervalMs: section.sync.syncIntervalMs || 5 * 60 * 1000,
+    } : undefined,
+  });
+
+  // Initialize cache manager
+  cacheManager.init().catch(err => {
+    console.error('[CelPhoneWeChat] Cache manager init failed:', err);
+  });
+
+  return cacheManager;
+}
+
+export interface CelPhoneWeChatResolvedAccount {
+  accountId: string | null;
+  apiKey: string;
+  baseUrl: string;
+  wechatAccountId: string;  // Required - which WeChat account this is
+  wechatId: string;         // The actual WeChat ID (wxid_xxx)
+  nickName: string;         // WeChat nickname for display
+  allowFrom: string[];
+  dmPolicy: string | undefined;
+}
+
+/**
+ * Resolve account from OpenClaw config
+ *
+ * Note: This is a "human account" model - the WeChat account represents
+ * a real person with all their friends and groups, not a bot.
+ */
+function resolveAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null
+): CelPhoneWeChatResolvedAccount {
+  const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+  const apiKey = section?.apiKey;
+  const baseUrl = section?.baseUrl || "https://api.workphone.example.com";
+  const wechatAccountId = section?.wechatAccountId;
+
+  if (!apiKey) {
+    throw new Error("celphone-wechat: apiKey is required");
+  }
+
+  if (!wechatAccountId) {
+    throw new Error("celphone-wechat: wechatAccountId is required (the WeChat account to use)");
+  }
+
+  return {
+    accountId: accountId ?? null,
+    apiKey,
+    baseUrl,
+    wechatAccountId,
+    wechatId: section?.wechatId || wechatAccountId,  // Actual WeChat ID (wxid_xxx)
+    nickName: section?.nickName || "WeChat User",     // Display name
+    allowFrom: section?.allowFrom ?? [],
+    dmPolicy: section?.dmSecurity,
+  };
+}
+
+/**
+ * Create the channel plugin
+ */
+export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolvedAccount>({
+  base: createChannelPluginBase({
+    id: "celphone-wechat",
+    setup: {
+      resolveAccount,
+      inspectAccount(cfg, accountId) {
+        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+        const hasApiKey = Boolean(section?.apiKey);
+        return {
+          enabled: hasApiKey,
+          configured: hasApiKey,
+          tokenStatus: hasApiKey ? "available" : "missing",
+        };
+      },
+    },
+  }),
+
+  // DM security: who can message the bot
+  security: {
+    dm: {
+      channelKey: "celphone-wechat",
+      resolvePolicy: (account) => account.dmPolicy,
+      resolveAllowFrom: (account) => account.allowFrom,
+      defaultPolicy: "allowlist", // Default to allowlist for security
+    },
+  },
+
+  // Pairing: not currently supported for this channel
+  // WorkPhone WeChat doesn't have a standard pairing flow
+  // pairing: { ... },
+
+  // Threading: how replies are delivered
+  // For WeChat, replies go back to the same chat (friend or chatroom)
+  threading: {
+    topLevelReplyToMode: "reply", // Reply to the last message in the thread
+  },
+
+  // Outbound: send messages to WeChat via WorkPhone API
+  //
+  // HUMAN ACCOUNT MODEL IMPORTANT:
+  // This channel connects to a real person's WeChat account.
+  // The agent needs to communicate with ALL their friends and groups,
+  // not just one conversation. We distinguish by conversation type:
+  // - DM (direct): friendWechatId in params.to
+  // - Group chat: chatroomId in params.to (detect by format or metadata)
+  outbound: {
+    attachedResults: {
+      // Send text - detect if DM or group based on conversation metadata
+      sendText: async (params) => {
+        const client = createWorkPhoneClient({
+          baseUrl: params.account.baseUrl,
+          apiKey: params.account.apiKey,
+          accountId: params.account.accountId || undefined,
+          wechatAccountId: params.account.wechatAccountId,
+        });
+
+        // Check if this is a group message (chatroom)
+        // Chatroom IDs typically start with certain prefix or have specific format
+        const isChatroom = params.metadata?.conversationType === 'group' ||
+                          (params.to && params.to.includes('@chatroom'));
+
+        let result;
+        if (isChatroom) {
+          // Send to chatroom (group)
+          result = await client.sendChatroomMessage({
+            wechatAccountId: params.account.wechatAccountId,
+            chatroomId: params.to,
+            content: params.text,
+            type: 'text',
+          });
+        } else {
+          // Send to friend (DM)
+          result = await client.sendFriendMessage({
+            wechatAccountId: params.account.wechatAccountId,
+            friendWechatId: params.to,
+            content: params.text,
+            type: 'text',
+          });
+        }
+
+        return { messageId: result.messageId };
+      },
+
+      // Send media - also support both DM and group
+      sendMedia: async (params) => {
+        const client = createWorkPhoneClient({
+          baseUrl: params.account.baseUrl,
+          apiKey: params.account.apiKey,
+          accountId: params.account.accountId || undefined,
+          wechatAccountId: params.account.wechatAccountId,
+        });
+
+        const isChatroom = params.metadata?.conversationType === 'group' ||
+                          (params.to && params.to.includes('@chatroom'));
+
+        let result;
+        if (isChatroom) {
+          result = await client.sendChatroomMessage({
+            wechatAccountId: params.account.wechatAccountId,
+            chatroomId: params.to,
+            content: params.filePath || '',
+            type: 'file',
+          });
+        } else {
+          result = await client.sendFriendMessage({
+            wechatAccountId: params.account.wechatAccountId,
+            friendWechatId: params.to,
+            content: params.filePath || '',
+            type: 'file',
+          });
+        }
+
+        return { messageId: result.messageId };
+      },
+    },
+
+    // Additional outbound handlers can be added here for:
+    // - sendLink: Send link cards
+    // - sendLocation: Send location
+    // - sendContact: Send contact card
+  },
+
+  // Additional capabilities
+  // - Describe the channel's message types and features
+  capabilities: {
+    supportedMessageTypes: [
+      "text",
+      "image",
+      "video",
+      "file",
+      "link",
+      "location",
+      "contact",
+    ],
+    maxAttachmentSize: 25 * 1024 * 1024, // 25MB
+    supportsMarkdown: false, // WeChat uses a limited markup
+    supportsHtml: false,
+    supportsEmoji: true,
+    supportsReactions: false, // WeChat doesn't support reactions
+    supportsThreads: true,   // Can reply in chat
+    supportsEditing: false,  // Cannot edit sent messages
+    supportsDeleting: false, // Cannot delete sent messages
+  },
+});
+
+/**
+ * Helper function to handle inbound webhook messages
+ * This should be called from your HTTP route handler
+ *
+ * Integrates with Cache Manager for:
+ * - Local MD file caching
+ * - User profile storage
+ * - Session memory
+ * - Cloud sync
+ * - Offline fallback
+ */
+export async function handleInboundMessage(
+  api: any,
+  payload: WebhookPayload,
+  cfg?: OpenClawConfig
+): Promise<void> {
+  const { event, accountId, wechatAccountId, message, friendRequest } = payload;
+
+  if (event === 'message' && message) {
+    // Determine conversation type
+    const isChatroom = !!(message as any).chatroomId;
+    const conversationId = isChatroom
+      ? (message as any).chatroomId
+      : message.fromUser || message.toUser || '';
+
+    // Convert to cache format and store locally
+    if (cacheManager && accountId) {
+      try {
+        await cacheManager.onMessage({
+          messageId: message.messageId,
+          msgSvrId: message.msgSvrId,
+          accountId: accountId,
+          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: message.isSelf ? 'outbound' : 'inbound',
+        });
+      } catch (err) {
+        console.error('[CelPhoneWeChat] Cache write failed:', err);
+      }
+    }
+
+    // Convert WorkPhone message format to OpenClaw format
+    const openclawMessage = {
+      id: message.messageId,
+      rawId: message.msgSvrId || message.messageId,
+      conversation: {
+        type: isChatroom ? 'group' as const : 'dm' as const,
+        id: conversationId,
+        chatroomId: isChatroom ? conversationId : undefined,
+      },
+      sender: {
+        id: message.fromUser || '',
+        platformId: message.wechatId,
+      },
+      content: {
+        type: message.type === 1 ? 'text' : 'media',
+        text: message.content,
+      },
+      timestamp: new Date(message.timestamp || Date.now()),
+      isSelf: message.isSelf || false,
+    };
+
+    // Dispatch to OpenClaw
+    await api.inbound.dispatchMessage(openclawMessage);
+  } else if (event === 'friend_request' && friendRequest) {
+    // Handle friend request
+    await api.inbound.dispatchFriendRequest({
+      id: friendRequest.v1,
+      platformId: friendRequest.fromUser,
+      scene: friendRequest.scene,
+      ticket: friendRequest.ticket,
+      accountId,
+      wechatAccountId,
+    });
+  }
+}
+
+/**
+ * Get user profile from cache (for agent use)
+ */
+export async function getUserProfile(
+  accountId: string,
+  wechatId: string
+): Promise<any> {
+  if (!cacheManager) return null;
+  return await cacheManager.getProfile(accountId, wechatId);
+}
+
+/**
+ * Update user profile in cache
+ */
+export async function updateUserProfile(
+  accountId: string,
+  wechatId: string,
+  updates: any
+): Promise<void> {
+  if (!cacheManager) return;
+  await cacheManager.updateProfile(accountId, wechatId, updates);
+}
+
+/**
+ * Get SAAS connection status
+ */
+export function getConnectionStatus() {
+  return cacheManager?.getConnectionStatus();
+}
+
+/**
+ * Check if system is online (SAAS connected)
+ */
+export function isOnline(): boolean {
+  return cacheManager?.isSAASOnline() ?? false;
+}
+
+export default celPhoneWeChatPlugin;