@gloablehive/celphone-wechat-plugin 1.0.0 → 1.0.1

package/dist/index.js

@@ -61,15 +61,17 @@ export default defineChannelPluginEntry({
             },
         });
         // Register gateway method for outbound media handling
-        api.registerGatewayMethod({
-            method: "POST",
+        api.registerHttpRoute({
             path: "/celphone-wechat/media",
+            auth: "plugin",
             handler: async (req, res) => {
-                const { messageId, mediaUrl, mediaType } = req.body;
+                const payload = req.body;
+                const { messageId, mediaUrl, mediaType } = payload || {};
                 // Handle media upload/send through WorkPhone
                 // This is called when the bot needs to send media files
+                res.setHeader("Content-Type", "application/json");
                 res.statusCode = 200;
-                res.json({ success: true, messageId });
+                res.end(JSON.stringify({ success: true, messageId }));
                 return true;
             },
         });

package/dist/src/channel.js

@@ -20,8 +20,8 @@
  */
 import { createChatChannelPlugin, createChannelPluginBase, } from "openclaw/plugin-sdk/core";
 import { createWorkPhoneClient } from "./client.js";
-// Import cache modules
-import { createCacheManager, } from "./cache/index.js";
+// Import cache modules from shared package
+import { createCacheManager, } from "@gloablehive/wechat-cache";
 // Cache manager instance (lazy initialized)
 let cacheManager = null;
 /**
@@ -35,15 +35,15 @@ function getCacheManager(cfg) {
     // If no accounts configured, create default from main config
     if (accounts.length === 0 && section?.wechatAccountId) {
         accounts.push({
-            accountId: section.accountId || 'default',
+            accountId: section.accountId || "default",
             wechatAccountId: section.wechatAccountId,
             wechatId: section.wechatId || section.wechatAccountId,
-            nickName: section.nickName || 'WeChat User',
+            nickName: section.nickName || "WeChat User",
             enabled: true,
         });
     }
     const basePath = globalThis?.process?.env?.OPENCLAW_CACHE_PATH
-        || '~/.openclaw/channels/celphone-wechat';
+        || "~/.openclaw/channels/celphone-wechat";
     cacheManager = createCacheManager({
         basePath,
         accounts,
@@ -54,13 +54,13 @@ function getCacheManager(cfg) {
         } : undefined,
         syncConfig: section?.sync ? {
             databaseUrl: section.sync.databaseUrl,
-            syncMode: section.sync.syncMode || 'interval',
+            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);
+        console.error("[CelPhoneWeChat] Cache manager init failed:", err);
     });
     return cacheManager;
 }
@@ -99,112 +99,108 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
     base: createChannelPluginBase({
         id: "celphone-wechat",
         setup: {
-            resolveAccount,
-            inspectAccount(cfg, accountId) {
-                const section = cfg.channels?.["celphone-wechat"];
-                const hasApiKey = Boolean(section?.apiKey);
-                return {
-                    enabled: hasApiKey,
-                    configured: hasApiKey,
-                    tokenStatus: hasApiKey ? "available" : "missing",
-                };
+            resolveAccountId: (params) => {
+                return resolveAccount(params.cfg, params.accountId)?.accountId || "";
             },
+            applyAccountConfig: (params) => params.cfg,
         },
     }),
-    // 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
+            defaultPolicy: "allowlist",
         },
     },
-    // 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
+        topLevelReplyToMode: "reply",
     },
-    // 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: {
+        channel: "celphone-wechat",
         attachedResults: {
-            // Send text - detect if DM or group based on conversation metadata
+            channel: "celphone-wechat",
             sendText: async (params) => {
+                const cfg = params.cfg;
+                const section = cfg.channels?.["celphone-wechat"];
                 const client = createWorkPhoneClient({
-                    baseUrl: params.account.baseUrl,
-                    apiKey: params.account.apiKey,
-                    accountId: params.account.accountId || undefined,
-                    wechatAccountId: params.account.wechatAccountId,
+                    baseUrl: section?.baseUrl || "https://api.workphone.example.com",
+                    apiKey: section?.apiKey,
+                    accountId: section?.accountId || undefined,
+                    wechatAccountId: section?.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'));
+                const isChatroom = params.to?.includes("@chatroom");
                 let result;
                 if (isChatroom) {
-                    // Send to chatroom (group)
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: section?.wechatAccountId,
                         chatroomId: params.to,
                         content: params.text,
-                        type: 'text',
+                        type: "text",
                     });
                 }
                 else {
                     // Send to friend (DM)
                     result = await client.sendFriendMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: section?.wechatAccountId,
                         friendWechatId: params.to,
                         content: params.text,
-                        type: 'text',
+                        type: "text",
                     });
                 }
                 return { messageId: result.messageId };
             },
             // Send media - also support both DM and group
             sendMedia: async (params) => {
+                const cfg = params.cfg;
+                const section = cfg.channels?.["celphone-wechat"];
                 const client = createWorkPhoneClient({
-                    baseUrl: params.account.baseUrl,
-                    apiKey: params.account.apiKey,
-                    accountId: params.account.accountId || undefined,
-                    wechatAccountId: params.account.wechatAccountId,
+                    baseUrl: section?.baseUrl || "https://api.workphone.example.com",
+                    apiKey: section?.apiKey,
+                    accountId: section?.accountId || undefined,
+                    wechatAccountId: section?.wechatAccountId,
                 });
-                const isChatroom = params.metadata?.conversationType === 'group' ||
-                    (params.to && params.to.includes('@chatroom'));
+                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 {
+                            // Need to find the file path from the message
+                            // In practice, we'd need to look at the attachment info
+                            filePath = root;
+                            break;
+                        }
+                        catch {
+                            // Try next root
+                        }
+                    }
+                }
                 let result;
                 if (isChatroom) {
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: section?.wechatAccountId,
                         chatroomId: params.to,
-                        content: params.filePath || '',
-                        type: 'file',
+                        content: filePath,
+                        type: "file",
                     });
                 }
                 else {
                     result = await client.sendFriendMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: section?.wechatAccountId,
                         friendWechatId: params.to,
-                        content: params.filePath || '',
-                        type: 'file',
+                        content: 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
@@ -225,7 +221,7 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
         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
+        supportsDeleting: false,
     },
 });
 /**
@@ -241,31 +237,33 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
  */
 export async function handleInboundMessage(api, payload, cfg) {
     const { event, accountId, wechatAccountId, message, friendRequest } = payload;
-    if (event === 'message' && message) {
+    if (event === "message" && message) {
         // Determine conversation type
         const isChatroom = !!message.chatroomId;
         const conversationId = isChatroom
             ? message.chatroomId
-            : message.fromUser || message.toUser || '';
+            : message.fromUser || message.toUser || "";
         // Convert to cache format and store locally
-        if (cacheManager && accountId) {
+        if (cfg) {
             try {
-                await cacheManager.onMessage({
+                const cache = getCacheManager(cfg);
+                const wechatMessage = {
                     messageId: message.messageId,
                     msgSvrId: message.msgSvrId,
-                    accountId: accountId,
-                    conversationType: isChatroom ? 'chatroom' : 'friend',
+                    accountId: accountId || "default",
+                    conversationType: isChatroom ? "chatroom" : "friend",
                     conversationId,
-                    senderId: message.fromUser || '',
+                    senderId: message.fromUser || "",
                     content: message.content,
                     messageType: message.type || 1,
                     timestamp: message.timestamp || Date.now(),
                     isSelf: message.isSelf || false,
-                    direction: message.isSelf ? 'outbound' : 'inbound',
-                });
+                    direction: message.isSelf ? "outbound" : "inbound",
+                };
+                await cache.onMessage(wechatMessage);
             }
             catch (err) {
-                console.error('[CelPhoneWeChat] Cache write failed:', err);
+                console.error("[CelPhoneWeChat] Cache write failed:", err);
             }
         }
         // Convert WorkPhone message format to OpenClaw format
@@ -273,16 +271,16 @@ export async function handleInboundMessage(api, payload, cfg) {
             id: message.messageId,
             rawId: message.msgSvrId || message.messageId,
             conversation: {
-                type: isChatroom ? 'group' : 'dm',
+                type: isChatroom ? "group" : "dm",
                 id: conversationId,
                 chatroomId: isChatroom ? conversationId : undefined,
             },
             sender: {
-                id: message.fromUser || '',
+                id: message.fromUser || "",
                 platformId: message.wechatId,
             },
             content: {
-                type: message.type === 1 ? 'text' : 'media',
+                type: message.type === 1 ? "text" : "media",
                 text: message.content,
             },
             timestamp: new Date(message.timestamp || Date.now()),
@@ -291,7 +289,7 @@ export async function handleInboundMessage(api, payload, cfg) {
         // Dispatch to OpenClaw
         await api.inbound.dispatchMessage(openclawMessage);
     }
-    else if (event === 'friend_request' && friendRequest) {
+    else if (event === "friend_request" && friendRequest) {
         // Handle friend request
         await api.inbound.dispatchFriendRequest({
             id: friendRequest.v1,

package/index.ts

@@ -44,7 +44,7 @@ export default defineChannelPluginEntry({
         try {
           // Parse the webhook payload
           // The exact format depends on WorkPhone's webhook configuration
-          const payload = req.body;
+          const payload = (req as any).body;
 
           // Verify the request is from WorkPhone
           // Add signature verification here if needed
@@ -71,17 +71,19 @@ export default defineChannelPluginEntry({
     });
 
     // Register gateway method for outbound media handling
-    api.registerGatewayMethod({
-      method: "POST",
+    api.registerHttpRoute({
       path: "/celphone-wechat/media",
+      auth: "plugin",
       handler: async (req, res) => {
-        const { messageId, mediaUrl, mediaType } = req.body;
+        const payload = (req as any).body;
+        const { messageId, mediaUrl, mediaType } = payload || {};
 
         // Handle media upload/send through WorkPhone
         // This is called when the bot needs to send media files
 
+        res.setHeader("Content-Type", "application/json");
         res.statusCode = 200;
-        res.json({ success: true, messageId });
+        res.end(JSON.stringify({ success: true, messageId }));
         return true;
       },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gloablehive/celphone-wechat-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "OpenClaw channel plugin for workphone-wechat API - enables sending/receiving WeChat messages through workphone",
   "main": "index.ts",
@@ -24,7 +24,7 @@
     }
   },
   "dependencies": {
-    "@gloablehive/wechat-cache": "^1.0.0",
+    "@gloablehive/wechat-cache": "^1.0.1",
     "openclaw": ">=1.0.0"
   },
   "devDependencies": {

package/src/channel.ts

@@ -31,6 +31,7 @@ import {
   createCacheManager,
   CacheManager,
   WeChatAccount,
+  WeChatMessage,
 } from "@gloablehive/wechat-cache";
 
 // Cache manager instance (lazy initialized)
@@ -48,16 +49,16 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
   // If no accounts configured, create default from main config
   if (accounts.length === 0 && section?.wechatAccountId) {
     accounts.push({
-      accountId: section.accountId || 'default',
+      accountId: section.accountId || "default",
       wechatAccountId: section.wechatAccountId,
       wechatId: section.wechatId || section.wechatAccountId,
-      nickName: section.nickName || 'WeChat User',
+      nickName: section.nickName || "WeChat User",
       enabled: true,
     });
   }
 
   const basePath = (globalThis as any)?.process?.env?.OPENCLAW_CACHE_PATH
-    || '~/.openclaw/channels/celphone-wechat';
+    || "~/.openclaw/channels/celphone-wechat";
 
   cacheManager = createCacheManager({
     basePath,
@@ -69,14 +70,14 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
     } : undefined,
     syncConfig: section?.sync ? {
       databaseUrl: section.sync.databaseUrl,
-      syncMode: section.sync.syncMode || 'interval',
+      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);
+    console.error("[CelPhoneWeChat] Cache manager init failed:", err);
   });
 
   return cacheManager;
@@ -86,9 +87,9 @@ 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
+  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;
 }
@@ -121,8 +122,8 @@ function resolveAccount(
     apiKey,
     baseUrl,
     wechatAccountId,
-    wechatId: section?.wechatId || wechatAccountId,  // Actual WeChat ID (wxid_xxx)
-    nickName: section?.nickName || "WeChat User",     // Display name
+    wechatId: section?.wechatId || wechatAccountId, // Actual WeChat ID (wxid_xxx)
+    nickName: section?.nickName || "WeChat User", // Display name
     allowFrom: section?.allowFrom ?? [],
     dmPolicy: section?.dmSecurity,
   };
@@ -135,79 +136,58 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
   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",
-        };
+      resolveAccountId: (params: any) => {
+        return resolveAccount(params.cfg, params.accountId)?.accountId || "";
       },
+      applyAccountConfig: (params) => params.cfg,
     },
-  }),
+  }) as any,
 
-  // 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
+      defaultPolicy: "allowlist",
     },
   },
 
-  // 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
+    topLevelReplyToMode: "reply",
   },
 
-  // 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: {
+    channel: "celphone-wechat",
     attachedResults: {
-      // Send text - detect if DM or group based on conversation metadata
-      sendText: async (params) => {
+      channel: "celphone-wechat",
+      sendText: async (params: any) => {
+        const cfg = params.cfg;
+        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+
         const client = createWorkPhoneClient({
-          baseUrl: params.account.baseUrl,
-          apiKey: params.account.apiKey,
-          accountId: params.account.accountId || undefined,
-          wechatAccountId: params.account.wechatAccountId,
+          baseUrl: section?.baseUrl || "https://api.workphone.example.com",
+          apiKey: section?.apiKey,
+          accountId: section?.accountId || undefined,
+          wechatAccountId: section?.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'));
+        const isChatroom = params.to?.includes("@chatroom");
 
         let result;
         if (isChatroom) {
-          // Send to chatroom (group)
           result = await client.sendChatroomMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: section?.wechatAccountId,
             chatroomId: params.to,
             content: params.text,
-            type: 'text',
+            type: "text",
           });
         } else {
           // Send to friend (DM)
           result = await client.sendFriendMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: section?.wechatAccountId,
             friendWechatId: params.to,
             content: params.text,
-            type: 'text',
+            type: "text",
           });
         }
 
@@ -215,43 +195,59 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
       },
 
       // Send media - also support both DM and group
-      sendMedia: async (params) => {
+      sendMedia: async (params: any) => {
+        const cfg = params.cfg;
+        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+
         const client = createWorkPhoneClient({
-          baseUrl: params.account.baseUrl,
-          apiKey: params.account.apiKey,
-          accountId: params.account.accountId || undefined,
-          wechatAccountId: params.account.wechatAccountId,
+          baseUrl: section?.baseUrl || "https://api.workphone.example.com",
+          apiKey: section?.apiKey,
+          accountId: section?.accountId || undefined,
+          wechatAccountId: section?.wechatAccountId,
         });
 
-        const isChatroom = params.metadata?.conversationType === 'group' ||
-                          (params.to && params.to.includes('@chatroom'));
+        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 {
+              // Need to find the file path from the message
+              // In practice, we'd need to look at the attachment info
+              filePath = root;
+              break;
+            } catch {
+              // Try next root
+            }
+          }
+        }
 
         let result;
         if (isChatroom) {
           result = await client.sendChatroomMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: section?.wechatAccountId,
             chatroomId: params.to,
-            content: params.filePath || '',
-            type: 'file',
+            content: filePath,
+            type: "file",
           });
         } else {
           result = await client.sendFriendMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: section?.wechatAccountId,
             friendWechatId: params.to,
-            content: params.filePath || '',
-            type: 'file',
+            content: 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
-  },
+  } as any,
 
   // Additional capabilities
   // - Describe the channel's message types and features
@@ -270,11 +266,11 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
     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
+    supportsThreads: true, // Can reply in chat
+    supportsEditing: false, // Cannot edit sent messages
+    supportsDeleting: false,
   },
-});
+} as any);
 
 /**
  * Helper function to handle inbound webhook messages
@@ -294,31 +290,33 @@ export async function handleInboundMessage(
 ): Promise<void> {
   const { event, accountId, wechatAccountId, message, friendRequest } = payload;
 
-  if (event === 'message' && message) {
+  if (event === "message" && message) {
     // Determine conversation type
     const isChatroom = !!(message as any).chatroomId;
     const conversationId = isChatroom
       ? (message as any).chatroomId
-      : message.fromUser || message.toUser || '';
+      : message.fromUser || message.toUser || "";
 
     // Convert to cache format and store locally
-    if (cacheManager && accountId) {
+    if (cfg) {
       try {
-        await cacheManager.onMessage({
+        const cache = getCacheManager(cfg);
+        const wechatMessage: WeChatMessage = {
           messageId: message.messageId,
           msgSvrId: message.msgSvrId,
-          accountId: accountId,
-          conversationType: isChatroom ? 'chatroom' : 'friend',
+          accountId: accountId || "default",
+          conversationType: isChatroom ? "chatroom" : "friend",
           conversationId,
-          senderId: message.fromUser || '',
+          senderId: message.fromUser || "",
           content: message.content,
           messageType: message.type || 1,
           timestamp: message.timestamp || Date.now(),
           isSelf: message.isSelf || false,
-          direction: message.isSelf ? 'outbound' : 'inbound',
-        });
+          direction: message.isSelf ? "outbound" : "inbound",
+        };
+        await cache.onMessage(wechatMessage);
       } catch (err) {
-        console.error('[CelPhoneWeChat] Cache write failed:', err);
+        console.error("[CelPhoneWeChat] Cache write failed:", err);
       }
     }
 
@@ -327,16 +325,16 @@ export async function handleInboundMessage(
       id: message.messageId,
       rawId: message.msgSvrId || message.messageId,
       conversation: {
-        type: isChatroom ? 'group' as const : 'dm' as const,
+        type: isChatroom ? "group" as const : "dm" as const,
         id: conversationId,
         chatroomId: isChatroom ? conversationId : undefined,
       },
       sender: {
-        id: message.fromUser || '',
+        id: message.fromUser || "",
         platformId: message.wechatId,
       },
       content: {
-        type: message.type === 1 ? 'text' : 'media',
+        type: message.type === 1 ? "text" as const : "media" as const,
         text: message.content,
       },
       timestamp: new Date(message.timestamp || Date.now()),
@@ -345,7 +343,7 @@ export async function handleInboundMessage(
 
     // Dispatch to OpenClaw
     await api.inbound.dispatchMessage(openclawMessage);
-  } else if (event === 'friend_request' && friendRequest) {
+  } else if (event === "friend_request" && friendRequest) {
     // Handle friend request
     await api.inbound.dispatchFriendRequest({
       id: friendRequest.v1,

package/src/client.ts

@@ -107,7 +107,7 @@ export class WorkPhoneWeChatClient {
       throw new Error(`WorkPhone API error: ${response.status} - ${error}`);
     }
 
-    return response.json();
+    return response.json() as Promise<T>;
   }
 
   // ========== WeChat Account Operations ==========

package/test-cache.ts

@@ -10,7 +10,7 @@ import {
   CacheManager,
   WeChatAccount,
   WeChatMessage,
-} from './src/cache/index.js';
+} from "@gloablehive/wechat-cache";
 
 const TEST_CACHE_PATH = '/tmp/wechat-cache-test';
 const ENCODING = 'utf-8';