@gloablehive/celphone-wechat-plugin 1.0.0

package/src/client.ts

@@ -0,0 +1,412 @@
+/**
+ * WorkPhone WeChat API Client
+ *
+ * Interfaces with the WorkPhone API for sending/receiving WeChat messages
+ * Based on the Apifox API manual: data/apifox-workphone-3/
+ */
+
+export interface WorkPhoneConfig {
+  baseUrl: string;
+  apiKey: string;
+  accountId?: string;
+  wechatAccountId?: string;
+}
+
+export interface WeChatFriend {
+  wechatFriendId: string;
+  wechatId: string;
+  nickName: string;
+  remark: string;
+  avatar?: string;
+  label?: string[];
+  phones?: string[];
+}
+
+export interface WeChatChatroom {
+  wechatChatroomId: string;
+  chatroomId: string;
+  name: string;
+  ownerId: string;
+  memberCount: number;
+}
+
+export interface WeChatMessage {
+  messageId: string;
+  msgSvrId?: string;
+  wechatId: string;
+  content: string;
+  type: number;
+  timestamp: number;
+  isSelf: boolean;
+  fromUser?: string;
+  toUser?: string;
+}
+
+export interface SendMessageParams {
+  wechatAccountId: string;
+  toUser: string;
+  content: string;
+  type?: 'text' | 'image' | 'video' | 'file' | 'link' | 'card';
+}
+
+export interface SendMessageResult {
+  messageId: string;
+  msgSvrId?: string;
+  success: boolean;
+}
+
+export interface WebhookPayload {
+  event: 'message' | 'friend_request' | 'group_invite' | 'system';
+  accountId: string;
+  wechatAccountId: string;
+  message?: WeChatMessage;
+  friendRequest?: {
+    v1: string;
+    scene: number;
+    fromUser: string;
+    ticket?: string;
+  };
+  timestamp: number;
+}
+
+export class WorkPhoneWeChatClient {
+  private config: WorkPhoneConfig;
+
+  constructor(config: WorkPhoneConfig) {
+    this.config = config;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: any,
+    query?: Record<string, string>
+  ): Promise<T> {
+    const url = new URL(`${this.config.baseUrl}${path}`);
+    if (query) {
+      Object.entries(query).forEach(([k, v]) => url.searchParams.append(k, v));
+    }
+
+    const headers: Record<string, string> = {
+      'Authorization': `Bearer ${this.config.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    if (this.config.accountId) {
+      headers['X-Account-Id'] = this.config.accountId;
+    }
+
+    const response = await fetch(url.toString(), {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`WorkPhone API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  // ========== WeChat Account Operations ==========
+
+  /**
+   * Get all WeChat accounts for an account
+   * GET /api/v1/accounts/{accountId}/wechatAccounts
+   */
+  async getWeChatAccounts(accountId: string): Promise<WeChatFriend[]> {
+    return this.request('GET', `/api/v1/accounts/${accountId}/wechatAccounts`);
+  }
+
+  /**
+   * Get WeChat account info by wechatId
+   * GET /wp/api/v1/wechatAccounts/{wechatId}/byWechatId
+   */
+  async getWeChatAccountById(wechatId: string): Promise<any> {
+    return this.request('GET', `/wp/api/v1/wechatAccounts/${wechatId}/byWechatId`);
+  }
+
+  // ========== Friend Operations ==========
+
+  /**
+   * Get all friends for a WeChat account
+   * GET /wp/api/v1/wechatAccounts/{wechatAccountId}/friends
+   */
+  async getFriends(wechatAccountId: string, options?: {
+    page?: number;
+    pageSize?: number;
+    labelId?: string;
+  }): Promise<{ list: WeChatFriend[]; total: number }> {
+    return this.request('GET', `/wp/api/v1/wechatAccounts/${wechatAccountId}/friends`, undefined, options as any);
+  }
+
+  /**
+   * Search friends
+   * GET /wp/api/v1/wechatFriends
+   */
+  async searchFriends(params: {
+    accountId?: string;
+    wechatAccountId?: string;
+    keyword?: string;
+  }): Promise<WeChatFriend[]> {
+    return this.request('GET', '/wp/api/v1/wechatFriends', undefined, params);
+  }
+
+  /**
+   * Get friend by ID
+   * GET /wp/api/v1/wechatFriends/{wechatFriendId}
+   */
+  async getFriend(wechatFriendId: string): Promise<WeChatFriend> {
+    return this.request('GET', `/wp/api/v1/wechatFriends/${wechatFriendId}`);
+  }
+
+  /**
+   * Add friend (send friend request)
+   * POST /wp/api/v1/wechatFriends/addFriend
+   */
+  async addFriend(params: {
+    wechatAccountId: string;
+    v1: string;  // WeChat ID to add
+    verifyMessage?: string;
+    scene?: number;  // 15: QQ号, 16: 微信号, 17: 手机号, 22: 朋友推荐
+  }): Promise<{ success: boolean; taskId?: string }> {
+    return this.request('POST', '/wp/api/v1/wechatFriends/addFriend', params);
+  }
+
+  /**
+   * Accept friend request
+   * POST /wp/api/v1/wechatFriends/{wechatFriendId}/acceptFriend
+   */
+  async acceptFriend(wechatFriendId: string): Promise<{ success: boolean }> {
+    return this.request('POST', `/wp/api/v1/wechatFriends/${wechatFriendId}/acceptFriend`);
+  }
+
+  /**
+   * Update friend remark
+   * PUT /wp/api/v1/wechatFriends/{wechatFriendId}/remark
+   */
+  async updateFriendRemark(wechatFriendId: string, remark: string): Promise<{ success: boolean }> {
+    return this.request('PUT', `/wp/api/v1/wechatFriends/${wechatFriendId}/remark`, { remark });
+  }
+
+  /**
+   * Update friend labels
+   * PUT /wp/api/v1/wechatFriends/{wechatFriendId}/label
+   */
+  async updateFriendLabels(wechatFriendId: string, labelIds: string[]): Promise<{ success: boolean }> {
+    return this.request('PUT', `/wp/api/v1/wechatFriends/${wechatFriendId}/label`, { labelIds });
+  }
+
+  // ========== Chatroom (Group) Operations ==========
+
+  /**
+   * Get all chatrooms for a WeChat account
+   * GET /wp/api/v1/wechatAccounts/{wechatAccountId}/chatrooms
+   */
+  async getChatrooms(wechatAccountId: string): Promise<WeChatChatroom[]> {
+    return this.request('GET', `/wp/api/v1/wechatAccounts/${wechatAccountId}/chatrooms`);
+  }
+
+  /**
+   * Get chatroom info by chatroomId
+   * GET /wp/api/v1/wechatChatrooms/{wechatChatroomId}
+   */
+  async getChatroom(wechatChatroomId: string): Promise<WeChatChatroom> {
+    return this.request('GET', `/wp/api/v1/wechatChatrooms/${wechatChatroomId}`);
+  }
+
+  /**
+   * Update chatroom name (announcement)
+   * PUT /wp/api/v1/wechatChatrooms/{wechatChatroomId}/chatroomName
+   */
+  async updateChatroomName(wechatChatroomId: string, name: string): Promise<{ success: boolean }> {
+    return this.request('PUT', `/wp/api/v1/wechatChatrooms/${wechatChatroomId}/chatroomName`, { name });
+  }
+
+  /**
+   * Publish chatroom announcement
+   * PUT /api/v1/wechat/chatroom/announcement
+   */
+  async publishChatroomAnnouncement(wechatChatroomId: string, content: string): Promise<{ success: boolean }> {
+    return this.request('PUT', '/api/v1/wechat/chatroom/announcement', {
+      wechatChatroomId,
+      content,
+    });
+  }
+
+  // ========== Message Operations ==========
+
+  /**
+   * Get friend messages (1-on-1 chat)
+   * GET /wp/api/v1/wechat/friendMessages
+   */
+  async getFriendMessages(params: {
+    wechatAccountId: string;
+    friendWechatId: string;
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+    offset?: number;
+  }): Promise<{ list: WeChatMessage[]; total: number }> {
+    return this.request('GET', '/wp/api/v1/wechat/friendMessages', undefined, params as any);
+  }
+
+  /**
+   * Get chatroom messages (group chat)
+   * GET /wp/api/v1/wechat/chatroomMessages
+   */
+  async getChatroomMessages(params: {
+    wechatAccountId: string;
+    chatroomId: string;
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+    offset?: number;
+  }): Promise<{ list: WeChatMessage[]; total: number }> {
+    return this.request('GET', '/wp/api/v1/wechat/chatroomMessages', undefined, params as any);
+  }
+
+  /**
+   * Send friend message (1-on-1)
+   * POST /wp/api/v1/wechat/friendMessages
+   */
+  async sendFriendMessage(params: {
+    wechatAccountId: string;
+    friendWechatId: string;
+    content: string;
+    type?: 'text' | 'image' | 'video' | 'file' | 'link';
+  }): Promise<SendMessageResult> {
+    return this.request('POST', '/wp/api/v1/wechat/friendMessages', params);
+  }
+
+  /**
+   * Send chatroom message (group)
+   * POST /wp/api/v1/wechat/chatroomMessages
+   */
+  async sendChatroomMessage(params: {
+    wechatAccountId: string;
+    chatroomId: string;
+    content: string;
+    type?: 'text' | 'image' | 'video' | 'file' | 'link';
+    atUsers?: string[];  // WeChat IDs to @mention
+  }): Promise<SendMessageResult> {
+    return this.request('POST', '/wp/api/v1/wechat/chatroomMessages', params);
+  }
+
+  // ========== Moments (朋友圈) Operations ==========
+
+  /**
+   * Get moments
+   * GET /wp/api/v1/moments
+   */
+  async getMoments(params: {
+    wechatAccountId: string;
+    startTime?: number;
+    endTime?: number;
+    limit?: number;
+  }): Promise<{ list: any[]; total: number }> {
+    return this.request('GET', '/wp/api/v1/moments', undefined, params as any);
+  }
+
+  /**
+   * Publish moment (post to Moments)
+   * POST /wp/api/v1/moments
+   */
+  async publishMoment(params: {
+    wechatAccountId: string;
+    content: string;
+    images?: string[];  // URLs or paths
+    videos?: string[];
+    location?: { lat: number; lng: number; name: string };
+  }): Promise<{ momentId: string; success: boolean }> {
+    return this.request('POST', '/wp/api/v1/moments', params);
+  }
+
+  /**
+   * Comment on a moment
+   * POST /wp/api/v1/moments/{momentId}/comment
+   */
+  async commentMoment(momentId: string, content: string, replyCommentId?: string): Promise<{ success: boolean }> {
+    return this.request('POST', `/wp/api/v1/moments/${momentId}/comment`, {
+      content,
+      replyCommentId,
+    });
+  }
+
+  /**
+   * Like a moment
+   * POST /wp/api/v1/moments/{momentId}/like
+   */
+  async likeMoment(momentId: string): Promise<{ success: boolean }> {
+    return this.request('POST', `/wp/api/v1/moments/${momentId}/like`);
+  }
+
+  // ========== Media Download ==========
+
+  /**
+   * Download friend message file
+   */
+  async downloadFriendFile(messageId: string, wechatTime: number): Promise<Blob> {
+    const url = `${this.config.baseUrl}/wp/api/v1/wechat/friendMessage/downloadFile/${messageId}/${wechatTime}`;
+    const response = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${this.config.apiKey}` },
+    });
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status}`);
+    }
+    return response.blob();
+  }
+
+  /**
+   * Download chatroom message file
+   */
+  async downloadChatroomFile(messageId: string, wechatTime: number): Promise<Blob> {
+    const url = `${this.config.baseUrl}/wp/api/v1/wechat/chatroomMessage/downloadFile/${messageId}/${wechatTime}`;
+    const response = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${this.config.apiKey}` },
+    });
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status}`);
+    }
+    return response.blob();
+  }
+
+  // ========== Webhook Parsing ==========
+
+  /**
+   * Parse webhook payload from WorkPhone callback
+   * This should be called by your webhook endpoint handler
+   */
+  parseWebhookPayload(payload: any): WebhookPayload | null {
+    // WorkPhone webhook format - adjust based on actual webhook docs
+    const eventMap: Record<string, WebhookPayload['event']> = {
+      'msg': 'message',
+      'friend_request': 'friend_request',
+      'group_invite': 'group_invite',
+      'system': 'system',
+    };
+
+    return {
+      event: eventMap[payload.event] || 'message',
+      accountId: payload.accountId || '',
+      wechatAccountId: payload.wechatAccountId || '',
+      message: payload.message,
+      friendRequest: payload.friendRequest,
+      timestamp: payload.timestamp || Date.now(),
+    };
+  }
+}
+
+/**
+ * Factory function to create a WorkPhone client from OpenClaw config
+ */
+export function createWorkPhoneClient(config: {
+  baseUrl: string;
+  apiKey: string;
+  accountId?: string;
+  wechatAccountId?: string;
+}): WorkPhoneWeChatClient {
+  return new WorkPhoneWeChatClient(config);
+}

package/test-cache.ts

@@ -0,0 +1,260 @@
+/**
+ * Test Script for WeChat Cache System
+ * Run: npx tsx test-cache.ts
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import {
+  createCacheManager,
+  CacheManager,
+  WeChatAccount,
+  WeChatMessage,
+} from './src/cache/index.js';
+
+const TEST_CACHE_PATH = '/tmp/wechat-cache-test';
+const ENCODING = 'utf-8';
+
+async function cleanup() {
+  try {
+    await fs.rm(TEST_CACHE_PATH, { recursive: true, force: true });
+  } catch {}
+}
+
+async function test1_CreateCacheManager() {
+  console.log('\n📋 Test 1: Create Cache Manager');
+
+  const accounts: WeChatAccount[] = [
+    {
+      accountId: 'test-account-001',
+      wechatAccountId: 'wp-wechat-001',
+      wechatId: 'wxid_test001',
+      nickName: '测试客服',
+      enabled: true,
+    },
+  ];
+
+  const manager = createCacheManager({
+    basePath: TEST_CACHE_PATH,
+    accounts,
+  });
+
+  await manager.init();
+  console.log('✅ Cache manager created and initialized');
+
+  return manager;
+}
+
+async function test2_MessageCaching(manager: CacheManager) {
+  console.log('\n📋 Test 2: Message Caching');
+
+  const message: WeChatMessage = {
+    messageId: 'msg-001',
+    msgSvrId: 'msg-svr-001',
+    accountId: 'test-account-001',
+    conversationType: 'friend',
+    conversationId: 'wxid_alice',
+    senderId: 'wxid_alice',
+    content: '你好，我想咨询产品',
+    messageType: 1,
+    timestamp: Date.now(),
+    isSelf: false,
+    direction: 'inbound',
+  };
+
+  await manager.onMessage(message);
+  console.log('✅ Message cached:', message.messageId);
+
+  // Send a reply
+  const reply: WeChatMessage = {
+    messageId: 'msg-002',
+    msgSvrId: 'msg-svr-002',
+    accountId: 'test-account-001',
+    conversationType: 'friend',
+    conversationId: 'wxid_alice',
+    senderId: 'wxid_test001',
+    content: '您好，请问有什么可以帮您？',
+    messageType: 1,
+    timestamp: Date.now() + 1000,
+    isSelf: true,
+    direction: 'outbound',
+  };
+
+  await manager.onMessage(reply);
+  console.log('✅ Reply cached:', reply.messageId);
+}
+
+async function test3_VerifyFiles() {
+  console.log('\n📋 Test 3: Verify Files Created');
+
+  // Check account directory
+  const accountPath = path.join(TEST_CACHE_PATH, 'accounts', 'test-account-001');
+  const friendsPath = path.join(accountPath, 'friends');
+
+  const friends = await fs.readdir(friendsPath);
+  console.log('📁 Friends directories:', friends);
+
+  // Check conversation file
+  const convPath = path.join(friendsPath, 'wxid_alice', 'memory');
+  try {
+    const files = await fs.readdir(convPath);
+    console.log('📁 Conversation files:', files);
+
+    if (files.length > 0) {
+      const content = await fs.readFile(path.join(convPath, files[0]), ENCODING);
+      console.log('📄 Conversation content preview:');
+      console.log(content.slice(0, 500) + '...');
+    }
+  } catch (e) {
+    console.log('⚠️ No conversation files found yet');
+  }
+
+  // Check MEMORY.md
+  const globalIndex = path.join(TEST_CACHE_PATH, 'MEMORY.md');
+  try {
+    const indexContent = await fs.readFile(globalIndex, ENCODING);
+    console.log('📄 Global MEMORY.md:');
+    console.log(indexContent.slice(0, 300) + '...');
+  } catch (e) {
+    console.log('⚠️ No global index yet');
+  }
+
+  console.log('✅ File verification complete');
+}
+
+async function test4_ProfileOperations(manager: CacheManager) {
+  console.log('\n📋 Test 4: Profile Operations');
+
+  // Update profile
+  await manager.updateProfile('test-account-001', 'wxid_alice', {
+    remark: 'Alice-客户',
+    tags: ['潜在客户', '高价值'],
+    customFields: { region: '北京' },
+  });
+  console.log('✅ Profile updated');
+
+  // Get profile
+  const profile = await manager.getProfile('test-account-001', 'wxid_alice');
+  console.log('📄 Profile retrieved:', JSON.stringify(profile, null, 2));
+}
+
+async function test5_ConnectionStatus(manager: CacheManager) {
+  console.log('\n📋 Test 5: Connection Status');
+
+  const status = manager.getConnectionStatus();
+  console.log('📄 Connection status:', JSON.stringify(status, null, 2));
+
+  const isOnline = manager.isSAASOnline();
+  console.log('📄 Is online:', isOnline);
+
+  const offlineMsg = manager.getOfflineMessage();
+  console.log('📄 Offline message:', offlineMsg);
+
+  console.log('✅ Connection status check complete');
+}
+
+async function test6_MultiAccount() {
+  console.log('\n📋 Test 6: Multi-Account Support');
+
+  const accounts: WeChatAccount[] = [
+    {
+      accountId: 'account-001',
+      wechatAccountId: 'wp-001',
+      wechatId: 'wxid_001',
+      nickName: '客服1号',
+      enabled: true,
+    },
+    {
+      accountId: 'account-002',
+      wechatAccountId: 'wp-002',
+      wechatId: 'wxid_002',
+      nickName: '客服2号',
+      enabled: true,
+    },
+  ];
+
+  const manager = createCacheManager({
+    basePath: TEST_CACHE_PATH + '-multi',
+    accounts,
+  });
+
+  await manager.init();
+
+  // Send message to account 1
+  await manager.onMessage({
+    messageId: 'msg-multi-001',
+    accountId: 'account-001',
+    conversationType: 'friend',
+    conversationId: 'wxid_user1',
+    senderId: 'wxid_user1',
+    content: 'Message from user 1',
+    messageType: 1,
+    timestamp: Date.now(),
+    isSelf: false,
+    direction: 'inbound',
+  });
+
+  // Send message to account 2
+  await manager.onMessage({
+    messageId: 'msg-multi-002',
+    accountId: 'account-002',
+    conversationType: 'friend',
+    conversationId: 'wxid_user2',
+    senderId: 'wxid_user2',
+    content: 'Message from user 2',
+    messageType: 1,
+    timestamp: Date.now(),
+    isSelf: false,
+    direction: 'inbound',
+  });
+
+  // Verify separate directories
+  const dir1 = path.join(TEST_CACHE_PATH + '-multi', 'accounts', 'account-001', 'friends');
+  const dir2 = path.join(TEST_CACHE_PATH + '-multi', 'accounts', 'account-002', 'friends');
+
+  const users1 = await fs.readdir(dir1);
+  const users2 = await fs.readdir(dir2);
+
+  console.log('📁 Account 1 users:', users1);
+  console.log('📁 Account 2 users:', users2);
+
+  console.log('✅ Multi-account test complete');
+}
+
+async function runAllTests() {
+  console.log('🧪 WeChat Cache System Tests');
+  console.log('='.repeat(50));
+
+  await cleanup();
+
+  try {
+    // Test 1: Create cache manager
+    const manager = await test1_CreateCacheManager();
+
+    // Test 2: Message caching
+    await test2_MessageCaching(manager);
+
+    // Test 3: Verify files
+    await test3_VerifyFiles();
+
+    // Test 4: Profile operations
+    await test4_ProfileOperations(manager);
+
+    // Test 5: Connection status
+    await test5_ConnectionStatus(manager);
+
+    // Test 6: Multi-account
+    await test6_MultiAccount();
+
+    console.log('\n' + '='.repeat(50));
+    console.log('🎉 All tests passed!');
+    console.log('\n📁 Test cache location:', TEST_CACHE_PATH);
+
+  } catch (error) {
+    console.error('\n❌ Test failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run tests
+runAllTests();