openclaw-vchat-plugin 0.0.1

package/dist/relay-server.js

@@ -0,0 +1,877 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelayServer = createRelayServer;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const multer_1 = __importDefault(require("multer"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const ws_1 = require("ws");
+const crypto_1 = require("crypto");
+const session_manager_1 = require("./session-manager");
+const message_handler_1 = require("./message-handler");
+const media_handler_1 = require("./media-handler");
+const group_manager_1 = require("./group-manager");
+const commands_1 = require("./commands");
+const constants_1 = require("./constants");
+const session_key_1 = require("./session-key");
+const config_routes_1 = __importDefault(require("./routes/config.routes"));
+function createRequestMemo(ttlMs) {
+    const inflight = new Map();
+    const cache = new Map();
+    return async function memoized(key, loader) {
+        const now = Date.now();
+        const cached = cache.get(key);
+        if (cached && cached.expiresAt > now) {
+            return cached.value;
+        }
+        const pending = inflight.get(key);
+        if (pending)
+            return pending;
+        const task = (async () => {
+            try {
+                const value = await loader();
+                cache.set(key, { value, expiresAt: Date.now() + ttlMs });
+                return value;
+            }
+            finally {
+                inflight.delete(key);
+            }
+        })();
+        inflight.set(key, task);
+        return task;
+    };
+}
+function toBridgeSessionPayload(item) {
+    const createdAt = Number(item.createdAt) || Date.now();
+    return {
+        id: String(item.id || '').trim(),
+        title: String(item.title || '').trim() || '新对话',
+        lastMessage: String(item.lastMessage || '').trim(),
+        lastMessageTime: Number(item.lastMessageTime) || createdAt,
+        createdAt,
+        agentId: String(item.agentId || '').trim() || 'main',
+    };
+}
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        if (value > 1000000000000)
+            return value;
+        if (value > 1000000000)
+            return value * 1000;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const n = Number(value);
+        if (Number.isFinite(n))
+            return parseTimestamp(n);
+        const d = Date.parse(value);
+        if (!Number.isNaN(d))
+            return d;
+    }
+    return 0;
+}
+function pickTimestamp(entry, fallback) {
+    return (parseTimestamp(entry?.lastMessageTime) ||
+        parseTimestamp(entry?.updatedAt) ||
+        parseTimestamp(entry?.lastActiveAt) ||
+        parseTimestamp(entry?.lastActivityAt) ||
+        parseTimestamp(entry?.timestamp) ||
+        parseTimestamp(entry?.createdAt) ||
+        fallback);
+}
+function normalizeMessageText(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (!raw || typeof raw !== 'object')
+        return '';
+    if (typeof raw.text === 'string')
+        return raw.text;
+    if (typeof raw.content === 'string')
+        return raw.content;
+    if (Array.isArray(raw.content)) {
+        return raw.content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (part?.type === 'text' && typeof part?.text === 'string')
+                return part.text;
+            if (typeof part?.text === 'string')
+                return part.text;
+            return '';
+        })
+            .filter(Boolean)
+            .join('');
+    }
+    if (raw.message)
+        return normalizeMessageText(raw.message);
+    return '';
+}
+function getHistoryRoleRaw(row) {
+    return String(row?.role || row?.author || row?.sender || row?.message?.role || row?.message?.author || '').trim().toLowerCase();
+}
+function isRenderableHistoryRole(roleRaw) {
+    if (!roleRaw)
+        return true;
+    return roleRaw === 'user' || roleRaw === 'assistant' || roleRaw === 'system';
+}
+function normalizePreviewMessageText(raw) {
+    if (!raw || typeof raw !== 'object')
+        return normalizeMessageText(raw);
+    const roleRaw = getHistoryRoleRaw(raw);
+    if (!isRenderableHistoryRole(roleRaw))
+        return '';
+    return normalizeMessageText(raw);
+}
+function normalizeHistoryMessages(rawPayload, sessionId, limit, before) {
+    const payload = rawPayload || {};
+    const rows = Array.isArray(payload.messages) ? payload.messages
+        : Array.isArray(payload.items) ? payload.items
+            : Array.isArray(payload.history) ? payload.history
+                : Array.isArray(payload.entries) ? payload.entries
+                    : [];
+    const mapped = rows.map((row) => {
+        const roleRaw = getHistoryRoleRaw(row) || 'assistant';
+        if (!isRenderableHistoryRole(roleRaw))
+            return null;
+        const role = roleRaw === 'user' ? 'user' : roleRaw === 'system' ? 'system' : 'assistant';
+        const typeRaw = String(row?.type || row?.message?.type || 'text').toLowerCase();
+        const type = typeRaw === 'voice' || typeRaw === 'image' || typeRaw === 'system' || typeRaw === 'command'
+            ? typeRaw
+            : 'text';
+        const timestamp = pickTimestamp(row, Date.now());
+        return {
+            id: String(row?.id || row?.messageId || (0, crypto_1.randomUUID)()),
+            sessionId,
+            role,
+            type,
+            content: normalizeMessageText(row),
+            mediaUrl: row?.mediaUrl || row?.media_url || row?.message?.mediaUrl || '',
+            duration: Number(row?.duration || row?.message?.duration) || undefined,
+            timestamp,
+        };
+    }).filter((m) => Boolean(m && (m.content || m.type !== 'text')));
+    const sorted = mapped.sort((a, b) => a.timestamp - b.timestamp);
+    const filtered = before ? sorted.filter((m) => m.timestamp < before) : sorted;
+    if (filtered.length <= limit)
+        return filtered;
+    return filtered.slice(filtered.length - limit);
+}
+async function listGatewayWechatSessions(gateway, userId, agentId) {
+    const targetUserId = (0, session_key_1.sanitizeWeChatId)(userId, 'unknown');
+    const targetAgentId = (0, session_key_1.sanitizeWeChatId)(agentId, '');
+    const response = await gateway.call('sessions.list', {});
+    const rawSessions = Array.isArray(response?.sessions) ? response.sessions : [];
+    const now = Date.now();
+    const rows = [];
+    for (const row of rawSessions) {
+        const key = String(row?.key || row?.sessionKey || row?.id || '').trim().toLowerCase();
+        if (!key)
+            continue;
+        const parsed = (0, session_key_1.parseWeChatDirectThreadSessionKey)(key);
+        if (!parsed)
+            continue;
+        if (parsed.userId !== targetUserId)
+            continue;
+        if (targetAgentId && parsed.agentId !== targetAgentId)
+            continue;
+        const lastMessage = normalizePreviewMessageText(row?.lastMessage || row?.preview || row?.summary || '');
+        const title = String(row?.title || row?.displayName || row?.name || '').trim();
+        const createdAt = parseTimestamp(row?.createdAt) || pickTimestamp(row, now);
+        const lastMessageTime = pickTimestamp(row, createdAt || now);
+        rows.push({
+            id: parsed.sessionId,
+            userId: targetUserId,
+            agentId: parsed.agentId,
+            gatewaySessionKey: key,
+            title: title || lastMessage || '新对话',
+            lastMessage,
+            lastMessageTime,
+            createdAt: createdAt || lastMessageTime || now,
+        });
+    }
+    return rows.sort((a, b) => b.lastMessageTime - a.lastMessageTime);
+}
+async function resolveGatewaySessionKey(gateway, userId, sessionId, agentId) {
+    const all = await listGatewayWechatSessions(gateway, userId);
+    const targetSessionId = (0, session_key_1.sanitizeWeChatId)(sessionId, '');
+    const targetAgent = (0, session_key_1.sanitizeWeChatId)(agentId, '');
+    const candidates = all.filter(item => item.id === targetSessionId);
+    if (candidates.length > 0) {
+        const exact = targetAgent ? candidates.find(c => c.agentId === targetAgent) : null;
+        const selected = exact || candidates[0];
+        return { key: selected.gatewaySessionKey, agentId: selected.agentId, found: true };
+    }
+    const fallbackAgent = targetAgent || 'main';
+    return {
+        key: (0, session_key_1.buildWeChatGatewaySessionKey)(userId, sessionId, fallbackAgent),
+        agentId: fallbackAgent,
+        found: false,
+    };
+}
+async function callGatewayHistory(gateway, key, sessionId, limit, before) {
+    const attempts = [
+        { sessionKey: key, limit, before },
+        { key, limit, before },
+        { sessionKey: key, limit },
+        { key, limit },
+    ];
+    let lastError = null;
+    for (const params of attempts) {
+        try {
+            const result = await gateway.call('chat.history', params);
+            const messages = normalizeHistoryMessages(result, sessionId, limit, before);
+            const hasMore = Boolean(result?.hasMore) || messages.length === limit;
+            return { messages, hasMore };
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw lastError || new Error('Gateway 历史查询失败');
+}
+async function callGatewayDeleteSession(gateway, key) {
+    try {
+        await gateway.call('sessions.delete', { key, deleteTranscript: true });
+        return;
+    }
+    catch {
+        await gateway.call('sessions.delete', { key });
+    }
+}
+function ensureBridgeSession(sessionManager, userId, sessionId, agentId, groupId) {
+    const normalizedAgentId = (0, session_key_1.sanitizeWeChatId)(agentId, 'main');
+    const existingSessionId = String(sessionId || '').trim();
+    if (existingSessionId) {
+        return sessionManager.ensureSessionBinding(userId, existingSessionId, normalizedAgentId, (0, session_key_1.buildWeChatGatewaySessionKey)(userId, existingSessionId, normalizedAgentId, groupId));
+    }
+    const created = sessionManager.createSession(userId, undefined, normalizedAgentId);
+    return sessionManager.ensureSessionBinding(userId, created.id, normalizedAgentId, (0, session_key_1.buildWeChatGatewaySessionKey)(userId, created.id, normalizedAgentId, groupId));
+}
+/**
+ * 内部中继服务器
+ * 仅接受来自 wechat-backend 的请求（通过 X-Internal-Secret 验证）
+ * 路由前缀: /internal/*
+ */
+function createRelayServer(config, gateway) {
+    const app = (0, express_1.default)();
+    const dataDir = path_1.default.join(config.uploadDir, '..');
+    const sessionManager = new session_manager_1.SessionManager(dataDir);
+    const messageHandler = new message_handler_1.MessageHandler(config, sessionManager, gateway);
+    const mediaHandler = new media_handler_1.MediaHandler(config);
+    const groupManager = new group_manager_1.GroupManager(dataDir);
+    const memoSessions = createRequestMemo(1000);
+    const memoGroups = createRequestMemo(1000);
+    const memoHistory = createRequestMemo(800);
+    // ===== 中间件 =====
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json({ limit: '10mb' }));
+    app.use(express_1.default.urlencoded({ extended: true, limit: '10mb' }));
+    app.use('/uploads', express_1.default.static(config.uploadDir));
+    const upload = (0, multer_1.default)({
+        storage: multer_1.default.memoryStorage(),
+        limits: { fileSize: config.maxFileSize },
+    });
+    // ===== 内部鉴权中间件 =====
+    function internalAuth(req, res, next) {
+        const secret = req.headers['x-internal-secret'];
+        if (!config.internalSecret || secret === config.internalSecret) {
+            next();
+        }
+        else {
+            res.status(403).json({ error: '内部通信密钥无效' });
+        }
+    }
+    function getRequestId(req) {
+        return String(req.headers['x-request-id'] || req.body?.requestId || req.query?.requestId || '').trim();
+    }
+    function logBridgeRequest(req, action, extra) {
+        const requestId = getRequestId(req);
+        const userId = String(req.body?.userId || req.query?.userId || req.userId || '').trim();
+        const sessionId = String(req.body?.sessionId || req.query?.sessionId || req.params?.id || '').trim();
+        const payload = {
+            requestId: requestId || '-',
+            action,
+            method: req.method,
+            path: req.path,
+            userId: userId || '-',
+            sessionId: sessionId || '-',
+            ...(extra || {}),
+        };
+        console.log('[BridgeHTTP]', JSON.stringify(payload));
+    }
+    // ===== 健康检查（无鉴权） =====
+    app.get('/internal/health', (_req, res) => {
+        res.json({
+            status: 'ok',
+            service: 'openclaw-wechat-plugin',
+            timestamp: Date.now(),
+            gateway: config.openclawGatewayUrl,
+        });
+    });
+    // ===== 所有内部路由需要密钥验证 =====
+    const internal = express_1.default.Router();
+    internal.use(internalAuth);
+    internal.get('/bridge/capabilities', (_req, res) => {
+        res.json({
+            protocolVersion: constants_1.BRIDGE_PROTOCOL_VERSION,
+            pluginVersion: constants_1.BRIDGE_PLUGIN_VERSION,
+            capabilities: Array.from(constants_1.BRIDGE_CAPABILITIES),
+            bridgeRole: 'gateway-bridge',
+            runtime: {
+                persistMessagesEnabled: sessionManager.isPersistMessagesEnabled(),
+                localFallbackEnabled: Boolean(config.allowLocalFallback),
+            },
+        });
+    });
+    // ===== 会话管理 =====
+    internal.get('/sessions', async (req, res) => {
+        logBridgeRequest(req, 'sessions.list');
+        const userId = String(req.query.userId || req.userId || '').trim();
+        const agentId = String(req.query.agentId || '').trim();
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        try {
+            const memoKey = `sessions:${userId}:${agentId || '*'}`;
+            const payload = await memoSessions(memoKey, async () => {
+                const fromGateway = await listGatewayWechatSessions(gateway, userId, agentId || undefined);
+                const normalizedAgentId = agentId ? (0, session_key_1.sanitizeWeChatId)(agentId, 'main') : undefined;
+                const sessions = fromGateway.map((item) => {
+                    const local = sessionManager.getSession(item.id, userId);
+                    sessionManager.upsertSession(userId, item.id, {
+                        createdAt: local?.createdAt || item.createdAt,
+                        agentId: item.agentId,
+                        gatewaySessionKey: item.gatewaySessionKey,
+                    });
+                    return toBridgeSessionPayload({
+                        id: item.id,
+                        title: item.title || '新对话',
+                        lastMessage: item.lastMessage || '',
+                        lastMessageTime: item.lastMessageTime || item.createdAt || Date.now(),
+                        createdAt: local?.createdAt || item.createdAt,
+                        agentId: item.agentId,
+                    });
+                }).sort((a, b) => b.lastMessageTime - a.lastMessageTime);
+                sessionManager.pruneSessions(userId, sessions.map(item => item.id), normalizedAgentId);
+                return {
+                    sessions,
+                    source: 'gateway',
+                };
+            });
+            res.json(payload);
+        }
+        catch (err) {
+            const gatewayError = err?.message || 'unknown';
+            console.error('[Sessions] Gateway 列表获取失败:', gatewayError);
+            if (!config.allowLocalFallback) {
+                res.status(502).json({
+                    error: 'Gateway 会话列表查询失败',
+                    source: 'gateway-error',
+                });
+                return;
+            }
+            console.warn('[Sessions] 已启用本地 fallback，返回本地元数据');
+            const local = sessionManager.getSessions(userId)
+                .filter(s => !agentId || s.agentId === (0, session_key_1.sanitizeWeChatId)(agentId, 'main'))
+                .map(item => toBridgeSessionPayload(item));
+            res.json({
+                sessions: local,
+                source: 'local-fallback',
+            });
+        }
+    });
+    internal.post('/sessions', (req, res) => {
+        logBridgeRequest(req, 'sessions.create', { agentId: String(req.body.agentId || 'main') });
+        const userId = String(req.body.userId || '').trim();
+        const agentId = String(req.body.agentId || 'main').trim() || 'main';
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        const session = ensureBridgeSession(sessionManager, userId, typeof req.body.sessionId === 'string' ? req.body.sessionId : '', agentId);
+        res.json(toBridgeSessionPayload({
+            ...session,
+            title: req.body.title || session.title,
+        }));
+    });
+    internal.delete('/sessions/:id', async (req, res) => {
+        logBridgeRequest(req, 'sessions.delete', { targetSessionId: String(req.params.id || '').trim() });
+        const userId = String(req.query.userId || req.body.userId || '').trim();
+        const agentId = String(req.query.agentId || req.body.agentId || '').trim();
+        const sessionId = String(req.params.id || '').trim();
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        if (!sessionId) {
+            res.status(400).json({ error: '缺少 sessionId' });
+            return;
+        }
+        let gatewayDeleted = true;
+        let matchedGatewaySessions = 0;
+        try {
+            const all = await listGatewayWechatSessions(gateway, userId);
+            const hit = all.filter(s => s.id === (0, session_key_1.sanitizeWeChatId)(sessionId, ''));
+            matchedGatewaySessions = hit.length;
+            if (hit.length > 0) {
+                for (const item of hit) {
+                    await callGatewayDeleteSession(gateway, item.gatewaySessionKey);
+                }
+            }
+            else {
+                const fallbackKey = (0, session_key_1.buildWeChatGatewaySessionKey)(userId, sessionId, agentId || 'main');
+                await callGatewayDeleteSession(gateway, fallbackKey);
+            }
+        }
+        catch (err) {
+            console.error('[Sessions] Gateway 删除失败:', err.message);
+            gatewayDeleted = false;
+        }
+        const localDeleted = sessionManager.deleteSession(sessionId, userId);
+        res.json({
+            ok: localDeleted && (gatewayDeleted || matchedGatewaySessions === 0),
+            sessionId,
+            localDeleted,
+            gatewayDeleted,
+        });
+    });
+    // ===== Agent REST API =====
+    const OPENCLAW_AGENTS_DIR = path_1.default.join(process.env.HOME || '/root', '.openclaw', 'agents');
+    internal.get('/agents', (_req, res) => {
+        try {
+            const agents = [];
+            if (fs_1.default.existsSync(OPENCLAW_AGENTS_DIR)) {
+                const dirs = fs_1.default.readdirSync(OPENCLAW_AGENTS_DIR, { withFileTypes: true });
+                for (const d of dirs) {
+                    if (!d.isDirectory())
+                        continue;
+                    const agentId = d.name;
+                    const identityFile = path_1.default.join(OPENCLAW_AGENTS_DIR, agentId, 'agent', 'identity.json');
+                    let identity = { name: agentId, emoji: '🤖' };
+                    try {
+                        if (fs_1.default.existsSync(identityFile)) {
+                            identity = { ...identity, ...JSON.parse(fs_1.default.readFileSync(identityFile, 'utf-8')) };
+                        }
+                    }
+                    catch { /* ignore */ }
+                    agents.push({ id: agentId, name: agentId, identity });
+                }
+            }
+            if (agents.length === 0) {
+                agents.push({ id: 'main', name: 'main', identity: { name: 'OpenClaw', emoji: '🤖' } });
+            }
+            res.json({ agents, defaultId: 'main' });
+        }
+        catch (err) {
+            res.json({ agents: [{ id: 'main', name: 'main', identity: { name: 'OpenClaw', emoji: '🤖' } }], defaultId: 'main' });
+        }
+    });
+    internal.get('/agents/:id/identity', (req, res) => {
+        const identityFile = path_1.default.join(OPENCLAW_AGENTS_DIR, req.params.id, 'agent', 'identity.json');
+        try {
+            if (fs_1.default.existsSync(identityFile)) {
+                res.json(JSON.parse(fs_1.default.readFileSync(identityFile, 'utf-8')));
+            }
+            else {
+                res.json({ name: req.params.id, emoji: '🤖' });
+            }
+        }
+        catch {
+            res.json({ name: req.params.id, emoji: '🤖' });
+        }
+    });
+    internal.post('/agents', (req, res) => {
+        try {
+            const { name, emoji } = req.body;
+            if (!name) {
+                res.status(400).json({ error: '缺少 name' });
+                return;
+            }
+            const agentDir = path_1.default.join(OPENCLAW_AGENTS_DIR, name, 'agent');
+            fs_1.default.mkdirSync(agentDir, { recursive: true });
+            if (emoji) {
+                fs_1.default.writeFileSync(path_1.default.join(agentDir, 'identity.json'), JSON.stringify({ name, emoji }, null, 2), 'utf-8');
+            }
+            res.json({ id: name, name, identity: { name, emoji: emoji || '🤖' } });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.put('/agents/:id', (req, res) => {
+        try {
+            const agentDir = path_1.default.join(OPENCLAW_AGENTS_DIR, req.params.id, 'agent');
+            const idFile = path_1.default.join(agentDir, 'identity.json');
+            let identity = { name: req.params.id, emoji: '🤖' };
+            try {
+                if (fs_1.default.existsSync(idFile))
+                    identity = JSON.parse(fs_1.default.readFileSync(idFile, 'utf-8'));
+            }
+            catch { }
+            Object.assign(identity, req.body);
+            fs_1.default.mkdirSync(agentDir, { recursive: true });
+            fs_1.default.writeFileSync(idFile, JSON.stringify(identity, null, 2), 'utf-8');
+            res.json({ id: req.params.id, identity });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.delete('/agents/:id', (req, res) => {
+        try {
+            const agentDir = path_1.default.join(OPENCLAW_AGENTS_DIR, req.params.id);
+            if (fs_1.default.existsSync(agentDir)) {
+                fs_1.default.rmSync(agentDir, { recursive: true, force: true });
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // Agent 文件管理
+    internal.get('/agents/:id/files', async (req, res) => {
+        try {
+            const result = await gateway.getAgentFiles(req.params.id);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.get('/agents/:id/files/:filename', async (req, res) => {
+        try {
+            const result = await gateway.getAgentFile(req.params.id, req.params.filename);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.put('/agents/:id/files/:filename', async (req, res) => {
+        try {
+            const { content } = req.body;
+            await gateway.setAgentFile(req.params.id, req.params.filename, content);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ===== Group API =====
+    internal.get('/groups', (_req, res) => {
+        memoGroups('groups:list', async () => ({ groups: groupManager.list() }))
+            .then(payload => res.json(payload))
+            .catch((err) => res.status(500).json({ error: err?.message || '群列表获取失败' }));
+    });
+    internal.post('/groups', (req, res) => {
+        const { name, emoji, agentIds, mode } = req.body;
+        if (!name) {
+            res.status(400).json({ error: '缺少群名称' });
+            return;
+        }
+        const group = groupManager.create(name, emoji, agentIds, mode);
+        res.json(group);
+    });
+    internal.put('/groups/:id', (req, res) => {
+        const group = groupManager.update(req.params.id, req.body);
+        group ? res.json(group) : res.status(404).json({ error: '群不存在' });
+    });
+    internal.delete('/groups/:id', (req, res) => {
+        groupManager.delete(req.params.id)
+            ? res.json({ ok: true })
+            : res.status(404).json({ error: '群不存在' });
+    });
+    internal.post('/groups/:id/agents', (req, res) => {
+        const { agentId } = req.body;
+        if (!agentId) {
+            res.status(400).json({ error: '缺少 agentId' });
+            return;
+        }
+        const group = groupManager.addAgent(req.params.id, agentId);
+        group ? res.json(group) : res.status(404).json({ error: '群不存在' });
+    });
+    internal.delete('/groups/:id/agents/:agentId', (req, res) => {
+        const group = groupManager.removeAgent(req.params.id, req.params.agentId);
+        group ? res.json(group) : res.status(404).json({ error: '群不存在' });
+    });
+    // ===== 聊天 =====
+    internal.get('/chat/history', async (req, res) => {
+        logBridgeRequest(req, 'chat.history');
+        const userId = String(req.query.userId || '').trim();
+        const sessionId = String(req.query.sessionId || '').trim();
+        const agentId = String(req.query.agentId || '').trim();
+        const limit = parseInt(req.query.limit) || 50;
+        const before = req.query.before ? parseInt(req.query.before) : undefined;
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        if (!sessionId) {
+            res.status(400).json({ error: '缺少 sessionId' });
+            return;
+        }
+        try {
+            const memoKey = `history:${userId}:${agentId || '*'}:${sessionId}:${limit}:${before || 0}`;
+            const payload = await memoHistory(memoKey, async () => {
+                const resolved = await resolveGatewaySessionKey(gateway, userId, sessionId, agentId || undefined);
+                if (!resolved.found) {
+                    sessionManager.deleteSession(sessionId, userId);
+                    sessionManager.clearMessages(sessionId);
+                    return {
+                        messages: [],
+                        hasMore: false,
+                        source: 'gateway',
+                        sessionMissing: true,
+                    };
+                }
+                sessionManager.upsertSession(userId, sessionId, {
+                    agentId: resolved.agentId,
+                    gatewaySessionKey: resolved.key,
+                });
+                const { messages, hasMore } = await callGatewayHistory(gateway, resolved.key, sessionId, limit, before);
+                if (messages.length === 0) {
+                    sessionManager.clearMessages(sessionId);
+                }
+                return { messages, hasMore, source: 'gateway', sessionMissing: false };
+            });
+            res.json(payload);
+            return;
+        }
+        catch (err) {
+            const gatewayError = err?.message || 'unknown';
+            console.error('[History] Gateway 查询失败:', gatewayError);
+            if (!config.allowLocalFallback) {
+                res.status(502).json({
+                    error: 'Gateway 历史查询失败',
+                    source: 'gateway-error',
+                    sessionMissing: false,
+                });
+                return;
+            }
+            console.warn('[History] 已启用本地 fallback，返回本地缓存');
+        }
+        const messages = sessionManager.getMessages(sessionId, limit, before);
+        res.json({
+            messages,
+            hasMore: messages.length === limit,
+            source: 'local-fallback',
+            sessionMissing: false,
+        });
+    });
+    internal.post('/chat/send', async (req, res) => {
+        logBridgeRequest(req, 'chat.send', {
+            route: typeof req.body.commandRoute === 'string' ? req.body.commandRoute : '-',
+            routeSource: typeof req.body.routeSource === 'string' ? req.body.routeSource : '-',
+        });
+        const userId = req.body.userId;
+        const { sessionId, content } = req.body;
+        const agentId = String(req.body.agentId || 'main');
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        if (!content) {
+            res.status(400).json({ error: '消息内容不能为空' });
+            return;
+        }
+        try {
+            const session = ensureBridgeSession(sessionManager, userId, sessionId, agentId);
+            const sid = session.id;
+            const result = await messageHandler.handleMessage(userId, sid, content, 'text', undefined, undefined, agentId, undefined, {
+                commandRoute: typeof req.body.commandRoute === 'string' ? req.body.commandRoute : undefined,
+                routeSource: typeof req.body.routeSource === 'string' ? req.body.routeSource : undefined,
+                requestId: typeof req.body.requestId === 'string' ? req.body.requestId : undefined,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            console.error('[Chat] 发送消息失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.post('/chat/send-voice', upload.single('voice'), async (req, res) => {
+        logBridgeRequest(req, 'chat.send-voice');
+        const userId = req.body.userId;
+        const { sessionId } = req.body;
+        const agentId = String(req.body.agentId || 'main');
+        const duration = parseFloat(req.body.duration) || 0;
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        if (!req.file) {
+            res.status(400).json({ error: '没有上传语音文件' });
+            return;
+        }
+        try {
+            const { url } = mediaHandler.saveVoice(req.file.buffer, req.file.originalname);
+            const session = ensureBridgeSession(sessionManager, userId, sessionId, agentId);
+            const sid = session.id;
+            const textContent = req.body.text || '[语音消息]';
+            const result = await messageHandler.handleMessage(userId, sid, textContent, 'voice', url, duration, agentId);
+            res.json(result);
+        }
+        catch (err) {
+            console.error('[Chat] 语音消息失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.post('/chat/send-image', upload.single('image'), async (req, res) => {
+        logBridgeRequest(req, 'chat.send-image');
+        const userId = req.body.userId;
+        const { sessionId } = req.body;
+        const agentId = String(req.body.agentId || 'main');
+        if (!userId) {
+            res.status(400).json({ error: '缺少 userId' });
+            return;
+        }
+        if (!req.file) {
+            res.status(400).json({ error: '没有上传图片文件' });
+            return;
+        }
+        try {
+            const { url } = mediaHandler.saveImage(req.file.buffer, req.file.originalname);
+            const session = ensureBridgeSession(sessionManager, userId, sessionId, agentId);
+            const sid = session.id;
+            const userMessage = sessionManager.addMessage(sid, 'user', 'image', req.body.description || '请查看这张图片', url);
+            res.json({ userMessage, mediaUrl: url, sessionId: sid });
+        }
+        catch (err) {
+            console.error('[Chat] 图片上传失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    internal.get('/commands', (_req, res) => {
+        res.json({ commands: commands_1.BOT_COMMANDS });
+    });
+    // 配置路由
+    internal.use('/config', config_routes_1.default);
+    app.use('/internal', internal);
+    // ===== WebSocket 服务 =====
+    const server = http_1.default.createServer(app);
+    const wss = new ws_1.WebSocketServer({ server, path: '/internal/ws' });
+    const heartbeatInterval = setInterval(() => {
+        wss.clients.forEach((ws) => {
+            if (ws.isAlive === false)
+                return ws.terminate();
+            ws.isAlive = false;
+            ws.ping();
+        });
+    }, 30000);
+    wss.on('close', () => clearInterval(heartbeatInterval));
+    wss.on('connection', (ws, req) => {
+        const wsAny = ws;
+        wsAny.isAlive = true;
+        wsAny.abortCurrent = null;
+        // 从后端代理传来的 header 获取 userId 和密钥验证
+        const secret = req.headers['x-internal-secret'];
+        const userId = req.headers['x-user-id'];
+        if (config.internalSecret && secret !== config.internalSecret) {
+            ws.close(4003, '内部通信密钥无效');
+            return;
+        }
+        wsAny.authenticated = true;
+        wsAny.userId = userId;
+        console.log(`[WS] 内部连接: userId=${userId}`);
+        ws.on('pong', () => { wsAny.isAlive = true; });
+        ws.on('message', (raw) => {
+            wsAny.isAlive = true;
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch {
+                wsSend(ws, { type: 'error', message: '无效的 JSON' });
+                return;
+            }
+            // userId 来自消息或 header
+            if (msg.userId)
+                wsAny.userId = msg.userId;
+            switch (msg.type) {
+                case 'chat':
+                    handleWsChat(ws, msg, messageHandler, sessionManager);
+                    break;
+                case 'stop':
+                    if (wsAny.abortCurrent) {
+                        wsAny.abortCurrent();
+                        wsAny.abortCurrent = null;
+                        wsSend(ws, { type: 'stopped' });
+                    }
+                    break;
+                case 'ping':
+                    wsSend(ws, { type: 'pong' });
+                    break;
+                default:
+                    wsSend(ws, { type: 'error', message: `未知消息类型: ${msg.type}` });
+            }
+        });
+        ws.on('close', () => {
+            if (wsAny.abortCurrent) {
+                wsAny.abortCurrent();
+                wsAny.abortCurrent = null;
+            }
+        });
+        ws.on('error', (err) => {
+            console.error('[WS] 错误:', err.message);
+        });
+    });
+    return { app, server, sessionManager, wss };
+}
+// ===== WebSocket 处理函数 =====
+function wsSend(ws, data) {
+    if (ws.readyState === ws_1.WebSocket.OPEN) {
+        ws.send(JSON.stringify(data));
+    }
+}
+async function handleWsChat(ws, msg, messageHandler, sessionManager) {
+    const wsAny = ws;
+    if (!wsAny.authenticated || !wsAny.userId) {
+        wsSend(ws, { type: 'error', message: '未认证' });
+        return;
+    }
+    const { sessionId, content, messageType, agentId, groupId, mediaUrl } = msg;
+    if (!content) {
+        wsSend(ws, { type: 'error', message: '消息内容不能为空' });
+        return;
+    }
+    const userId = wsAny.userId;
+    const selectedAgentId = String(agentId || 'main');
+    const session = ensureBridgeSession(sessionManager, userId, sessionId, selectedAgentId, groupId);
+    const sid = session.id;
+    const type = messageType || 'text';
+    if (wsAny.abortCurrent) {
+        wsAny.abortCurrent();
+    }
+    wsSend(ws, { type: 'start', sessionId: sid, agentId: selectedAgentId });
+    const abort = messageHandler.handleMessageStream(userId, sid, content, type, {
+        onThinking: (text) => {
+            wsSend(ws, { type: 'thinking', text, agentId: selectedAgentId });
+        },
+        onChunk: (text) => {
+            wsSend(ws, { type: 'chunk', text, agentId: selectedAgentId });
+        },
+        onDone: (userMessage, assistantMessage) => {
+            wsAny.abortCurrent = null;
+            wsSend(ws, {
+                type: 'done', userMessage, assistantMessage,
+                sessionId: sid, agentId: selectedAgentId
+            });
+        },
+        onError: (error) => {
+            wsAny.abortCurrent = null;
+            wsSend(ws, { type: 'error', message: error, agentId: selectedAgentId });
+        },
+    }, selectedAgentId, mediaUrl, undefined, groupId, {
+        commandRoute: typeof msg.commandRoute === 'string' ? msg.commandRoute : undefined,
+        routeSource: typeof msg.routeSource === 'string' ? msg.routeSource : undefined,
+        requestId: typeof msg.requestId === 'string' ? msg.requestId : undefined,
+    });
+    wsAny.abortCurrent = abort;
+}
+//# sourceMappingURL=relay-server.js.map