openclaw-vchat-plugin 0.0.1

package/src/routes/config.routes.ts

@@ -0,0 +1,144 @@
+/**
+ * 模型配置路由
+ * GET    /api/config/providers     — 提供商列表
+ * POST   /api/config/providers     — 添加提供商
+ * DELETE /api/config/providers/:id — 删除提供商
+ * POST   /api/config/reset         — 重置配置
+ * GET    /api/config/export        — 导出配置
+ * POST   /api/config/import        — 导入配置
+ */
+
+import { Router, Request, Response } from 'express';
+import * as configService from '../services/config.service';
+
+const router = Router();
+
+/**
+ * GET /api/config/providers
+ */
+router.get('/providers', (req: Request, res: Response) => {
+    try {
+        const providers = configService.getProviders();
+        res.json({ providers });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] getProviders 错误:', err);
+        res.status(500).json({ error: err.message || '获取提供商列表失败' });
+    }
+});
+
+/**
+ * POST /api/config/providers
+ * Body: { preset?, providerId?, baseUrl?, apiKey, name?, api?, authHeader?, headers?, models? }
+ */
+router.post('/providers', (req: Request, res: Response) => {
+    try {
+        const { preset, providerId, baseUrl, apiKey, name, api, authHeader, headers, models } = req.body;
+
+        if (!apiKey) {
+            res.status(400).json({ error: '请提供 API Key' });
+            return;
+        }
+
+        const provider = configService.addProvider({
+            preset,
+            providerId,
+            baseUrl,
+            apiKey,
+            name,
+            api,
+            authHeader,
+            headers,
+            models,
+        });
+        res.json({ provider });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] addProvider 错误:', err);
+        res.status(400).json({ error: err.message || '添加提供商失败' });
+    }
+});
+
+/**
+ * PUT /api/config/providers/:id
+ */
+router.put('/providers/:id', (req: Request, res: Response) => {
+    try {
+        const { id } = req.params;
+        const provider = configService.updateProvider(id, req.body);
+        res.json({ provider });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] updateProvider 错误:', err);
+        res.status(400).json({ error: err.message || '更新提供商失败' });
+    }
+});
+
+/**
+ * DELETE /api/config/providers/:id
+ */
+router.delete('/providers/:id', (req: Request, res: Response) => {
+    try {
+        const { id } = req.params;
+        configService.deleteProvider(id);
+        res.json({ message: '已删除' });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] deleteProvider 错误:', err);
+        res.status(400).json({ error: err.message || '删除提供商失败' });
+    }
+});
+
+/**
+ * POST /api/config/reset
+ */
+router.post('/reset', (req: Request, res: Response) => {
+    try {
+        configService.resetConfig();
+        res.json({ message: '配置已重置为默认' });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] reset 错误:', err);
+        res.status(500).json({ error: err.message || '重置配置失败' });
+    }
+});
+
+/**
+ * POST /api/config/backup
+ */
+router.post('/backup', (req: Request, res: Response) => {
+    try {
+        configService.backupConfig();
+        res.json({ message: '配置已备份' });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] backup 错误:', err);
+        res.status(500).json({ error: err.message || '备份配置失败' });
+    }
+});
+
+/**
+ * GET /api/config/export
+ */
+router.get('/export', (req: Request, res: Response) => {
+    try {
+        const config = configService.exportConfig();
+        res.json(config);
+    } catch (err: any) {
+        console.error('[ConfigRoutes] export 错误:', err);
+        res.status(500).json({ error: err.message || '导出配置失败' });
+    }
+});
+
+/**
+ * POST /api/config/import
+ */
+router.post('/import', (req: Request, res: Response) => {
+    try {
+        if (!req.body || Object.keys(req.body).length === 0) {
+            res.status(400).json({ error: '请提供配置数据' });
+            return;
+        }
+        configService.importConfig(req.body);
+        res.json({ message: '配置已导入' });
+    } catch (err: any) {
+        console.error('[ConfigRoutes] import 错误:', err);
+        res.status(400).json({ error: err.message || '导入配置失败' });
+    }
+});
+
+export default router;

package/src/services/config.service.ts

@@ -0,0 +1,398 @@
+/**
+ * 模型提供商配置服务
+ * 读写 openclaw.json / 预设模板 / 配置导出导入
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { Provider } from '../types';
+import { PROVIDER_PRESETS } from '../constants';
+
+// OpenClaw 配置文件路径
+const OPENCLAW_DIR = process.env.OPENCLAW_DIR || path.join(require('os').homedir(), '.openclaw');
+const OPENCLAW_CONFIG_PATH = path.join(OPENCLAW_DIR, 'openclaw.json');
+const BACKUP_DIR = path.join(OPENCLAW_DIR, 'backups');
+
+// 内置默认配置
+const DEFAULT_CONFIG_PATH = path.join(__dirname, '..', '..', 'default-config.json');
+
+/**
+ * 读取 openclaw.json
+ */
+function readConfig(): any {
+    try {
+        const content = fs.readFileSync(OPENCLAW_CONFIG_PATH, 'utf-8');
+        return JSON.parse(content);
+    } catch {
+        return { models: { providers: {} } };
+    }
+}
+
+function ensureProvidersObject(config: any): Record<string, any> {
+    if (!config.models || typeof config.models !== 'object') config.models = {};
+    const raw = config.models.providers;
+
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        config.models.providers = raw;
+        return config.models.providers;
+    }
+
+    // 兼容旧格式：providers 是数组
+    const normalized: Record<string, any> = {};
+    if (Array.isArray(raw)) {
+        for (const item of raw) {
+            if (!item || typeof item !== 'object') continue;
+            const key = makeProviderKey(
+                item.id || item.providerId || item.name || item.baseUrl || `provider_${Object.keys(normalized).length + 1}`,
+                normalized
+            );
+            normalized[key] = sanitizeProviderEntry(item);
+        }
+    }
+
+    config.models.providers = normalized;
+    return config.models.providers;
+}
+
+/**
+ * 转换字符串模型列表为 OpenClaw 官方对象列表
+ */
+function formatModels(models: any[]): any[] {
+    if (!models || !Array.isArray(models)) return [];
+    return models
+        .map((m) => {
+            if (typeof m === 'object' && m !== null && m.id) {
+                return {
+                    ...m,
+                    id: String(m.id),
+                    name: m.name ? String(m.name) : String(m.id),
+                };
+            }
+            const id = String(m || '').trim();
+            if (!id) return null;
+            return {
+                id,
+                name: id,
+                reasoning: false,
+                input: ['text'],
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                contextWindow: 128000,
+                maxTokens: 128000,
+            };
+        })
+        .filter(Boolean);
+}
+
+function normalizeApi(api?: string): string {
+    const val = String(api || '').trim();
+    return val || 'openai-completions';
+}
+
+function sanitizeProviderEntry(entry: any): any {
+    const normalized: any = {};
+
+    const baseUrl = String(entry?.baseUrl || entry?.baseURL || '').trim();
+    if (baseUrl) normalized.baseUrl = baseUrl;
+
+    const apiKey = String(entry?.apiKey || '').trim();
+    if (apiKey) normalized.apiKey = apiKey;
+
+    normalized.api = normalizeApi(entry?.api);
+
+    const authHeader = String(entry?.authHeader || '').trim();
+    if (authHeader) normalized.authHeader = authHeader;
+
+    if (entry?.headers && typeof entry.headers === 'object' && !Array.isArray(entry.headers)) {
+        normalized.headers = entry.headers;
+    }
+
+    if (Array.isArray(entry?.models)) {
+        normalized.models = formatModels(entry.models);
+    } else {
+        normalized.models = [];
+    }
+
+    return normalized;
+}
+
+function slugify(value: string): string {
+    const lowered = String(value || '').trim().toLowerCase();
+    const slug = lowered
+        .replace(/^https?:\/\//, '')
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return slug || 'provider';
+}
+
+function makeProviderKey(seed: string, providers: Record<string, any>): string {
+    const base = slugify(seed);
+    let key = base;
+    let idx = 2;
+    while (providers[key]) {
+        key = `${base}_${idx}`;
+        idx += 1;
+    }
+    return key;
+}
+
+function validateProviderIdOrThrow(value: string): string {
+    const trimmed = String(value || '').trim();
+    if (!/^[A-Za-z0-9]{1,8}$/.test(trimmed)) {
+        throw new Error('providerId 仅允许英文大小写和数字，长度 1-8');
+    }
+    return trimmed;
+}
+
+function pickProviderDisplayName(providerId: string, entry: any): string {
+    const explicit = String(entry?.name || '').trim();
+    if (explicit) return explicit;
+
+    const fromPreset = Object.entries(PROVIDER_PRESETS).find(([, preset]) => {
+        return preset.baseUrl === entry?.baseUrl;
+    });
+    if (fromPreset) return fromPreset[1].name;
+
+    return providerId;
+}
+
+/**
+ * 写入 openclaw.json
+ */
+function writeConfig(config: any): void {
+    fs.mkdirSync(path.dirname(OPENCLAW_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+/**
+ * 获取提供商列表（apiKey 脱敏）
+ */
+export function getProviders(): Provider[] {
+    const config = readConfig();
+    const providersObj = ensureProvidersObject(config);
+
+    return Object.keys(providersObj).map((key) => {
+        const raw = providersObj[key] || {};
+        const p = sanitizeProviderEntry(raw);
+        return {
+            id: key,
+            name: pickProviderDisplayName(key, raw),
+            baseUrl: p.baseUrl || '',
+            apiKey: maskApiKey(p.apiKey || ''),
+            api: p.api || 'openai-completions',
+            authHeader: p.authHeader,
+            headers: p.headers,
+            models: p.models || [],
+        };
+    });
+}
+
+/**
+ * 添加提供商
+ * 官方结构：models.providers.<providerId> = { baseUrl, apiKey, api, models, ... }
+ */
+export function addProvider(options: {
+    preset?: string;
+    providerId?: string;
+    baseUrl?: string;
+    apiKey: string;
+    name?: string;
+    api?: string;
+    authHeader?: string;
+    headers?: Record<string, string>;
+    models?: string[];
+}): Provider {
+    const config = readConfig();
+    const providers = ensureProvidersObject(config);
+
+    const apiKey = String(options.apiKey || '').trim();
+    if (!apiKey) throw new Error('请提供 API Key');
+
+    let providerId = '';
+    let providerEntry: any = {};
+    let displayName = '';
+
+    if (options.preset && options.preset in PROVIDER_PRESETS) {
+        const template = PROVIDER_PRESETS[options.preset];
+        providerId = validateProviderIdOrThrow(options.providerId || options.preset || '');
+        if (providers[providerId]) throw new Error(`providerId 已存在: ${providerId}`);
+        providerEntry = sanitizeProviderEntry({
+            baseUrl: template.baseUrl,
+            apiKey,
+            api: template.api,
+            models: template.models,
+        });
+        displayName = template.name;
+    } else {
+        const baseUrl = String(options.baseUrl || '').trim();
+        if (!baseUrl) throw new Error('自定义提供商需要指定 baseUrl');
+        if (!options.providerId) throw new Error('自定义提供商必须提供 providerId');
+        providerId = validateProviderIdOrThrow(options.providerId);
+        if (providers[providerId]) throw new Error(`providerId 已存在: ${providerId}`);
+
+        providerEntry = sanitizeProviderEntry({
+            baseUrl,
+            apiKey,
+            api: options.api,
+            authHeader: options.authHeader,
+            headers: options.headers,
+            models: options.models || [],
+        });
+
+        displayName = String(options.name || providerId).trim() || providerId;
+    }
+
+    providers[providerId] = providerEntry;
+    writeConfig(config);
+
+    console.log(`[ConfigService] 添加提供商: ${displayName} (${providerId})`);
+
+    return {
+        id: providerId,
+        name: displayName,
+        baseUrl: providerEntry.baseUrl || '',
+        apiKey: maskApiKey(providerEntry.apiKey || ''),
+        api: providerEntry.api || 'openai-completions',
+        authHeader: providerEntry.authHeader,
+        headers: providerEntry.headers,
+        models: providerEntry.models || [],
+    };
+}
+
+/**
+ * 删除提供商
+ */
+export function deleteProvider(providerId: string): void {
+    const config = readConfig();
+    const providers = ensureProvidersObject(config);
+
+    if (!providers[providerId]) {
+        throw new Error(`提供商不存在: ${providerId}`);
+    }
+
+    delete providers[providerId];
+    writeConfig(config);
+
+    console.log(`[ConfigService] 删除提供商: ${providerId}`);
+}
+
+/**
+ * 更新提供商
+ */
+export function updateProvider(providerId: string, data: Partial<{
+    name: string;
+    baseUrl: string;
+    apiKey: string;
+    api: string;
+    authHeader: string;
+    headers: Record<string, string>;
+    models: string[];
+}>): Provider {
+    const config = readConfig();
+    const providers = ensureProvidersObject(config);
+
+    const currentRaw = providers[providerId];
+    if (!currentRaw) {
+        throw new Error(`提供商不存在: ${providerId}`);
+    }
+
+    const current = sanitizeProviderEntry(currentRaw);
+    const next = { ...current };
+
+    if (data.baseUrl !== undefined) next.baseUrl = String(data.baseUrl || '').trim();
+    if (data.apiKey !== undefined) next.apiKey = String(data.apiKey || '').trim();
+    if (data.api !== undefined) next.api = normalizeApi(data.api);
+    if (data.authHeader !== undefined) {
+        const authHeader = String(data.authHeader || '').trim();
+        if (authHeader) next.authHeader = authHeader;
+        else delete next.authHeader;
+    }
+    if (data.headers !== undefined) {
+        if (data.headers && typeof data.headers === 'object' && !Array.isArray(data.headers)) {
+            next.headers = data.headers;
+        } else {
+            delete next.headers;
+        }
+    }
+    if (data.models !== undefined) next.models = formatModels(data.models);
+
+    providers[providerId] = next;
+    writeConfig(config);
+
+    console.log(`[ConfigService] 更新提供商: ${providerId}`);
+
+    return {
+        id: providerId,
+        name: String(data.name || pickProviderDisplayName(providerId, currentRaw) || providerId),
+        baseUrl: next.baseUrl || '',
+        apiKey: maskApiKey(next.apiKey || ''),
+        api: next.api || 'openai-completions',
+        authHeader: next.authHeader,
+        headers: next.headers,
+        models: next.models || [],
+    };
+}
+
+/**
+ * 重置配置（备份当前 → 覆盖为默认）
+ */
+export function resetConfig(): void {
+    backupConfig();
+
+    // 用默认配置覆盖
+    if (fs.existsSync(DEFAULT_CONFIG_PATH)) {
+        const defaultConfig = fs.readFileSync(DEFAULT_CONFIG_PATH, 'utf-8');
+        writeConfig(JSON.parse(defaultConfig));
+    } else {
+        // 无默认配置文件 → 写入空配置
+        writeConfig({ models: { providers: {} } });
+    }
+
+    console.log('[ConfigService] 配置已重置为默认');
+}
+
+/**
+ * 备份配置
+ */
+export function backupConfig(): void {
+    if (fs.existsSync(OPENCLAW_CONFIG_PATH)) {
+        fs.mkdirSync(BACKUP_DIR, { recursive: true });
+        // 按北京时间生成友好的文件名，包含小时和分钟
+        const d = new Date();
+        const dateStr = [d.getFullYear(), String(d.getMonth() + 1).padStart(2, '0'), String(d.getDate()).padStart(2, '0')].join('-');
+        const timeStr = [String(d.getHours()).padStart(2, '0'), String(d.getMinutes()).padStart(2, '0'), String(d.getSeconds()).padStart(2, '0')].join('');
+        const backupName = `openclaw-backup-${dateStr}-${timeStr}.json`;
+        fs.copyFileSync(OPENCLAW_CONFIG_PATH, path.join(BACKUP_DIR, backupName));
+        console.log(`[ConfigService] 配置已备份: ${backupName}`);
+    }
+}
+
+/**
+ * 导出配置
+ */
+export function exportConfig(): any {
+    return readConfig();
+}
+
+/**
+ * 导入配置
+ */
+export function importConfig(configData: any): void {
+    // 备份当前配置
+    if (fs.existsSync(OPENCLAW_CONFIG_PATH)) {
+        fs.mkdirSync(BACKUP_DIR, { recursive: true });
+        const backupName = `openclaw-pre-import-${Date.now()}.json`;
+        fs.copyFileSync(OPENCLAW_CONFIG_PATH, path.join(BACKUP_DIR, backupName));
+    }
+
+    writeConfig(configData);
+    console.log('[ConfigService] 配置已导入');
+}
+
+/**
+ * API Key 脱敏
+ * "sk-1234567890abcdef" → "sk-****cdef"
+ */
+function maskApiKey(key: string): string {
+    if (!key || key.length <= 8) return '****';
+    return key.substring(0, 4) + '****' + key.substring(key.length - 4);
+}

package/src/session-key.ts

@@ -0,0 +1,30 @@
+const DIRECT_THREAD_KEY_RE = /^agent:([^:]+):wechat:direct:([^:]+):thread:([^:]+)$/i;
+
+export function sanitizeWeChatId(value: unknown, fallback: string): string {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized || fallback;
+}
+
+export function buildWeChatGatewaySessionKey(
+    userId: string,
+    sessionId: string,
+    agentId = 'main',
+    groupId?: string,
+): string {
+    const agent = sanitizeWeChatId(agentId, 'main');
+    if (groupId) {
+        return `agent:${agent}:wechat:group:${sanitizeWeChatId(groupId, 'unknown')}`;
+    }
+
+    return `agent:${agent}:wechat:direct:${sanitizeWeChatId(userId, 'unknown')}:thread:${sanitizeWeChatId(sessionId, 'unknown')}`;
+}
+
+export function parseWeChatDirectThreadSessionKey(key: string): { agentId: string; userId: string; sessionId: string } | null {
+    const match = String(key || '').trim().toLowerCase().match(DIRECT_THREAD_KEY_RE);
+    if (!match) return null;
+    return {
+        agentId: match[1],
+        userId: match[2],
+        sessionId: match[3],
+    };
+}