openclaw-vchat-plugin 0.0.8 → 0.0.9

package/src/group-event-store.ts

@@ -0,0 +1,204 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { MessageType } from './types';
+
+export interface GroupEvent {
+    id: string;
+    groupId: string;
+    requestId?: string;
+    sessionId?: string;
+    role: 'user' | 'assistant' | 'system';
+    type: MessageType;
+    content: string;
+    mediaUrl?: string;
+    timestamp: number;
+    senderUserId?: string;
+    senderName?: string;
+    senderAvatarUrl?: string;
+    agentId?: string;
+}
+
+function normalizeText(value: unknown): string {
+    return String(value || '').trim();
+}
+
+function normalizeMessageType(value: unknown): MessageType {
+    const normalized = normalizeText(value).toLowerCase();
+    if (normalized === 'voice' || normalized === 'image' || normalized === 'system' || normalized === 'command') {
+        return normalized;
+    }
+    return 'text';
+}
+
+export class GroupEventStore {
+    private db: Database.Database;
+
+    constructor(dataDir: string) {
+        const dbPath = path.join(dataDir, 'openclaw-wechat.db');
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.initTables();
+    }
+
+    private initTables(): void {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS group_events (
+              id TEXT PRIMARY KEY,
+              group_id TEXT NOT NULL,
+              request_id TEXT,
+              session_id TEXT,
+              role TEXT NOT NULL,
+              type TEXT NOT NULL DEFAULT 'text',
+              content TEXT NOT NULL,
+              media_url TEXT,
+              sender_user_id TEXT,
+              sender_name TEXT,
+              sender_avatar_url TEXT,
+              agent_id TEXT,
+              created_at INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_group_events_group_id_created_at
+              ON group_events(group_id, created_at DESC);
+            CREATE INDEX IF NOT EXISTS idx_group_events_request_id
+              ON group_events(request_id);
+        `);
+    }
+
+    appendUserMessage(input: {
+        groupId: string;
+        requestId?: string;
+        sessionId?: string;
+        content: string;
+        type?: MessageType;
+        mediaUrl?: string;
+        senderUserId?: string;
+        senderName?: string;
+        senderAvatarUrl?: string;
+        timestamp?: number;
+    }): GroupEvent {
+        const groupId = normalizeText(input.groupId);
+        const content = String(input.content || '');
+        const requestId = normalizeText(input.requestId);
+
+        if (requestId) {
+            const existing = this.db.prepare(`
+                SELECT * FROM group_events
+                WHERE group_id = ? AND request_id = ? AND role = 'user'
+                LIMIT 1
+            `).get(groupId, requestId) as any;
+            if (existing) {
+                return this.mapRow(existing);
+            }
+        }
+
+        const event: GroupEvent = {
+            id: randomUUID(),
+            groupId,
+            requestId: requestId || undefined,
+            sessionId: normalizeText(input.sessionId) || undefined,
+            role: 'user',
+            type: normalizeMessageType(input.type),
+            content,
+            mediaUrl: normalizeText(input.mediaUrl) || undefined,
+            timestamp: Number(input.timestamp) || Date.now(),
+            senderUserId: normalizeText(input.senderUserId) || undefined,
+            senderName: normalizeText(input.senderName) || undefined,
+            senderAvatarUrl: normalizeText(input.senderAvatarUrl) || undefined,
+        };
+
+        this.insert(event);
+        return event;
+    }
+
+    appendAssistantMessage(input: {
+        groupId: string;
+        requestId?: string;
+        sessionId?: string;
+        agentId?: string;
+        content: string;
+        type?: MessageType;
+        mediaUrl?: string;
+        timestamp?: number;
+    }): GroupEvent {
+        const event: GroupEvent = {
+            id: randomUUID(),
+            groupId: normalizeText(input.groupId),
+            requestId: normalizeText(input.requestId) || undefined,
+            sessionId: normalizeText(input.sessionId) || undefined,
+            role: 'assistant',
+            type: normalizeMessageType(input.type),
+            content: String(input.content || ''),
+            mediaUrl: normalizeText(input.mediaUrl) || undefined,
+            timestamp: Number(input.timestamp) || Date.now(),
+            agentId: normalizeText(input.agentId) || undefined,
+        };
+
+        this.insert(event);
+        return event;
+    }
+
+    list(groupId: string, limit = 100, before?: number): GroupEvent[] {
+        const safeLimit = Math.max(1, Math.min(Number(limit) || 100, 200));
+        const safeBefore = Number(before) || 0;
+        const rows = safeBefore > 0
+            ? this.db.prepare(`
+                SELECT * FROM group_events
+                WHERE group_id = ? AND created_at < ?
+                ORDER BY created_at DESC
+                LIMIT ?
+            `).all(normalizeText(groupId), safeBefore, safeLimit) as any[]
+            : this.db.prepare(`
+                SELECT * FROM group_events
+                WHERE group_id = ?
+                ORDER BY created_at DESC
+                LIMIT ?
+            `).all(normalizeText(groupId), safeLimit) as any[];
+
+        return rows
+            .map((row) => this.mapRow(row))
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+
+    private insert(event: GroupEvent): void {
+        this.db.prepare(`
+            INSERT INTO group_events (
+              id, group_id, request_id, session_id, role, type, content, media_url,
+              sender_user_id, sender_name, sender_avatar_url, agent_id, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+            event.id,
+            event.groupId,
+            event.requestId || null,
+            event.sessionId || null,
+            event.role,
+            event.type,
+            event.content,
+            event.mediaUrl || null,
+            event.senderUserId || null,
+            event.senderName || null,
+            event.senderAvatarUrl || null,
+            event.agentId || null,
+            event.timestamp,
+        );
+    }
+
+    private mapRow(row: any): GroupEvent {
+        return {
+            id: normalizeText(row.id),
+            groupId: normalizeText(row.group_id),
+            requestId: normalizeText(row.request_id) || undefined,
+            sessionId: normalizeText(row.session_id) || undefined,
+            role: normalizeText(row.role) === 'assistant' ? 'assistant' : normalizeText(row.role) === 'system' ? 'system' : 'user',
+            type: normalizeMessageType(row.type),
+            content: String(row.content || ''),
+            mediaUrl: normalizeText(row.media_url) || undefined,
+            timestamp: Number(row.created_at) || Date.now(),
+            senderUserId: normalizeText(row.sender_user_id) || undefined,
+            senderName: normalizeText(row.sender_name) || undefined,
+            senderAvatarUrl: normalizeText(row.sender_avatar_url) || undefined,
+            agentId: normalizeText(row.agent_id) || undefined,
+        };
+    }
+}

package/src/index.ts

@@ -234,6 +234,7 @@ function handleClientMessage(raw: string): void {
                 sendTunnelFrame({ type: 'error', message: '插件尚未完成初始化', error: '插件尚未完成初始化' });
                 return;
             }
+            const currentRelayServer = relayServer;
 
             const content = String(msg.content || '').trim();
             if (!content) {
@@ -258,6 +259,20 @@ function handleClientMessage(raw: string): void {
                 requestId: typeof msg.requestId === 'string' ? msg.requestId : undefined,
             };
 
+            if (groupId) {
+                currentRelayServer.groupEventStore.appendUserMessage({
+                    groupId,
+                    requestId: requestId || undefined,
+                    sessionId: sid,
+                    content,
+                    type: messageType,
+                    mediaUrl,
+                    senderUserId: userId,
+                    senderName: typeof msg.senderName === 'string' ? msg.senderName : undefined,
+                    senderAvatarUrl: typeof msg.senderAvatarUrl === 'string' ? msg.senderAvatarUrl : undefined,
+                });
+            }
+
             const previousAbort = tunnelAbortByUser.get(userId);
             if (previousAbort) {
                 previousAbort();
@@ -290,6 +305,17 @@ function handleClientMessage(raw: string): void {
                     onDone: (userMessage, assistantMessage) => {
                         streamFinished = true;
                         if (currentAbort && tunnelAbortByUser.get(userId) === currentAbort) tunnelAbortByUser.delete(userId);
+                        if (groupId && assistantMessage?.content) {
+                            currentRelayServer.groupEventStore.appendAssistantMessage({
+                                groupId,
+                                requestId: requestId || undefined,
+                                sessionId: sid,
+                                agentId,
+                                content: assistantMessage.content,
+                                type: assistantMessage.type,
+                                mediaUrl: assistantMessage.mediaUrl,
+                            });
+                        }
                         sendTunnelFrame({
                             type: 'done',
                             sessionId: sid,

package/src/plugin-update-runner.ts

@@ -0,0 +1,217 @@
+import fs from 'fs';
+import http from 'http';
+import { execFileSync } from 'child_process';
+
+type UpdatePhase =
+    | 'queued'
+    | 'checking'
+    | 'installing'
+    | 'restarting'
+    | 'verifying'
+    | 'succeeded'
+    | 'failed'
+    | 'rolled_back';
+
+type UpdateStatus = 'running' | 'succeeded' | 'failed' | 'rolled_back';
+
+type UpdateState = {
+    status: UpdateStatus;
+    phase: UpdatePhase;
+    currentVersion: string;
+    latestVersion: string;
+    targetVersion: string;
+    updateAvailable: boolean;
+    message: string;
+    packageName: string;
+    registry: string;
+    pm2ProcessName: string;
+    pm2Managed: boolean;
+    startedAt: number;
+    finishedAt: number;
+    error: string;
+    warning: string;
+};
+
+function cleanString(value: unknown): string {
+    return String(value || '').trim();
+}
+
+function npmCommand(): string {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function pm2Command(): string {
+    return process.platform === 'win32' ? 'pm2.cmd' : 'pm2';
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const statePath = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_STATE);
+const packageName = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_PACKAGE) || 'openclaw-vchat-plugin';
+const currentVersion = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_CURRENT);
+const targetVersion = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_TARGET);
+const registry = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_REGISTRY);
+const pm2Name = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_PM2_NAME) || 'openclaw-vchat';
+const healthUrl = cleanString(process.env.OPENCLAW_VCHAT_UPDATE_HEALTH_URL) || 'http://127.0.0.1:39217/internal/health';
+
+function readState(): UpdateState {
+    const raw = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    return raw as UpdateState;
+}
+
+function writeState(patch: Partial<UpdateState>): UpdateState {
+    const current = readState();
+    const next = {
+        ...current,
+        ...patch,
+    };
+    fs.writeFileSync(statePath, JSON.stringify(next, null, 2) + '\n', 'utf-8');
+    return next;
+}
+
+function runCommand(command: string, args: string[], timeout: number): string {
+    const stdout = execFileSync(command, args, {
+        encoding: 'utf8',
+        timeout,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    return cleanString(stdout);
+}
+
+function buildNpmArgs(version: string): string[] {
+    const args = ['install', '-g', `${packageName}@${version}`];
+    if (registry) args.push('--registry', registry);
+    return args;
+}
+
+function restartPm2(): void {
+    runCommand(pm2Command(), ['restart', pm2Name, '--update-env'], 30000);
+    try {
+        runCommand(pm2Command(), ['save'], 10000);
+    } catch {
+        // ignore save failure
+    }
+}
+
+async function waitForHealth(url: string, timeoutMs: number): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const ok = await new Promise<boolean>((resolve) => {
+            const req = http.get(url, (res) => {
+                const statusCode = Number(res.statusCode) || 0;
+                res.resume();
+                resolve(statusCode >= 200 && statusCode < 300);
+            });
+            req.on('error', () => resolve(false));
+            req.setTimeout(3000, () => {
+                req.destroy();
+                resolve(false);
+            });
+        });
+        if (ok) return;
+        await sleep(1500);
+    }
+    throw new Error('插件重启后健康检查超时');
+}
+
+async function rollback(reason: string): Promise<void> {
+    if (!currentVersion) {
+        writeState({
+            status: 'failed',
+            phase: 'failed',
+            finishedAt: Date.now(),
+            error: reason,
+            message: '更新失败，且缺少回滚版本',
+        });
+        return;
+    }
+
+    try {
+        writeState({
+            phase: 'installing',
+            message: `更新失败，正在回滚到 v${currentVersion}`,
+            error: reason,
+        });
+        runCommand(npmCommand(), buildNpmArgs(currentVersion), 600000);
+        writeState({
+            phase: 'restarting',
+            message: '回滚安装完成，正在重启插件',
+            error: reason,
+        });
+        restartPm2();
+        writeState({
+            phase: 'verifying',
+            message: '正在验证回滚后的插件状态',
+            error: reason,
+        });
+        await waitForHealth(healthUrl, 60000);
+        writeState({
+            status: 'rolled_back',
+            phase: 'rolled_back',
+            finishedAt: Date.now(),
+            message: `更新失败，已回滚到 v${currentVersion}`,
+            error: reason,
+            warning: '请稍后重试，或先检查 Node / npm / 网络环境',
+        });
+    } catch (rollbackErr: any) {
+        writeState({
+            status: 'failed',
+            phase: 'failed',
+            finishedAt: Date.now(),
+            message: '更新失败，且自动回滚失败',
+            error: `${reason}; rollback=${cleanString(rollbackErr?.message) || 'unknown'}`,
+        });
+    }
+}
+
+async function main() {
+    try {
+        writeState({
+            status: 'running',
+            phase: 'checking',
+            message: `准备更新到 v${targetVersion}`,
+            error: '',
+            warning: '',
+        });
+
+        writeState({
+            phase: 'installing',
+            message: `正在下载并安装 v${targetVersion}`,
+        });
+        runCommand(npmCommand(), buildNpmArgs(targetVersion), 600000);
+
+        writeState({
+            phase: 'restarting',
+            message: '安装完成，正在重启插件进程',
+        });
+        restartPm2();
+
+        writeState({
+            phase: 'verifying',
+            message: '正在验证更新后的插件状态',
+        });
+        await waitForHealth(healthUrl, 60000);
+
+        writeState({
+            status: 'succeeded',
+            phase: 'succeeded',
+            currentVersion: targetVersion,
+            latestVersion: targetVersion,
+            targetVersion,
+            updateAvailable: false,
+            finishedAt: Date.now(),
+            message: `插件已更新到 v${targetVersion}`,
+            error: '',
+            warning: '',
+        });
+    } catch (err: any) {
+        await rollback(cleanString(err?.message) || 'plugin-update-failed');
+    }
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch(() => process.exit(1));

package/src/relay-server.ts

@@ -12,11 +12,14 @@ import { MessageHandler } from './message-handler';
 import { MediaHandler } from './media-handler';
 import { GatewayClient } from './gateway-client';
 import { GroupManager } from './group-manager';
+import { GroupEventStore } from './group-event-store';
 import { BOT_COMMANDS } from './commands';
 import { Message, PluginConfig } from './types';
 import { BRIDGE_CAPABILITIES, BRIDGE_PLUGIN_VERSION, BRIDGE_PROTOCOL_VERSION } from './constants';
 import { buildWeChatGatewaySessionKey, parseWeChatDirectThreadSessionKey, sanitizeWeChatId } from './session-key';
 import configRoutes from './routes/config.routes';
+import { getSkillsStatus, installSkill, setSkillEnabledLocally, updateSkill } from './services/skills.service';
+import { checkPluginUpdateInfo, readPluginUpdateState, startPluginUpdate } from './services/plugin-update.service';
 
 interface GatewayWechatSession {
     id: string;
@@ -496,11 +499,13 @@ export function createRelayServer(config: PluginConfig, gateway: GatewayClient)
     const app = express();
     const dataDir = path.join(config.uploadDir, '..');
     const sessionManager = new SessionManager(dataDir);
+    const groupEventStore = new GroupEventStore(dataDir);
     const messageHandler = new MessageHandler(config, sessionManager, gateway);
     const mediaHandler = new MediaHandler(config);
     const groupManager = new GroupManager(dataDir);
     const memoSessions = createRequestMemo<any>(1000);
     const memoGroups = createRequestMemo<any>(1000);
+    const memoSkills = createRequestMemo<any>(1500);
     const memoHistory = createRequestMemo<any>(800);
 
     // ===== 中间件 =====
@@ -817,6 +822,19 @@ export function createRelayServer(config: PluginConfig, gateway: GatewayClient)
             .catch((err: any) => res.status(500).json({ error: err?.message || '群列表获取失败' }));
     });
 
+    internal.get('/groups/:id/history', (req: Request, res: Response) => {
+        try {
+            const limit = parseInt(String(req.query.limit || ''), 10) || 100;
+            const before = req.query.before ? parseInt(String(req.query.before), 10) : undefined;
+            res.json({
+                messages: groupEventStore.list(req.params.id, limit, before),
+                source: 'local-group-events',
+            });
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '群历史获取失败' });
+        }
+    });
+
     internal.post('/groups', (req: Request, res: Response) => {
         const { name, emoji, agentIds, mode } = req.body;
         if (!name) { res.status(400).json({ error: '缺少群名称' }); return; }
@@ -847,6 +865,98 @@ export function createRelayServer(config: PluginConfig, gateway: GatewayClient)
         group ? res.json(group) : res.status(404).json({ error: '群不存在' });
     });
 
+    // ===== Skills API =====
+
+    internal.get('/skills', async (req: Request, res: Response) => {
+        try {
+            const agentId = typeof req.query.agentId === 'string' ? req.query.agentId : '';
+            const memoKey = `skills:${String(agentId || '*').trim() || '*'}`;
+            const payload = await memoSkills(memoKey, async () => {
+                const status = await getSkillsStatus(gateway, agentId);
+                return {
+                    ...status,
+                    source: 'gateway',
+                };
+            });
+            res.json(payload);
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '获取 Skills 列表失败' });
+        }
+    });
+
+    internal.post('/skills/install', async (req: Request, res: Response) => {
+        try {
+            const result = await installSkill(gateway, {
+                name: typeof req.body?.name === 'string' ? req.body.name : '',
+                installId: typeof req.body?.installId === 'string' ? req.body.installId : '',
+                timeoutMs: req.body?.timeoutMs,
+            });
+            res.json(result);
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '安装 Skill 失败' });
+        }
+    });
+
+    internal.post('/skills/:skillKey/update', async (req: Request, res: Response) => {
+        try {
+            const skillKey = String(req.params.skillKey || '').trim();
+            if (!skillKey) {
+                res.status(400).json({ error: '缺少 skillKey' });
+                return;
+            }
+
+            const payload = {
+                enabled: typeof req.body?.enabled === 'boolean' ? req.body.enabled : undefined,
+                apiKey: typeof req.body?.apiKey === 'string' ? req.body.apiKey : undefined,
+                env: req.body?.env && typeof req.body.env === 'object' ? req.body.env : undefined,
+            };
+
+            try {
+                const result = await updateSkill(gateway, skillKey, payload);
+                res.json(result);
+            } catch (err: any) {
+                if (typeof payload.enabled !== 'boolean') throw err;
+                const fallback = setSkillEnabledLocally(gateway, skillKey, payload.enabled);
+                res.json({
+                    ...fallback,
+                    source: 'local-config',
+                    warning: err?.message || 'Gateway skills.update 失败，已改为本地配置写入',
+                });
+            }
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '更新 Skill 状态失败' });
+        }
+    });
+
+    // ===== Plugin update =====
+
+    internal.get('/plugin/update/info', async (_req: Request, res: Response) => {
+        try {
+            const info = await checkPluginUpdateInfo();
+            res.json(info);
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '检查插件更新失败' });
+        }
+    });
+
+    internal.get('/plugin/update/status', (_req: Request, res: Response) => {
+        try {
+            res.json(readPluginUpdateState());
+        } catch (err: any) {
+            res.status(500).json({ error: err?.message || '获取插件更新状态失败' });
+        }
+    });
+
+    internal.post('/plugin/update/start', async (req: Request, res: Response) => {
+        try {
+            const targetVersion = typeof req.body?.version === 'string' ? req.body.version : '';
+            const result = await startPluginUpdate(targetVersion);
+            res.json(result);
+        } catch (err: any) {
+            res.status(400).json({ error: err?.message || '启动插件更新失败' });
+        }
+    });
+
     // ===== 聊天 =====
 
     internal.get('/chat/history', async (req: Request, res: Response) => {
@@ -1111,7 +1221,7 @@ export function createRelayServer(config: PluginConfig, gateway: GatewayClient)
         });
     });
 
-    return { app, server, sessionManager, wss };
+    return { app, server, sessionManager, groupEventStore, wss };
 }
 
 // ===== WebSocket 处理函数 =====

package/src/routes/config.routes.ts

@@ -37,6 +37,52 @@ router.get('/models', (req: Request, res: Response) => {
     }
 });
 
+/**
+ * POST /api/config/providers/test
+ * 测试节点连通性并自动获取全部模型
+ * (通过后端代理请求，绕过小程序的合法域名限制)
+ */
+router.post('/providers/test', async (req: Request, res: Response) => {
+    try {
+        const { baseUrl, apiKey } = req.body;
+        if (!baseUrl || !apiKey) {
+            res.status(400).json({ error: '请提供baseUrl和apiKey' });
+            return;
+        }
+
+        let pingUrl = baseUrl.trim();
+        if (!pingUrl.endsWith('/models') && !pingUrl.endsWith('/models/')) {
+            pingUrl = pingUrl.endsWith('/') ? pingUrl + 'models' : pingUrl + '/models';
+        }
+
+        // 使用 Node 18+ 内置的 fetch，并注入超时控制
+        const response = await fetch(pingUrl, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey.trim()}`
+            },
+            signal: AbortSignal.timeout(10000) // 10秒超时
+        });
+
+        if (!response.ok) {
+            res.status(response.status).json({ error: `提供商连接异常: ${response.statusText}` });
+            return;
+        }
+
+        const data: any = await response.json();
+        if (data && data.data && Array.isArray(data.data)) {
+            const models = data.data.map((m: any) => m.id);
+            res.json({ models });
+        } else {
+            res.status(400).json({ error: '返回格式非标准 OpenAI 规范' });
+        }
+    } catch (err: any) {
+        console.error('[ConfigRoutes] 测试提供商连通性异常:', err);
+        res.status(500).json({ error: err.name === 'TimeoutError' ? '连接超时' : err.message || '网络连接失败' });
+    }
+});
+
 /**
  * POST /api/config/providers
  * Body: { preset?, providerId?, baseUrl?, apiKey, name?, api?, authHeader?, headers?, models? }