@gloablehive/celphone-wechat-plugin 1.0.0

package/dist/mock-server.js

@@ -0,0 +1,203 @@
+/**
+ * Mock WorkPhone API Server for Testing
+ *
+ * 模拟 WorkPhone 的 API 端点，用于本地测试
+ */
+import express from 'express';
+import { createServer } from 'http';
+const app = express();
+app.use(express.json());
+// 配置
+const MOCK_CONFIG = {
+    apiKey: 'test-api-key-12345',
+    wechatAccountId: 'mock-wechat-001',
+    wechatId: 'wxid_mock001',
+    baseUrl: 'http://localhost:18999',
+};
+// 存储消息
+const messages = [];
+const friends = [
+    { wechatId: 'wxid_customer001', remark: '客户A', nickname: '张三' },
+    { wechatId: 'wxid_customer002', remark: '客户B', nickname: '李四' },
+    { wechatId: 'wxid_customer003', remark: '潜在客户', nickname: '王五' },
+];
+// ============ API 端点 ============
+// 健康检查
+app.get('/health', (req, res) => {
+    res.json({ status: 'ok' });
+});
+// 获取账号列表
+app.get('/api/v1/wechat/accounts', (req, res) => {
+    const auth = req.headers.authorization;
+    if (auth !== `Bearer ${MOCK_CONFIG.apiKey}`) {
+        return res.status(401).json({ error: 'unauthorized' });
+    }
+    res.json({
+        data: [
+            {
+                accountId: MOCK_CONFIG.wechatAccountId,
+                wechatId: MOCK_CONFIG.wechatId,
+                nickname: '测试客服',
+                status: 'online',
+            }
+        ]
+    });
+});
+// 获取好友列表
+app.get(`/api/v1/wechat/accounts/${MOCK_CONFIG.wechatAccountId}/friends`, (req, res) => {
+    const auth = req.headers.authorization;
+    if (auth !== `Bearer ${MOCK_CONFIG.apiKey}`) {
+        return res.status(401).json({ error: 'unauthorized' });
+    }
+    res.json({ data: friends });
+});
+// 发送好友消息
+app.post(`/api/v1/wechat/accounts/${MOCK_CONFIG.wechatAccountId}/messages/friend`, (req, res) => {
+    const auth = req.headers.authorization;
+    if (auth !== `Bearer ${MOCK_CONFIG.apiKey}`) {
+        return res.status(401).json({ error: 'unauthorized' });
+    }
+    const { friendWechatId, content, type } = req.body;
+    console.log(`[Mock] 发送消息给 ${friendWechatId}: ${content}`);
+    const messageId = `msg_${Date.now()}`;
+    messages.push({
+        messageId,
+        friendWechatId,
+        content,
+        type,
+        timestamp: Date.now(),
+        direction: 'outbound',
+    });
+    res.json({
+        code: 0,
+        message: 'success',
+        data: {
+            messageId,
+            msgSvrId: `svr_${Date.now()}`,
+        }
+    });
+});
+// 发送群消息
+app.post(`/api/v1/wechat/accounts/${MOCK_CONFIG.wechatAccountId}/messages/chatroom`, (req, res) => {
+    const auth = req.headers.authorization;
+    if (auth !== `Bearer ${MOCK_CONFIG.apiKey}`) {
+        return res.status(401).json({ error: 'unauthorized' });
+    }
+    const { chatroomId, content, type, atUsers } = req.body;
+    console.log(`[Mock] 发送消息到群 ${chatroomId}: ${content}`);
+    const messageId = `msg_${Date.now()}`;
+    messages.push({
+        messageId,
+        chatroomId,
+        content,
+        type,
+        atUsers,
+        timestamp: Date.now(),
+        direction: 'outbound',
+    });
+    res.json({
+        code: 0,
+        message: 'success',
+        data: {
+            messageId,
+            msgSvrId: `svr_${Date.now()}`,
+        }
+    });
+});
+// Webhook 配置（返回当前 webhook 地址）
+app.get(`/api/v1/wechat/accounts/${MOCK_CONFIG.wechatAccountId}/webhook`, (req, res) => {
+    res.json({
+        data: {
+            url: 'http://localhost:18999/webhook',
+            enabled: true,
+        }
+    });
+});
+// 设置 webhook
+app.put(`/api/v1/wechat/accounts/${MOCK_CONFIG.wechatAccountId}/webhook`, (req, res) => {
+    const { url } = req.body;
+    console.log(`[Mock] Webhook 设置为: ${url}`);
+    res.json({ code: 0, message: 'success' });
+});
+// ============ Webhook 模拟触发 ============
+// 模拟收到好友消息
+app.post('/mock/trigger/friend-message', (req, res) => {
+    const { wechatId, content } = req.body;
+    const payload = {
+        event: 'message',
+        accountId: MOCK_CONFIG.wechatAccountId,
+        wechatAccountId: MOCK_CONFIG.wechatAccountId,
+        message: {
+            messageId: `in_msg_${Date.now()}`,
+            msgSvrId: `svr_${Date.now()}`,
+            fromUser: wechatId || 'wxid_customer001',
+            toUser: MOCK_CONFIG.wechatId,
+            content: content || '你好，这是测试消息',
+            type: 1,
+            timestamp: Date.now(),
+            isSelf: false,
+        }
+    };
+    // 回调（如果配置了 webhook）
+    // 实际使用时会让用户配置真实的 webhook URL
+    res.json({
+        code: 0,
+        message: 'triggered',
+        payload
+    });
+});
+// 模拟收到群消息
+app.post('/mock/trigger/chatroom-message', (req, res) => {
+    const { chatroomId, content } = req.body;
+    const payload = {
+        event: 'message',
+        accountId: MOCK_CONFIG.wechatAccountId,
+        wechatAccountId: MOCK_CONFIG.wechatAccountId,
+        message: {
+            messageId: `in_msg_${Date.now()}`,
+            msgSvrId: `svr_${Date.now()}`,
+            fromUser: 'wxid_customer001',
+            chatroomId: chatroomId || '123456789@chatroom',
+            content: content || '大家好',
+            type: 1,
+            timestamp: Date.now(),
+            isSelf: false,
+        }
+    };
+    res.json({
+        code: 0,
+        message: 'triggered',
+        payload
+    });
+});
+// 获取消息历史
+app.get('/mock/messages', (req, res) => {
+    res.json({ data: messages });
+});
+// 启动服务器
+const PORT = 18999;
+const server = createServer(app);
+server.listen(PORT, () => {
+    console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║           Mock WorkPhone API Server                        ║
+╠═══════════════════════════════════════════════════════════╣
+║  Base URL: http://localhost:${PORT}                          ║
+║  API Key:  ${MOCK_CONFIG.apiKey}                          ║
+║  WeChat Account: ${MOCK_CONFIG.wechatAccountId}                         ║
+╠═══════════════════════════════════════════════════════════╣
+║  测试端点:                                                 ║
+║  - POST /mock/trigger/friend-message  模拟好友消息          ║
+║  - POST /mock/trigger/chatroom-message 模拟群消息          ║
+║  - GET /mock/messages 查看消息历史                        ║
+╚═══════════════════════════════════════════════════════════╝
+  `);
+});
+// 优雅关闭
+process.on('SIGINT', () => {
+    console.log('\n[Mock] 关闭服务器...');
+    server.close(() => {
+        console.log('[Mock] 服务器已关闭');
+        process.exit(0);
+    });
+});

package/dist/openclaw.plugin.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "https://openclaw.ai/schema/plugin.json",
+  "id": "celphone-wechat",
+  "name": "WorkPhone WeChat",
+  "version": "1.0.0",
+  "description": "Connect OpenClaw to WorkPhone WeChat API for sending and receiving WeChat messages",
+  "author": {
+    "name": "GolaBeHive",
+    "url": "https://github.com/golabehive"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/golabehive/channels/celphone-wechat-plugin"
+  },
+  "keywords": ["openclaw", "channel", "wechat", "workphone", "messaging"],
+  "license": "MIT",
+  "type": "channel",
+  "capabilities": {
+    "inbound": {
+      "message": true,
+      "friend_request": true,
+      "group_invite": false
+    },
+    "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": "WorkPhone API key for authentication",
+        "secret": true
+      },
+      "baseUrl": {
+        "type": "string",
+        "description": "WorkPhone API base URL",
+        "default": "https://api.workphone.example.com"
+      },
+      "accountId": {
+        "type": "string",
+        "description": "WorkPhone account ID"
+      },
+      "wechatAccountId": {
+        "type": "string",
+        "description": "WeChat account ID to use (from WorkPhone) - REQUIRED"
+      },
+      "wechatId": {
+        "type": "string",
+        "description": "The actual WeChat ID (wxid_xxx) for this account"
+      },
+      "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"
+      },
+      "webhookSecret": {
+        "type": "string",
+        "description": "Secret for verifying webhook requests",
+        "secret": true
+      }
+    },
+    "required": ["apiKey", "wechatAccountId"]
+  },
+  "permissions": {
+    "channels": ["celphone-wechat"],
+    "http": {
+      "outbound": ["*"],
+      "inbound": ["/celphone-wechat/webhook"]
+    }
+  },
+  "apiVersion": "1.0.0"
+}

package/dist/setup-entry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Setup Entry Point
+ *
+ * Lightweight entry for loading during onboarding/config when channel is disabled
+ */
+declare const _default: {
+    plugin: import("openclaw/plugin-sdk/core").ChannelPlugin<import("./src/channel.js").CelPhoneWeChatResolvedAccount, unknown, unknown>;
+};
+export default _default;

package/dist/setup-entry.js

@@ -0,0 +1,8 @@
+/**
+ * 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/dist/src/cache/compactor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Compactor - 4-layer compression system
+ *
+ * Aligned with Claude Code compression:
+ * - Layer 1: Microcompact (clean old tool results)
+ * - Layer 2: Auto-compact (context threshold)
+ * - Layer 3: Full compact (Fork Agent summary)
+ * - Layer 4: Session compact (use session.md)
+ */
+import type { CompactConfig } from './types.js';
+import { DEFAULT_COMPACT_CONFIG } from './types.js';
+/**
+ * Layer 1: Microcompact - clean old messages, keep recent N intact
+ */
+export declare function microCompact(filePath: string, keepCount?: number): Promise<boolean>;
+/**
+ * Layer 2: Auto-compact - check if context threshold exceeded
+ */
+export declare function shouldAutoCompact(config: CompactConfig, tokenEstimate: number): boolean;
+/**
+ * Layer 3: Full compact - generate summary via LLM
+ */
+export declare function fullCompact(conversationPath: string, summary: string): Promise<boolean>;
+/**
+ * Layer 4: Session compact - use session.md as summary
+ */
+export declare function getSessionSummary(sessionPath: string): string | null;
+/**
+ * Determine which compaction layer to use
+ */
+export declare function runCompaction(config: CompactConfig, conversationPath: string, tokenEstimate: number, sessionPath?: string): Promise<'none' | 'micro' | 'auto' | 'full' | 'session'>;
+/**
+ * Get token estimate for conversation
+ */
+export declare function estimateConversationTokens(conversationPath: string): Promise<number>;
+export { CompactConfig, DEFAULT_COMPACT_CONFIG };

package/dist/src/cache/compactor.js

@@ -0,0 +1,154 @@
+/**
+ * Compactor - 4-layer compression system
+ *
+ * Aligned with Claude Code compression:
+ * - Layer 1: Microcompact (clean old tool results)
+ * - Layer 2: Auto-compact (context threshold)
+ * - Layer 3: Full compact (Fork Agent summary)
+ * - Layer 4: Session compact (use session.md)
+ */
+import { DEFAULT_COMPACT_CONFIG, } from './types.js';
+import * as fs from 'fs/promises';
+const ENCODING = 'utf-8';
+const CONTENT_CLEARED = '[Old content cleared]';
+/**
+ * Layer 1: Microcompact - clean old messages, keep recent N intact
+ */
+export async function microCompact(filePath, keepCount = 10) {
+    try {
+        const content = await fs.readFile(filePath, ENCODING);
+        const lines = content.split('\n');
+        // Find message blocks (lines starting with **[timestamp])
+        const messageLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].match(/^\*\*\[/)) {
+                messageLines.push(i);
+            }
+        }
+        if (messageLines.length <= keepCount) {
+            return false; // Nothing to compact
+        }
+        // Clear old messages
+        const toKeep = messageLines.slice(-keepCount);
+        const toClear = messageLines.slice(0, -keepCount);
+        let newContent = lines.slice();
+        for (const idx of toClear) {
+            // Find the end of this message block
+            let endIdx = idx + 1;
+            while (endIdx < lines.length && lines[endIdx].trim() !== '' && !lines[endIdx].match(/^\*\*\[/)) {
+                endIdx++;
+            }
+            // Replace with cleared marker
+            newContent[idx] = CONTENT_CLEARED;
+            for (let i = idx + 1; i < endIdx; i++) {
+                newContent[i] = '';
+            }
+        }
+        await fs.writeFile(filePath, newContent.filter(l => l !== '').join('\n'), ENCODING);
+        return true;
+    }
+    catch (error) {
+        console.error('[Compactor] Microcompact failed:', error);
+        return false;
+    }
+}
+/**
+ * Layer 2: Auto-compact - check if context threshold exceeded
+ */
+export function shouldAutoCompact(config, tokenEstimate) {
+    return tokenEstimate >= config.autoCompactThreshold;
+}
+/**
+ * Layer 3: Full compact - generate summary via LLM
+ */
+export async function fullCompact(conversationPath, summary) {
+    try {
+        const compactedPath = conversationPath.replace('.md', '.compacted.md');
+        // Read existing content
+        const content = await fs.readFile(conversationPath, ENCODING);
+        // Write compacted version with summary
+        const compactedContent = `---
+name: 压缩后的对话
+description: 已压缩的对话记录
+type: conversation
+compacted: true
+---
+
+# 对话摘要
+
+${summary}
+
+---
+
+# 原始记录（已压缩）
+
+${content.slice(0, 5000)}... (see original file for full content)
+`;
+        await fs.writeFile(compactedPath, compactedContent, ENCODING);
+        return true;
+    }
+    catch (error) {
+        console.error('[Compactor] Full compact failed:', error);
+        return false;
+    }
+}
+/**
+ * Layer 4: Session compact - use session.md as summary
+ */
+export function getSessionSummary(sessionPath) {
+    // Would read session.md and extract key information
+    // This is the fastest - no LLM needed
+    try {
+        const content = require('fs').readFileSync(sessionPath, ENCODING);
+        // Extract key sections
+        const learnings = extractSection(content, '## Learnings');
+        const keyResults = extractSection(content, '## Key results');
+        const currentState = extractSection(content, '## Current State');
+        return [currentState, learnings, keyResults].filter(Boolean).join('\n\n');
+    }
+    catch {
+        return null;
+    }
+}
+function extractSection(content, section) {
+    const regex = new RegExp(`${section}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const match = content.match(regex);
+    return match ? match[1].trim() : null;
+}
+/**
+ * Determine which compaction layer to use
+ */
+export async function runCompaction(config, conversationPath, tokenEstimate, sessionPath) {
+    // Layer 4: Session compact (fastest, preferred)
+    if (sessionPath && tokenEstimate >= config.sessionCompactThreshold) {
+        const sessionSummary = getSessionSummary(sessionPath);
+        if (sessionSummary) {
+            return 'session';
+        }
+    }
+    // Layer 3: Full compact
+    if (tokenEstimate >= config.fullCompactThreshold) {
+        return 'full';
+    }
+    // Layer 2: Auto compact
+    if (tokenEstimate >= config.autoCompactThreshold) {
+        return 'auto';
+    }
+    // Layer 1: Micro compact
+    const result = await microCompact(conversationPath, config.microCompactKeep);
+    return result ? 'micro' : 'none';
+}
+/**
+ * Get token estimate for conversation
+ */
+export async function estimateConversationTokens(conversationPath) {
+    try {
+        const content = await fs.readFile(conversationPath, ENCODING);
+        // Rough estimate: 4 characters per token
+        return Math.ceil(content.length / 4);
+    }
+    catch {
+        return 0;
+    }
+}
+export { DEFAULT_COMPACT_CONFIG };

package/dist/src/cache/extractor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AI Summary Extractor - Extract memories from conversations
+ *
+ * Aligned with Claude Code extractMemories:
+ * - Fork Agent execution
+ * - Tool permission whitelist
+ * - Trigger on conversation milestones
+ */
+import { ExtractionResult, WeChatMessage, ConversationSubtype } from './types.js';
+export interface ExtractorConfig {
+    enabled: boolean;
+    triggerAfterMessages: number;
+    triggerAfterTokens: number;
+    maxTurns: number;
+}
+/**
+ * Check if extraction should be triggered
+ */
+export declare function shouldExtract(config: ExtractorConfig, messageCount: number, tokenEstimate: number): boolean;
+/**
+ * Build extraction prompt for AI
+ */
+export declare function buildExtractionPrompt(conversationId: string, messages: WeChatMessage[], subtype: ConversationSubtype): string;
+/**
+ * Parse extraction result from AI response
+ */
+export declare function parseExtractionResult(response: string): ExtractionResult | null;
+/**
+ * Simulate extraction (placeholder for actual LLM call)
+ * In real implementation, this would call the LLM via Fork Agent
+ */
+export declare function extractWithLLM(prompt: string, apiKey?: string): Promise<ExtractionResult | null>;
+/**
+ * Validate tool is allowed (aligned with Claude Code)
+ */
+export declare function isToolAllowed(toolName: string): boolean;
+/**
+ * Validate bash command is allowed (read-only)
+ */
+export declare function isBashCommandAllowed(command: string): boolean;
+/**
+ * Get extraction trigger status
+ */
+export declare function getExtractionStatus(config: ExtractorConfig, lastExtractionMessageCount: number, currentMessageCount: number): {
+    shouldExtract: boolean;
+    messagesSinceLastExtraction: number;
+};
+export declare const DEFAULT_EXTRACTOR_CONFIG: ExtractorConfig;

package/dist/src/cache/extractor.js

@@ -0,0 +1,120 @@
+/**
+ * AI Summary Extractor - Extract memories from conversations
+ *
+ * Aligned with Claude Code extractMemories:
+ * - Fork Agent execution
+ * - Tool permission whitelist
+ * - Trigger on conversation milestones
+ */
+// ========== Constants ==========
+const ALLOWED_TOOLS = ['Read', 'Grep', 'Glob', 'Edit', 'Write'];
+const ALLOWED_BASH_COMMANDS = ['ls', 'find', 'grep', 'cat', 'stat', 'wc', 'head', 'tail'];
+/**
+ * Check if extraction should be triggered
+ */
+export function shouldExtract(config, messageCount, tokenEstimate) {
+    if (!config.enabled)
+        return false;
+    return (messageCount >= config.triggerAfterMessages ||
+        tokenEstimate >= config.triggerAfterTokens);
+}
+/**
+ * Build extraction prompt for AI
+ */
+export function buildExtractionPrompt(conversationId, messages, subtype) {
+    const messageList = messages
+        .slice(-20) // Last 20 messages
+        .map(m => {
+        const sender = m.isSelf ? '我' : (subtype === 'friend' ? '对方' : '群成员');
+        return `[${new Date(m.timestamp).toLocaleString()}] ${sender}: ${m.content}`;
+    })
+        .join('\n');
+    return `## 任务
+
+分析以下与 ${conversationId} 的对话，提取关键信息并生成摘要。
+
+## 对话内容
+
+${messageList}
+
+## 输出要求
+
+请返回以下格式的 JSON：
+
+{
+  "summary": "对话摘要 (2-3句话)",
+  "keyPoints": ["关键点1", "关键点2", "关键点3"],
+  "userProfileUpdate": {
+    "tags": ["如果发现新标签"],
+    "preferenceHints": "用户偏好提示",
+    "riskFlags": ["如果发现风险标记"]
+  },
+  "learnings": "从对话中学到的信息",
+  "actionItems": ["待跟进事项1", "待跟进事项2"]
+}
+
+只返回 JSON，不要其他内容。`;
+}
+/**
+ * Parse extraction result from AI response
+ */
+export function parseExtractionResult(response) {
+    try {
+        // Try to extract JSON from response
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return null;
+        const result = JSON.parse(jsonMatch[0]);
+        return {
+            summary: result.summary || '',
+            keyPoints: result.keyPoints || [],
+            userProfileUpdate: result.userProfileUpdate || {},
+            learnings: result.learnings || '',
+            actionItems: result.actionItems || [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Simulate extraction (placeholder for actual LLM call)
+ * In real implementation, this would call the LLM via Fork Agent
+ */
+export async function extractWithLLM(prompt, apiKey) {
+    // Placeholder: In real implementation, this would:
+    // 1. Create Fork Agent with limited tools
+    // 2. Run with the prompt
+    // 3. Parse result
+    console.log('[Extractor] Would run extraction with prompt:', prompt.substring(0, 100) + '...');
+    // Return null for now - real implementation would call LLM
+    return null;
+}
+/**
+ * Validate tool is allowed (aligned with Claude Code)
+ */
+export function isToolAllowed(toolName) {
+    return ALLOWED_TOOLS.includes(toolName);
+}
+/**
+ * Validate bash command is allowed (read-only)
+ */
+export function isBashCommandAllowed(command) {
+    const cmd = command.split(' ')[0];
+    return ALLOWED_BASH_COMMANDS.includes(cmd);
+}
+/**
+ * Get extraction trigger status
+ */
+export function getExtractionStatus(config, lastExtractionMessageCount, currentMessageCount) {
+    const messagesSinceLastExtraction = currentMessageCount - lastExtractionMessageCount;
+    const shouldExtract = shouldExtract(config, messagesSinceLastExtraction, 0 // Would calculate token estimate
+    );
+    return { shouldExtract, messagesSinceLastExtraction };
+}
+export const DEFAULT_EXTRACTOR_CONFIG = {
+    enabled: true,
+    triggerAfterMessages: 10,
+    triggerAfterTokens: 5000,
+    maxTurns: 5,
+};

package/dist/src/cache/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cache Module Exports
+ *
+ * All cache-related modules for WeChat Channel Plugin
+ */
+export * from './types.js';
+export * from './writer.js';
+export * from './indexer.js';
+export * from './extractor.js';
+export * from './compactor.js';
+export * from './syncer.js';
+export * from './saas-connector.js';
+export * from './message-queue.js';
+export * from './manager.js';
+export { createCacheManager, CacheManager } from './manager.js';