openclaw-vchat-plugin 0.0.1

package/src/session-manager.ts

@@ -0,0 +1,374 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { Message, Session, SessionUser, MessageRole, MessageType } from './types';
+
+/**
+ * 会话管理器 - SQLite
+ * 仅持久化会话元数据与会话键绑定；聊天明细默认不落地（可通过环境变量开启兼容模式）
+ */
+export class SessionManager {
+    private db: Database.Database;
+    private persistMessages: boolean;
+
+    constructor(dataDir: string, opts?: { persistMessages?: boolean }) {
+        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.persistMessages = Boolean(
+            opts?.persistMessages ?? (process.env.WECHAT_PLUGIN_PERSIST_MESSAGES === '1')
+        );
+        this.initTables();
+    }
+
+    private initTables(): void {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS users (
+        openid TEXT PRIMARY KEY,
+        nickname TEXT,
+        avatar_url TEXT,
+        created_at INTEGER NOT NULL,
+        last_login_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '新对话',
+        last_message TEXT DEFAULT '',
+        last_message_time INTEGER NOT NULL,
+        agent_id TEXT DEFAULT 'main',
+        gateway_key TEXT,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (user_id) REFERENCES users(openid)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        type TEXT NOT NULL DEFAULT 'text',
+        content TEXT NOT NULL,
+        media_url TEXT,
+        duration REAL,
+        timestamp INTEGER NOT NULL,
+        FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+      CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+    `);
+        this.ensureColumn('sessions', 'agent_id', "TEXT DEFAULT 'main'");
+        this.ensureColumn('sessions', 'gateway_key', 'TEXT');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_gateway_key ON sessions(gateway_key)');
+        this.compactSessionMetadata();
+    }
+
+    private compactSessionMetadata(): void {
+        if (this.persistMessages) return;
+
+        this.db.prepare(`
+      UPDATE sessions
+      SET last_message = '',
+          last_message_time = created_at,
+          title = '新对话'
+      WHERE COALESCE(last_message, '') <> ''
+         OR last_message_time <> created_at
+         OR COALESCE(title, '') <> '新对话'
+    `).run();
+    }
+
+    private normalizeStoredSession(row: any): Session {
+        const createdAt = Number(row.created_at) || Date.now();
+        const lastMessageTime = this.persistMessages
+            ? (Number(row.last_message_time) || createdAt)
+            : createdAt;
+
+        return {
+            id: row.id,
+            userId: row.user_id,
+            title: row.title || '新对话',
+            lastMessage: this.persistMessages ? (row.last_message || '') : '',
+            lastMessageTime,
+            agentId: row.agent_id || 'main',
+            gatewaySessionKey: row.gateway_key || '',
+            createdAt,
+        };
+    }
+
+    private ensureColumn(table: string, column: string, sqlType: string): void {
+        const rows = this.db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+        if (!rows.some(r => r.name === column)) {
+            this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${sqlType}`);
+        }
+    }
+
+    // ===== 用户管理 =====
+
+    upsertUser(openid: string, nickname?: string, avatarUrl?: string): void {
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO users (openid, nickname, avatar_url, created_at, last_login_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(openid) DO UPDATE SET
+        nickname = COALESCE(excluded.nickname, users.nickname),
+        avatar_url = COALESCE(excluded.avatar_url, users.avatar_url),
+        last_login_at = excluded.last_login_at
+    `);
+        stmt.run(openid, nickname || null, avatarUrl || null, now, now);
+    }
+
+    getUser(openid: string): SessionUser | null {
+        const row = this.db.prepare('SELECT * FROM users WHERE openid = ?').get(openid) as any;
+        if (!row) return null;
+        return {
+            openid: row.openid,
+            nickname: row.nickname,
+            avatarUrl: row.avatar_url,
+            createdAt: row.created_at,
+            lastLoginAt: row.last_login_at,
+        };
+    }
+
+    // ===== 会话管理 =====
+
+    createSession(userId: string, title?: string, agentId = 'main', sessionId?: string): Session {
+        this.upsertUser(userId);
+        const id = sessionId || uuidv4();
+        const now = Date.now();
+        const sessionTitle = title || '新对话';
+
+        this.db.prepare(`
+      INSERT OR REPLACE INTO sessions (id, user_id, title, last_message, last_message_time, agent_id, gateway_key, created_at)
+      VALUES (?, ?, ?, '', ?, ?, NULL, ?)
+    `).run(id, userId, sessionTitle, now, agentId || 'main', now);
+
+        return {
+            id,
+            userId,
+            title: sessionTitle,
+            lastMessage: '',
+            lastMessageTime: now,
+            agentId: agentId || 'main',
+            createdAt: now,
+        };
+    }
+
+    getSessions(userId: string): Session[] {
+        const rows = this.db.prepare(
+            'SELECT * FROM sessions WHERE user_id = ? ORDER BY created_at DESC'
+        ).all(userId) as any[];
+
+        return rows.map(row => this.normalizeStoredSession(row));
+    }
+
+    getSession(sessionId: string, userId: string): Session | null {
+        const row = this.db.prepare(
+            'SELECT * FROM sessions WHERE id = ? AND user_id = ?'
+        ).get(sessionId, userId) as any;
+
+        if (!row) return null;
+        return this.normalizeStoredSession(row);
+    }
+
+    deleteSession(sessionId: string, userId: string): boolean {
+        const result = this.db.prepare(
+            'DELETE FROM sessions WHERE id = ? AND user_id = ?'
+        ).run(sessionId, userId);
+        return result.changes > 0;
+    }
+
+    upsertSession(
+        userId: string,
+        sessionId: string,
+        patch: Partial<Pick<Session, 'title' | 'lastMessage' | 'lastMessageTime' | 'createdAt' | 'agentId' | 'gatewaySessionKey'>> = {}
+    ): Session {
+        const existing = this.getSession(sessionId, userId);
+        const now = Date.now();
+        const nextTitle = typeof patch.title === 'string' && patch.title.trim()
+            ? patch.title.trim()
+            : (existing?.title || '新对话');
+        const nextCreatedAt = patch.createdAt || existing?.createdAt || now;
+        const nextLastMessage = this.persistMessages
+            ? (patch.lastMessage != null ? patch.lastMessage : (existing?.lastMessage || ''))
+            : '';
+        const nextLastMessageTime = this.persistMessages
+            ? (patch.lastMessageTime || existing?.lastMessageTime || nextCreatedAt)
+            : nextCreatedAt;
+        const next = {
+            id: sessionId,
+            userId,
+            title: nextTitle,
+            lastMessage: nextLastMessage,
+            lastMessageTime: nextLastMessageTime,
+            createdAt: nextCreatedAt,
+            agentId: patch.agentId || existing?.agentId || 'main',
+            gatewaySessionKey: patch.gatewaySessionKey || existing?.gatewaySessionKey || '',
+        };
+
+        this.upsertUser(userId);
+        this.db.prepare(`
+      INSERT INTO sessions (id, user_id, title, last_message, last_message_time, agent_id, gateway_key, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        user_id = excluded.user_id,
+        title = excluded.title,
+        last_message = excluded.last_message,
+        last_message_time = excluded.last_message_time,
+        agent_id = excluded.agent_id,
+        gateway_key = excluded.gateway_key,
+        created_at = excluded.created_at
+    `).run(
+            next.id,
+            next.userId,
+            next.title,
+            next.lastMessage,
+            next.lastMessageTime,
+            next.agentId || 'main',
+            next.gatewaySessionKey || null,
+            next.createdAt,
+        );
+
+        return next;
+    }
+
+    ensureSessionBinding(
+        userId: string,
+        sessionId: string,
+        agentId = 'main',
+        gatewaySessionKey?: string,
+    ): Session {
+        const sid = String(sessionId || '').trim();
+        if (!sid) {
+            return this.createSession(userId, undefined, agentId);
+        }
+
+        const existing = this.getSession(sid, userId);
+        if (existing) {
+            if (
+                existing.agentId !== (agentId || 'main')
+                || (gatewaySessionKey && existing.gatewaySessionKey !== gatewaySessionKey)
+            ) {
+                return this.upsertSession(userId, sid, {
+                    agentId: agentId || 'main',
+                    gatewaySessionKey: gatewaySessionKey || existing.gatewaySessionKey,
+                });
+            }
+            return existing;
+        }
+
+        return this.upsertSession(userId, sid, {
+            agentId: agentId || 'main',
+            gatewaySessionKey: gatewaySessionKey || '',
+        });
+    }
+
+    updateSessionMeta(sessionId: string, lastMessage: string, title?: string): void {
+        if (!this.persistMessages) return;
+        const now = Date.now();
+        if (title) {
+            this.db.prepare(
+                'UPDATE sessions SET last_message = ?, last_message_time = ?, title = ? WHERE id = ?'
+            ).run(lastMessage, now, title, sessionId);
+        } else {
+            this.db.prepare(
+                'UPDATE sessions SET last_message = ?, last_message_time = ? WHERE id = ?'
+            ).run(lastMessage, now, sessionId);
+        }
+    }
+
+    pruneSessions(userId: string, keepSessionIds: string[], agentId?: string): number {
+        const ids = Array.from(new Set((keepSessionIds || []).map(id => String(id || '').trim()).filter(Boolean)));
+        const params: any[] = [userId];
+        let sql = 'DELETE FROM sessions WHERE user_id = ?';
+
+        if (agentId) {
+            sql += ' AND agent_id = ?';
+            params.push(agentId);
+        }
+
+        if (ids.length > 0) {
+            sql += ` AND id NOT IN (${ids.map(() => '?').join(', ')})`;
+            params.push(...ids);
+        }
+
+        const result = this.db.prepare(sql).run(...params);
+        return result.changes;
+    }
+
+    // ===== 消息管理 =====
+
+    addMessage(
+        sessionId: string,
+        role: MessageRole,
+        type: MessageType,
+        content: string,
+        mediaUrl?: string,
+        duration?: number
+    ): Message {
+        const id = uuidv4();
+        const timestamp = Date.now();
+        const message: Message = { id, sessionId, role, type, content, mediaUrl, duration, timestamp };
+
+        if (this.persistMessages) {
+            this.db.prepare(`
+      INSERT INTO messages (id, session_id, role, type, content, media_url, duration, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, sessionId, role, type, content, mediaUrl || null, duration || null, timestamp);
+        }
+
+        // 更新会话摘要
+        const summary = type === 'text' ? content.substring(0, 50) :
+            type === 'voice' ? '[语音消息]' :
+                type === 'image' ? '[图片消息]' : content.substring(0, 50);
+        if (this.persistMessages) {
+            this.updateSessionMeta(sessionId, summary);
+        }
+
+        return message;
+    }
+
+    getMessages(sessionId: string, limit = 50, before?: number): Message[] {
+        if (!this.persistMessages) return [];
+
+        let query: string;
+        let params: any[];
+
+        if (before) {
+            query = 'SELECT * FROM messages WHERE session_id = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?';
+            params = [sessionId, before, limit];
+        } else {
+            query = 'SELECT * FROM messages WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?';
+            params = [sessionId, limit];
+        }
+
+        const rows = this.db.prepare(query).all(...params) as any[];
+
+        return rows.reverse().map(row => ({
+            id: row.id,
+            sessionId: row.session_id,
+            role: row.role as MessageRole,
+            type: row.type as MessageType,
+            content: row.content,
+            mediaUrl: row.media_url,
+            duration: row.duration,
+            timestamp: row.timestamp,
+        }));
+    }
+
+    clearMessages(sessionId: string): number {
+        const result = this.db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
+        return result.changes;
+    }
+
+    close(): void {
+        this.db.close();
+    }
+
+    isPersistMessagesEnabled(): boolean {
+        return this.persistMessages;
+    }
+}

package/src/types.ts

@@ -0,0 +1,96 @@
+// ===== 消息类型 =====
+export type MessageType = 'text' | 'voice' | 'image' | 'system' | 'command';
+export type MessageRole = 'user' | 'assistant' | 'system';
+
+export interface Message {
+    id: string;
+    sessionId: string;
+    role: MessageRole;
+    type: MessageType;
+    content: string;
+    mediaUrl?: string;
+    duration?: number;
+    timestamp: number;
+}
+
+// ===== 会话 =====
+export interface Session {
+    id: string;
+    userId: string;
+    title: string;
+    lastMessage: string;
+    lastMessageTime: number;
+    agentId?: string;
+    gatewaySessionKey?: string;
+    createdAt: number;
+}
+
+// ===== 会话用户（轻量级，仅用于 SessionManager） =====
+export interface SessionUser {
+    openid: string;
+    nickname?: string;
+    avatarUrl?: string;
+    createdAt: number;
+    lastLoginAt: number;
+}
+
+// ===== 命令菜单 =====
+export interface BotCommand {
+    command: string;
+    description: string;
+    icon?: string;
+}
+
+export interface CommandExecutionContext {
+    /** 当前消息对应的 Gateway 会话键（用于 /new /reset /compact /stop） */
+    gatewaySessionKey?: string;
+    /** 当前路由到的 Agent */
+    agentId?: string;
+    /** 当前运行中的 runId（可选） */
+    runId?: string;
+}
+
+// ===== OpenClaw Gateway =====
+export interface OpenClawRequest {
+    model: string;
+    input: string;
+    user?: string;
+}
+
+export interface OpenClawResponse {
+    id: string;
+    output: Array<{
+        type: string;
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+}
+
+// ===== 提供商 =====
+export interface Provider {
+    id: string;
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    api?: string;
+    authHeader?: string;
+    headers?: Record<string, string>;
+    models: any[];
+}
+
+// ===== 配置 (精简版) =====
+export interface PluginConfig {
+    port: number;
+    openclawGatewayUrl: string;
+    openclawModel: string;
+    openclawAuthToken: string;
+    uploadDir: string;
+    maxFileSize: number;
+    maxVoiceDuration: number;
+    /** 与 wechat-backend 通信的共享密钥 */
+    internalSecret: string;
+    /** 是否允许在 Gateway 不可用时退回本地会话/历史缓存 */
+    allowLocalFallback?: boolean;
+}

package/start.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+exec node dist/index.js

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": [
+            "ES2020"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}