openclaw-vchat-plugin 0.0.1

package/src/group-manager.ts

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+
+/**
+ * 虚拟群数据模型
+ */
+export interface VirtualGroup {
+    id: string;
+    name: string;
+    emoji: string;
+    mode: 'broadcast' | 'mention';  // 广播 = 所有 Agent 回复 | 点名 = @指定 Agent
+    agentIds: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+
+/**
+ * 虚拟群管理器 — 本地 JSON 持久化
+ */
+export class GroupManager {
+    private groups: VirtualGroup[] = [];
+    private dataFile: string;
+
+    constructor(dataDir: string) {
+        this.dataFile = path.join(dataDir, 'groups.json');
+        this.load();
+    }
+
+    // ===== CRUD =====
+
+    list(): VirtualGroup[] {
+        return this.groups;
+    }
+
+    get(groupId: string): VirtualGroup | undefined {
+        return this.groups.find(g => g.id === groupId);
+    }
+
+    create(name: string, emoji: string = '👥', agentIds: string[] = [], mode: 'broadcast' | 'mention' = 'mention'): VirtualGroup {
+        const group: VirtualGroup = {
+            id: randomUUID().substring(0, 8),
+            name,
+            emoji,
+            mode,
+            agentIds,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.groups.push(group);
+        this.save();
+        return group;
+    }
+
+    update(groupId: string, data: Partial<Pick<VirtualGroup, 'name' | 'emoji' | 'mode'>>): VirtualGroup | null {
+        const group = this.get(groupId);
+        if (!group) return null;
+        if (data.name !== undefined) group.name = data.name;
+        if (data.emoji !== undefined) group.emoji = data.emoji;
+        if (data.mode !== undefined) group.mode = data.mode;
+        group.updatedAt = Date.now();
+        this.save();
+        return group;
+    }
+
+    delete(groupId: string): boolean {
+        const before = this.groups.length;
+        this.groups = this.groups.filter(g => g.id !== groupId);
+        if (this.groups.length < before) {
+            this.save();
+            return true;
+        }
+        return false;
+    }
+
+    // ===== Agent 绑定 =====
+
+    addAgent(groupId: string, agentId: string): VirtualGroup | null {
+        const group = this.get(groupId);
+        if (!group) return null;
+        if (!group.agentIds.includes(agentId)) {
+            group.agentIds.push(agentId);
+            group.updatedAt = Date.now();
+            this.save();
+        }
+        return group;
+    }
+
+    removeAgent(groupId: string, agentId: string): VirtualGroup | null {
+        const group = this.get(groupId);
+        if (!group) return null;
+        group.agentIds = group.agentIds.filter(id => id !== agentId);
+        group.updatedAt = Date.now();
+        this.save();
+        return group;
+    }
+
+    // ===== 持久化 =====
+
+    private load(): void {
+        try {
+            if (fs.existsSync(this.dataFile)) {
+                const raw = fs.readFileSync(this.dataFile, 'utf-8');
+                this.groups = JSON.parse(raw);
+            }
+        } catch (err) {
+            console.error('[GroupManager] 加载失败:', err);
+            this.groups = [];
+        }
+    }
+
+    private save(): void {
+        try {
+            fs.writeFileSync(this.dataFile, JSON.stringify(this.groups, null, 2), 'utf-8');
+        } catch (err) {
+            console.error('[GroupManager] 保存失败:', err);
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,443 @@
+import path from 'path';
+import fs from 'fs';
+import fetch from 'node-fetch';
+import WebSocket from 'ws';
+import { createRelayServer } from './relay-server';
+import { GatewayClient } from './gateway-client';
+import { setGatewayClient } from './commands';
+import { PluginConfig, MessageType } from './types';
+import { MessageHandler } from './message-handler';
+import { buildWeChatGatewaySessionKey, sanitizeWeChatId } from './session-key';
+
+// @ts-ignore
+import qrcode from 'qrcode-terminal';
+
+/**
+ * OpenClaw VChat Plugin 入口
+ *
+ * 启动流程：
+ * 1. 检查 ~/.openclaw/wechat-device.json 是否有 deviceKey
+ * 2. 有 → 用 deviceKey 注册 → 建立反向 WS 隧道
+ * 3. 没有 → 调 /api/devices/pair/init → 终端打印 QR 码 → 轮询配对 → 保存密钥
+ */
+
+const DATA_DIR = path.join(__dirname, '..', 'data');
+const UPLOAD_DIR = path.join(DATA_DIR, 'uploads');
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(process.env.HOME || '/root', '.openclaw');
+const DEVICE_CONFIG_PATH = path.join(OPENCLAW_HOME, 'wechat-device.json');
+const BACKEND_URL = process.env.WECHAT_BACKEND_URL || 'https://api.deck0.dev';
+
+fs.mkdirSync(UPLOAD_DIR, { recursive: true });
+fs.mkdirSync(OPENCLAW_HOME, { recursive: true });
+
+const config: PluginConfig = {
+    port: 39217,
+    openclawGatewayUrl: process.env.OPENCLAW_GATEWAY_URL || 'http://localhost:18789',
+    openclawModel: process.env.OPENCLAW_MODEL || 'nvidia/z-ai/glm5',
+    openclawAuthToken: process.env.OPENCLAW_AUTH_TOKEN || '',
+    uploadDir: UPLOAD_DIR,
+    maxFileSize: 10 * 1024 * 1024,
+    maxVoiceDuration: 60,
+    internalSecret: process.env.PLUGIN_SECRET || '',
+    allowLocalFallback: process.env.WECHAT_PLUGIN_ENABLE_LOCAL_FALLBACK === '1',
+};
+
+// ===== 设备配置读写 =====
+
+interface DeviceConfig {
+    deviceKey: string;
+    deviceToken?: string;
+    backendUrl: string;
+    pairedAt: string;
+}
+
+function readDeviceConfig(): DeviceConfig | null {
+    try {
+        return JSON.parse(fs.readFileSync(DEVICE_CONFIG_PATH, 'utf-8'));
+    } catch {
+        return null;
+    }
+}
+
+function saveDeviceConfig(cfg: DeviceConfig): void {
+    fs.writeFileSync(DEVICE_CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}
+
+// ===== 反向 WS 隧道 =====
+
+let tunnelWs: WebSocket | null = null;
+let gateway: GatewayClient;
+let relayServer: ReturnType<typeof createRelayServer> | null = null;
+let tunnelMessageHandler: MessageHandler | null = null;
+const tunnelAbortByUser = new Map<string, () => void>();
+
+function sendTunnelFrame(payload: any): void {
+    if (tunnelWs && tunnelWs.readyState === WebSocket.OPEN) {
+        tunnelWs.send(JSON.stringify(payload));
+    }
+}
+
+function normalizeSenderId(value: unknown): string {
+    const normalized = String(value || '').trim();
+    return normalized || 'unknown';
+}
+
+function ensureTunnelSession(userId: string, sessionId: string | undefined, agentId: string, groupId?: string): string {
+    if (!relayServer) throw new Error('插件尚未完成初始化');
+    const normalizedAgentId = sanitizeWeChatId(agentId, 'main');
+    const existingSessionId = String(sessionId || '').trim();
+    if (existingSessionId) {
+        return relayServer.sessionManager.ensureSessionBinding(
+            userId,
+            existingSessionId,
+            normalizedAgentId,
+            buildWeChatGatewaySessionKey(userId, existingSessionId, normalizedAgentId, groupId),
+        ).id;
+    }
+
+    const created = relayServer.sessionManager.createSession(userId, undefined, normalizedAgentId);
+    return relayServer.sessionManager.ensureSessionBinding(
+        userId,
+        created.id,
+        normalizedAgentId,
+        buildWeChatGatewaySessionKey(userId, created.id, normalizedAgentId, groupId),
+    ).id;
+}
+
+function connectTunnel(deviceToken: string): void {
+    const wsUrl = BACKEND_URL.replace(/^https:/, 'wss:').replace(/^http:/, 'ws:')
+        + `/ws/plugin?deviceToken=${encodeURIComponent(deviceToken)}`;
+
+    console.log('[隧道] 正在连接后端...');
+    tunnelWs = new WebSocket(wsUrl);
+
+    tunnelWs.on('open', () => {
+        console.log('[隧道] ✅ 已连接到后端，等待小程序消息');
+    });
+
+    tunnelWs.on('message', (data) => {
+        // 后端转发的小程序消息 → 处理并回复
+        handleClientMessage(data.toString());
+    });
+
+    tunnelWs.on('close', (code, reason) => {
+        console.log(`[隧道] 断开 (${code}): ${reason}`);
+        for (const abort of tunnelAbortByUser.values()) {
+            try { abort(); } catch { /* ignore */ }
+        }
+        tunnelAbortByUser.clear();
+        tunnelWs = null;
+        // 自动重连
+        setTimeout(() => {
+            console.log('[隧道] 尝试重连...');
+            connectTunnel(deviceToken);
+        }, 5000);
+    });
+
+    tunnelWs.on('error', (err) => {
+        console.error('[隧道] 连接错误:', err.message);
+    });
+}
+
+/**
+ * 处理小程序通过隧道发来的消息
+ */
+function handleClientMessage(raw: string): void {
+    try {
+        const msg = JSON.parse(raw);
+        const userId = normalizeSenderId(msg.userId);
+        const requestId = String(msg.requestId || '').trim();
+
+        if (msg.type === 'ping') {
+            sendTunnelFrame({ type: 'pong' });
+            return;
+        }
+
+        if (msg.type === 'chat') {
+            if (!relayServer || !tunnelMessageHandler) {
+                sendTunnelFrame({ type: 'error', message: '插件尚未完成初始化', error: '插件尚未完成初始化' });
+                return;
+            }
+
+            const content = String(msg.content || '').trim();
+            if (!content) {
+                sendTunnelFrame({ type: 'error', message: '消息内容不能为空', error: '消息内容不能为空' });
+                return;
+            }
+
+            const agentId = String(msg.agentId || 'main');
+            const sessionId = String(msg.sessionId || '').trim();
+            const groupId = msg.groupId ? String(msg.groupId) : undefined;
+            const sid = ensureTunnelSession(userId, sessionId, agentId, groupId);
+            console.log(`[BridgeTunnel] requestId=${requestId || '-'} type=chat agent=${agentId} session=${sid} user=${userId}`);
+            const mediaUrl = msg.mediaUrl ? String(msg.mediaUrl) : undefined;
+            const rawMessageType = String(msg.messageType || 'text');
+            const messageType: MessageType =
+                rawMessageType === 'voice' || rawMessageType === 'image' || rawMessageType === 'command' || rawMessageType === 'system'
+                    ? rawMessageType
+                    : 'text';
+            const routingHint = {
+                commandRoute: typeof msg.commandRoute === 'string' ? msg.commandRoute : undefined,
+                routeSource: typeof msg.routeSource === 'string' ? msg.routeSource : undefined,
+                requestId: typeof msg.requestId === 'string' ? msg.requestId : undefined,
+            };
+
+            const previousAbort = tunnelAbortByUser.get(userId);
+            if (previousAbort) {
+                previousAbort();
+                tunnelAbortByUser.delete(userId);
+            }
+
+            sendTunnelFrame({ type: 'start', sessionId: sid, agentId, requestId });
+
+            let currentAbort: (() => void) | null = null;
+            let streamFinished = false;
+            const abort = tunnelMessageHandler.handleMessageStream(
+                userId,
+                sid,
+                content,
+                messageType,
+                {
+                    onThinking: (text) => {
+                        sendTunnelFrame({ type: 'thinking', text, sessionId: sid, agentId, requestId });
+                    },
+                    onChunk: (text) => {
+                        sendTunnelFrame({
+                            type: 'chunk',
+                            text,
+                            delta: text,
+                            sessionId: sid,
+                            agentId,
+                            requestId,
+                        });
+                    },
+                    onDone: (userMessage, assistantMessage) => {
+                        streamFinished = true;
+                        if (currentAbort && tunnelAbortByUser.get(userId) === currentAbort) tunnelAbortByUser.delete(userId);
+                        sendTunnelFrame({
+                            type: 'done',
+                            sessionId: sid,
+                            agentId,
+                            userMessage,
+                            assistantMessage,
+                            text: assistantMessage?.content || '',
+                            requestId,
+                        });
+                    },
+                    onError: (error) => {
+                        streamFinished = true;
+                        if (currentAbort && tunnelAbortByUser.get(userId) === currentAbort) tunnelAbortByUser.delete(userId);
+                        sendTunnelFrame({
+                            type: 'error',
+                            sessionId: sid,
+                            agentId,
+                            message: error,
+                            error,
+                            requestId,
+                        });
+                    },
+                },
+                agentId,
+                mediaUrl,
+                undefined,
+                groupId,
+                routingHint,
+            );
+            currentAbort = abort;
+            if (streamFinished) {
+                return;
+            }
+            tunnelAbortByUser.set(userId, abort);
+            return;
+        }
+
+        if (msg.type === 'stop') {
+            const abort = tunnelAbortByUser.get(userId);
+            if (abort) {
+                abort();
+                tunnelAbortByUser.delete(userId);
+            }
+            sendTunnelFrame({ type: 'stopped', requestId });
+            return;
+        }
+
+        sendTunnelFrame({
+            type: 'error',
+            message: `未知消息类型: ${msg.type}`,
+            error: `未知消息类型: ${msg.type}`,
+        });
+    } catch (err) {
+        console.error('[隧道] 处理消息错误:', err);
+        sendTunnelFrame({
+            type: 'error',
+            message: '隧道消息解析失败',
+            error: '隧道消息解析失败',
+        });
+    }
+}
+
+// ===== 配对流程 =====
+
+async function startPairing(): Promise<DeviceConfig> {
+    console.log('\n📱 首次使用，需要与小程序配对...\n');
+
+    // 调后端 init
+    const initRes = await fetch(`${BACKEND_URL}/api/devices/pair/init`, { method: 'POST' });
+    if (!initRes.ok) {
+        throw new Error(`配对初始化失败: ${initRes.status}`);
+    }
+    const { pairingToken, pairingCode } = await initRes.json() as any;
+
+    // 终端显示二维码
+    const qrContent = JSON.stringify({ type: 'openclaw-pair', token: pairingToken });
+    console.log('╔══════════════════════════════════════════╗');
+    console.log('║   请用 OpenClaw 小程序扫描下方二维码配对   ║');
+    console.log('╚══════════════════════════════════════════╝');
+    console.log('');
+    qrcode.generate(qrContent, { small: true }, (qr: string) => {
+        console.log(qr);
+    });
+    console.log(`   配对码: ${pairingCode}  (5分钟内有效)`);
+    console.log('');
+    console.log('   等待小程序扫码...');
+    console.log('');
+
+    // 轮询
+    return new Promise((resolve, reject) => {
+        const pollInterval = setInterval(async () => {
+            try {
+                const statusRes = await fetch(
+                    `${BACKEND_URL}/api/devices/pair/status?token=${encodeURIComponent(pairingToken)}`
+                );
+                const status = await statusRes.json() as any;
+
+                if (status.status === 'paired') {
+                    clearInterval(pollInterval);
+                    console.log('✅ 配对成功！设备已绑定\n');
+
+                    const cfg: DeviceConfig = {
+                        deviceKey: status.deviceKey,
+                        deviceToken: status.deviceToken,
+                        backendUrl: BACKEND_URL,
+                        pairedAt: new Date().toISOString(),
+                    };
+                    saveDeviceConfig(cfg);
+                    resolve(cfg);
+                } else if (status.status === 'expired' || status.status === 'not_found') {
+                    clearInterval(pollInterval);
+                    reject(new Error('配对已过期，请重新启动插件'));
+                }
+                // pending → 继续轮询
+            } catch (err: any) {
+                console.error('[配对] 轮询错误:', err.message);
+            }
+        }, 2000);
+
+        // 5分钟超时
+        setTimeout(() => {
+            clearInterval(pollInterval);
+            reject(new Error('配对超时（5分钟），请重新启动插件'));
+        }, 5 * 60 * 1000);
+    });
+}
+
+// ===== 注册设备 =====
+
+async function registerDevice(deviceKey: string): Promise<string> {
+    const res = await fetch(`${BACKEND_URL}/api/devices/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ deviceKey }),
+    });
+    if (!res.ok) {
+        const errBody = await res.text();
+        throw new Error(`设备注册失败: ${res.status} ${errBody}`);
+    }
+    const result = await res.json() as any;
+    return result.deviceToken;
+}
+
+// ===== 主启动 =====
+
+async function start(): Promise<void> {
+    gateway = new GatewayClient(config.openclawGatewayUrl, config.openclawAuthToken);
+    setGatewayClient(gateway);
+
+    // 启动本地中继服务器（用于 HTTP API 调用，如 agent 列表等）
+    const relay = createRelayServer(config, gateway);
+    relayServer = relay;
+    tunnelMessageHandler = new MessageHandler(config, relay.sessionManager, gateway);
+    relay.server.listen(config.port, '127.0.0.1', () => {
+        // 不打印，下面统一打印
+    });
+
+    let deviceCfg = readDeviceConfig();
+
+    if (!deviceCfg || !deviceCfg.deviceKey) {
+        // 首次使用 → 扫码配对
+        try {
+            deviceCfg = await startPairing();
+        } catch (err: any) {
+            console.error('❌', err.message);
+            process.exit(1);
+        }
+    }
+
+    // 注册设备获取 token
+    let deviceToken = deviceCfg.deviceToken;
+    try {
+        deviceToken = await registerDevice(deviceCfg.deviceKey);
+        // 更新本地 token
+        deviceCfg.deviceToken = deviceToken;
+        saveDeviceConfig(deviceCfg);
+    } catch (err: any) {
+        console.error('⚠️  设备注册失败:', err.message);
+        if (!deviceToken) {
+            console.error('❌ 无法连接后端，请检查网络或重新配对');
+            process.exit(1);
+        }
+    }
+
+    // 建立反向 WS 隧道
+    connectTunnel(deviceToken!);
+
+    console.log('');
+    console.log('🔌 =============================================');
+    console.log('   OpenClaw VChat Plugin');
+    console.log('   =============================================');
+    console.log(`   📡 本地端口:    http://127.0.0.1:${config.port}`);
+    console.log(`   🔗 OpenClaw:    ${config.openclawGatewayUrl}`);
+    console.log(`   🤖 AI 模型:     ${config.openclawModel}`);
+    console.log(`   🌐 后端:        ${BACKEND_URL}`);
+    console.log(`   🔑 设备:        已配对`);
+    console.log('   =============================================');
+    console.log('');
+}
+
+start().catch((err) => {
+    console.error('❌ 启动失败:', err);
+    process.exit(1);
+});
+
+// 优雅关闭
+const shutdown = () => {
+    console.log('\n🛑 正在关闭插件...');
+    for (const abort of tunnelAbortByUser.values()) {
+        try { abort(); } catch { /* ignore */ }
+    }
+    tunnelAbortByUser.clear();
+    if (tunnelWs) tunnelWs.close();
+    if (relayServer) {
+        relayServer.server.close(() => {
+            relayServer!.sessionManager.close();
+            console.log('✅ 插件已关闭');
+            process.exit(0);
+        });
+    } else {
+        process.exit(0);
+    }
+    setTimeout(() => { process.exit(1); }, 5000);
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/src/media-handler.ts

@@ -0,0 +1,70 @@
+import path from 'path';
+import fs from 'fs';
+import { v4 as uuidv4 } from 'uuid';
+import { PluginConfig } from './types';
+
+/**
+ * 媒体文件处理：语音和图片的存储与访问
+ */
+export class MediaHandler {
+    private uploadDir: string;
+
+    constructor(config: PluginConfig) {
+        this.uploadDir = config.uploadDir;
+        // 确保上传目录存在
+        fs.mkdirSync(path.join(this.uploadDir, 'voice'), { recursive: true });
+        fs.mkdirSync(path.join(this.uploadDir, 'image'), { recursive: true });
+    }
+
+    /**
+     * 保存语音文件，返回文件路径和访问 URL
+     */
+    saveVoice(buffer: Buffer, originalName: string): { filePath: string; url: string } {
+        const ext = path.extname(originalName) || '.mp3';
+        const filename = `${uuidv4()}${ext}`;
+        const filePath = path.join(this.uploadDir, 'voice', filename);
+
+        fs.writeFileSync(filePath, buffer);
+
+        return {
+            filePath,
+            url: `/uploads/voice/${filename}`,
+        };
+    }
+
+    /**
+     * 保存图片文件，返回文件路径和访问 URL
+     */
+    saveImage(buffer: Buffer, originalName: string): { filePath: string; url: string } {
+        const ext = path.extname(originalName) || '.jpg';
+        const filename = `${uuidv4()}${ext}`;
+        const filePath = path.join(this.uploadDir, 'image', filename);
+
+        fs.writeFileSync(filePath, buffer);
+
+        return {
+            filePath,
+            url: `/uploads/image/${filename}`,
+        };
+    }
+
+    /**
+     * 删除媒体文件
+     */
+    deleteFile(filePath: string): void {
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        } catch (err) {
+            console.error('[MediaHandler] 删除文件失败:', filePath, err);
+        }
+    }
+
+    /**
+     * 获取上传目录的绝对路径（用于 Express 静态文件服务）
+     */
+    getUploadDir(): string {
+        return this.uploadDir;
+    }
+}