openclaw-vchat-plugin 0.0.1

package/src/gateway-client.ts

@@ -0,0 +1,648 @@
+import WebSocket from 'ws';
+import { randomUUID } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+
+const PROTOCOL_VERSION = 3;
+const DEFAULT_GATEWAY_URL = 'ws://127.0.0.1:18789';
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(process.env.HOME || '/root', '.openclaw');
+const OPENCLAW_CONFIG = process.env.OPENCLAW_CONFIG || path.join(OPENCLAW_HOME, 'openclaw.json');
+
+function normalizeGatewayUrl(url?: string): string {
+    const raw = (url || '').trim();
+    if (!raw) return DEFAULT_GATEWAY_URL;
+    if (raw.startsWith('ws://') || raw.startsWith('wss://')) return raw;
+    if (raw.startsWith('http://') || raw.startsWith('https://')) {
+        return raw.replace(/^http:/, 'ws:').replace(/^https:/, 'wss:');
+    }
+    return raw;
+}
+
+function readGatewayTokenFromConfig(): string {
+    try {
+        const cfg = JSON.parse(fs.readFileSync(OPENCLAW_CONFIG, 'utf-8'));
+        return cfg?.gateway?.auth?.token || '';
+    } catch {
+        return '';
+    }
+}
+
+function getGatewayMessageRole(message: any): string {
+    if (!message || typeof message !== 'object') return '';
+    return String(message.role || message.author || message.sender || '')
+        .trim()
+        .toLowerCase();
+}
+
+function isRenderableGatewayMessage(message: any): boolean {
+    const role = getGatewayMessageRole(message);
+    if (!role) return true;
+    return role === 'assistant' || role === 'system';
+}
+
+function extractTextFromChatMessage(message: any): string {
+    if (!message || typeof message !== 'object') return '';
+    if (!isRenderableGatewayMessage(message)) return '';
+    const content = Array.isArray(message.content) ? message.content : [];
+    return content
+        .map((item: any) => {
+            if (typeof item === 'string') return item;
+            const type = String(item?.type || '').trim().toLowerCase();
+            if (type && type !== 'text') return '';
+            return typeof item?.text === 'string' ? item.text : '';
+        })
+        .filter(Boolean)
+        .join('');
+}
+
+export interface GatewayStreamCallbacks {
+    onThinking?: (text: string) => void;
+    onChunk?: (delta: string) => void;
+    onDone?: (fullText: string) => void;
+    onError?: (error: string) => void;
+}
+
+export interface StreamAgentOpts {
+    groupId?: string;
+    groupChannel?: string;
+    attachments?: any[];
+    sessionKey?: string;
+}
+
+export interface StreamChatOpts {
+    sessionKey: string;
+    attachments?: any[];
+    thinking?: string;
+}
+
+export class GatewayClient {
+    private url: string;
+    private token: string;
+
+    constructor(url?: string, token?: string) {
+        this.url = normalizeGatewayUrl(url || process.env.OPENCLAW_GATEWAY_URL || DEFAULT_GATEWAY_URL);
+        this.token = (token || process.env.OPENCLAW_AUTH_TOKEN || readGatewayTokenFromConfig() || '').trim();
+    }
+
+    private buildConnectRequest() {
+        const params: any = {
+            minProtocol: PROTOCOL_VERSION,
+            maxProtocol: PROTOCOL_VERSION,
+            role: 'operator',
+            scopes: ['operator.admin', 'operator.read', 'operator.write'],
+            client: {
+                id: 'gateway-client',
+                displayName: 'openclaw-wechat-plugin',
+                version: '1.0.0',
+                platform: process.platform,
+                mode: 'backend',
+                instanceId: randomUUID(),
+            },
+            caps: [],
+        };
+        if (this.token) {
+            params.auth = { token: this.token };
+        }
+        return {
+            type: 'req',
+            id: randomUUID(),
+            method: 'connect',
+            params,
+        };
+    }
+
+    // ========== Gateway WS call() ==========
+
+    async call(method: string, params: any = {}): Promise<any> {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.url);
+            let connected = false;
+            const reqId = randomUUID();
+
+            const timeout = setTimeout(() => {
+                console.error(`[GW call] TIMEOUT method=${method} connected=${connected}`);
+                ws.close();
+                reject(new Error('Gateway 调用超时'));
+            }, 15000);
+
+            ws.on('open', () => console.log(`[GW call] opened for ${method}`));
+
+            ws.on('message', (data: Buffer) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+
+                    if (msg.type === 'event' && msg.event === 'connect.challenge') {
+                        ws.send(JSON.stringify(this.buildConnectRequest()));
+                        return;
+                    }
+
+                    if (msg.type === 'res' && !connected) {
+                        if (msg.ok) {
+                            connected = true;
+                            ws.send(JSON.stringify({ type: 'req', id: reqId, method, params }));
+                        } else {
+                            clearTimeout(timeout);
+                            ws.close();
+                            reject(new Error(msg.error?.message || 'Gateway 认证失败'));
+                        }
+                        return;
+                    }
+
+                    if (msg.type === 'res' && msg.id === reqId) {
+                        clearTimeout(timeout);
+                        ws.close();
+                        if (msg.ok) resolve(msg.payload);
+                        else reject(new Error(msg.error?.message || 'Gateway 错误'));
+                        return;
+                    }
+                } catch (err) {
+                    clearTimeout(timeout);
+                    ws.close();
+                    reject(err);
+                }
+            });
+
+            ws.on('error', (err: Error) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+
+    // ========== streamAgent() ==========
+
+    streamAgent(
+        message: string,
+        agentId: string = 'main',
+        callbacks: GatewayStreamCallbacks,
+        opts?: StreamAgentOpts
+    ): () => void {
+        const ws = new WebSocket(this.url);
+        const reqId = randomUUID();
+        let gwConnected = false;
+        let done = false;
+        let manualAbort = false;
+        let fullText = '';
+        let runId = '';
+        let sessionKey = (opts?.sessionKey || '').trim().toLowerCase();
+
+        // 活动超时：10 分钟内无任何消息才超时（每次收到消息重置）
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const INACTIVITY_MS = 600000;
+
+        const clearActivityTimer = () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        };
+
+        const resetActivityTimer = () => {
+            clearActivityTimer();
+            timer = setTimeout(() => {
+                if (done) return;
+                finishError('AI 回复超时（10分钟无活动）');
+            }, INACTIVITY_MS);
+        };
+
+        const finishDone = (text: string) => {
+            if (done) return;
+            done = true;
+            clearActivityTimer();
+            callbacks.onDone?.(text);
+            ws.close();
+        };
+
+        const finishError = (error: string) => {
+            if (done) return;
+            done = true;
+            clearActivityTimer();
+            if (!manualAbort) callbacks.onError?.(error);
+            ws.close();
+        };
+
+        const applyDelta = (nextText: string) => {
+            const next = nextText || '';
+            if (!next) return;
+            const delta = next.startsWith(fullText) ? next.slice(fullText.length) : next;
+            fullText = next;
+            if (delta) callbacks.onChunk?.(delta);
+        };
+
+        resetActivityTimer();
+
+        ws.on('open', () => {
+            console.log(`[GW stream] connected (agent=${agentId})`);
+        });
+
+        ws.on('message', (data: Buffer) => {
+            if (done) return;
+            try {
+                const msg = JSON.parse(data.toString());
+
+                if (msg.type === 'event' && msg.event === 'connect.challenge') {
+                    ws.send(JSON.stringify(this.buildConnectRequest()));
+                    return;
+                }
+
+                if (msg.type === 'res' && !gwConnected) {
+                    if (!msg.ok) {
+                        finishError(msg.error?.message || 'Gateway 认证失败');
+                        return;
+                    }
+                    gwConnected = true;
+                    callbacks.onThinking?.('正在思考...');
+                    const agentParams: any = {
+                        message,
+                        agentId,
+                        idempotencyKey: randomUUID(),
+                    };
+                    if (sessionKey) agentParams.sessionKey = sessionKey;
+                    if (opts?.groupId) {
+                        agentParams.groupId = opts.groupId;
+                        agentParams.groupChannel = opts.groupChannel || 'wechat';
+                    }
+                    if (opts?.attachments && opts.attachments.length > 0) {
+                        agentParams.attachments = opts.attachments;
+                    }
+                    ws.send(JSON.stringify({ type: 'req', id: reqId, method: 'agent', params: agentParams }));
+                    return;
+                }
+
+                if (msg.type === 'event' && msg.event === 'agent') {
+                    resetActivityTimer();
+                    const payload = msg.payload || {};
+                    if (payload.runId && !runId) runId = String(payload.runId);
+                    if (payload.sessionKey) sessionKey = String(payload.sessionKey).toLowerCase();
+                    if (payload.stream === 'assistant') {
+                        const text = typeof payload?.data?.text === 'string' ? payload.data.text : '';
+                        const delta = typeof payload?.data?.delta === 'string' ? payload.data.delta : '';
+                        if (text) applyDelta(text);
+                        else if (delta) {
+                            fullText += delta;
+                            callbacks.onChunk?.(delta);
+                        }
+                    }
+                    return;
+                }
+
+                if (msg.type === 'event' && msg.event === 'chat') {
+                    resetActivityTimer();
+                    const payload = msg.payload || {};
+                    if (payload.runId && runId && payload.runId !== runId) return;
+                    if (payload.sessionKey) sessionKey = String(payload.sessionKey).toLowerCase();
+                    const state = payload.state;
+                    const messageRole = getGatewayMessageRole(payload.message) || '-';
+                    const renderable = isRenderableGatewayMessage(payload.message);
+                    const messageText = extractTextFromChatMessage(payload.message);
+
+                    if (!renderable && (state === 'delta' || state === 'final')) {
+                        console.log(`[GW stream] skip chat message role=${messageRole} state=${state} requestId=${reqId} runId=${runId || payload.runId || '-'} sessionKey=${sessionKey || '-'}`);
+                        return;
+                    }
+
+                    if (state === 'delta') {
+                        if (messageText) applyDelta(messageText);
+                        return;
+                    }
+                    if (state === 'final') {
+                        if (messageText) fullText = messageText;
+                        console.log(`[GW stream] chat.final requestId=${reqId} runId=${runId || payload.runId || '-'} sessionKey=${sessionKey || '-'}`);
+                        const finalText = fullText.trim();
+                        if (finalText) finishDone(finalText);
+                        else finishError('AI 返回了空内容');
+                        return;
+                    }
+                    if (state === 'aborted') {
+                        console.log(`[GW stream] chat.aborted requestId=${reqId} runId=${runId || payload.runId || '-'} sessionKey=${sessionKey || '-'}`);
+                        finishError('会话已中断');
+                        return;
+                    }
+                    if (state === 'error') {
+                        console.log(`[GW stream] chat.error requestId=${reqId} runId=${runId || payload.runId || '-'} sessionKey=${sessionKey || '-'}`);
+                        finishError(payload.errorMessage || '会话执行失败');
+                        return;
+                    }
+                }
+
+                if (msg.type === 'res' && msg.id === reqId) {
+                    if (msg.ok && msg.payload?.status === 'accepted') {
+                        runId = msg.payload?.runId || runId;
+                        console.log(`[GW stream] accepted requestId=${reqId} runId=${runId} sessionKey=${sessionKey || '-'}`);
+                        return;
+                    }
+                    if (msg.ok && msg.payload?.status === 'ok') {
+                        if (!fullText && msg.payload?.result?.payloads?.[0]?.text) {
+                            fullText = msg.payload.result.payloads[0].text;
+                        }
+                        console.log(`[GW stream] completed requestId=${reqId} runId=${runId} sessionKey=${sessionKey || '-'}`);
+                        const finalText = fullText.trim();
+                        if (finalText) finishDone(finalText);
+                        else finishError('AI 返回了空内容');
+                        return;
+                    }
+                    if (msg.ok && msg.payload?.status === 'aborted') {
+                        console.log(`[GW stream] aborted requestId=${reqId} runId=${runId} sessionKey=${sessionKey || '-'}`);
+                        finishError('会话已中断');
+                        return;
+                    }
+                    if (!msg.ok) {
+                        finishError(msg.error?.message || '未知错误');
+                        return;
+                    }
+                }
+            } catch (err) {
+                console.error('[GW stream] parse error:', err);
+            }
+        });
+
+        ws.on('error', (err: Error) => {
+            finishError(`Gateway 连接失败: ${err.message}`);
+        });
+
+        ws.on('close', () => {
+            clearActivityTimer();
+            if (!done && !manualAbort) {
+                finishError('Gateway 连接已关闭');
+            }
+        });
+
+        return () => {
+            if (done) return;
+            manualAbort = true;
+            done = true;
+            clearActivityTimer();
+            try {
+                if (gwConnected && sessionKey && ws.readyState === WebSocket.OPEN) {
+                    const abortParams: any = { sessionKey };
+                    if (runId) abortParams.runId = runId;
+                    ws.send(JSON.stringify({
+                        type: 'req',
+                        id: randomUUID(),
+                        method: 'chat.abort',
+                        params: abortParams,
+                    }));
+                }
+            } catch {
+                // ignore
+            }
+            ws.close();
+        };
+    }
+
+    // ========== streamChatSend() ==========
+
+    streamChatSend(
+        message: string,
+        callbacks: GatewayStreamCallbacks,
+        opts: StreamChatOpts
+    ): () => void {
+        const ws = new WebSocket(this.url);
+        const reqId = randomUUID();
+        let gwConnected = false;
+        let done = false;
+        let manualAbort = false;
+        let fullText = '';
+        let runId = '';
+        const sessionKey = String(opts?.sessionKey || '').trim().toLowerCase();
+
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const INACTIVITY_MS = 600000;
+
+        const clearActivityTimer = () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        };
+
+        const resetActivityTimer = () => {
+            clearActivityTimer();
+            timer = setTimeout(() => {
+                if (done) return;
+                finishError('命令执行超时（10分钟无活动）');
+            }, INACTIVITY_MS);
+        };
+
+        const finishDone = (text: string) => {
+            if (done) return;
+            done = true;
+            clearActivityTimer();
+            callbacks.onDone?.(text);
+            ws.close();
+        };
+
+        const finishError = (error: string) => {
+            if (done) return;
+            done = true;
+            clearActivityTimer();
+            if (!manualAbort) callbacks.onError?.(error);
+            ws.close();
+        };
+
+        const applyDelta = (nextText: string) => {
+            const next = nextText || '';
+            if (!next) return;
+            const delta = next.startsWith(fullText) ? next.slice(fullText.length) : next;
+            fullText = next;
+            if (delta) callbacks.onChunk?.(delta);
+        };
+
+        resetActivityTimer();
+
+        ws.on('open', () => {
+            console.log(`[GW chat.send] connected session=${sessionKey || '-'}`);
+        });
+
+        ws.on('message', (data: Buffer) => {
+            if (done) return;
+            try {
+                const msg = JSON.parse(data.toString());
+
+                if (msg.type === 'event' && msg.event === 'connect.challenge') {
+                    ws.send(JSON.stringify(this.buildConnectRequest()));
+                    return;
+                }
+
+                if (msg.type === 'res' && !gwConnected) {
+                    if (!msg.ok) {
+                        finishError(msg.error?.message || 'Gateway 认证失败');
+                        return;
+                    }
+                    gwConnected = true;
+                    callbacks.onThinking?.('正在处理命令...');
+                    const params: any = {
+                        sessionKey: sessionKey || 'main',
+                        message,
+                        idempotencyKey: randomUUID(),
+                        deliver: false,
+                    };
+                    if (opts?.thinking) params.thinking = opts.thinking;
+                    if (opts?.attachments && opts.attachments.length > 0) params.attachments = opts.attachments;
+                    ws.send(JSON.stringify({ type: 'req', id: reqId, method: 'chat.send', params }));
+                    return;
+                }
+
+                if (msg.type === 'res' && msg.id === reqId) {
+                    if (!msg.ok) {
+                        finishError(msg.error?.message || '命令执行失败');
+                        return;
+                    }
+                    const status = String(msg.payload?.status || '').toLowerCase();
+                    if (msg.payload?.runId) runId = String(msg.payload.runId);
+                    console.log(`[GW chat.send] ack status=${status || '-'} runId=${runId || '-'} session=${sessionKey || '-'}`);
+                    if (status === 'ok' && !runId) {
+                        const finalText = fullText.trim();
+                        if (finalText) finishDone(finalText);
+                        else finishDone('✅ 命令已执行');
+                    }
+                    return;
+                }
+
+                if (msg.type === 'event' && msg.event === 'chat') {
+                    resetActivityTimer();
+                    const payload = msg.payload || {};
+                    if (payload.sessionKey) {
+                        const eventSession = String(payload.sessionKey).toLowerCase();
+                        if (sessionKey && eventSession !== sessionKey) return;
+                    }
+                    if (payload.runId && runId && payload.runId !== runId) return;
+                    if (!runId && payload.runId) runId = String(payload.runId);
+
+                    const state = payload.state;
+                    const messageRole = getGatewayMessageRole(payload.message) || '-';
+                    const renderable = isRenderableGatewayMessage(payload.message);
+                    const messageText = extractTextFromChatMessage(payload.message);
+
+                    if (!renderable && (state === 'delta' || state === 'final')) {
+                        console.log(`[GW chat.send] skip chat message role=${messageRole} state=${state} runId=${runId || payload.runId || '-'} session=${sessionKey || '-'}`);
+                        return;
+                    }
+
+                    if (state === 'delta') {
+                        if (messageText) applyDelta(messageText);
+                        return;
+                    }
+                    if (state === 'final') {
+                        if (messageText) fullText = messageText;
+                        const finalText = fullText.trim();
+                        if (finalText) finishDone(finalText);
+                        else finishDone('✅ 命令已执行');
+                        return;
+                    }
+                    if (state === 'aborted') {
+                        finishError('命令执行已中断');
+                        return;
+                    }
+                    if (state === 'error') {
+                        finishError(payload.errorMessage || '命令执行失败');
+                        return;
+                    }
+                }
+            } catch (err) {
+                console.error('[GW chat.send] parse error:', err);
+            }
+        });
+
+        ws.on('error', (err: Error) => {
+            finishError(`Gateway 连接失败: ${err.message}`);
+        });
+
+        ws.on('close', () => {
+            clearActivityTimer();
+            if (!done && !manualAbort) {
+                finishError('Gateway 连接已关闭');
+            }
+        });
+
+        return () => {
+            if (done) return;
+            manualAbort = true;
+            done = true;
+            clearActivityTimer();
+            try {
+                if (gwConnected && sessionKey && ws.readyState === WebSocket.OPEN) {
+                    const abortParams: any = { sessionKey };
+                    if (runId) abortParams.runId = runId;
+                    ws.send(JSON.stringify({
+                        type: 'req',
+                        id: randomUUID(),
+                        method: 'chat.abort',
+                        params: abortParams,
+                    }));
+                }
+            } catch {
+                // ignore
+            }
+            ws.close();
+        };
+    }
+
+    // ========== 本地配置读写 ==========
+
+    readConfig(): any {
+        try {
+            return JSON.parse(fs.readFileSync(OPENCLAW_CONFIG, 'utf-8'));
+        } catch {
+            return {};
+        }
+    }
+
+    async patchConfigLocal(patches: Array<{ path: string; value: any }>): Promise<void> {
+        const cfg = this.readConfig();
+        for (const { path: p, value } of patches) {
+            const parts = p.split('.');
+            let target = cfg;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (target[parts[i]] === undefined) target[parts[i]] = {};
+                target = target[parts[i]];
+            }
+            target[parts[parts.length - 1]] = value;
+        }
+        const tmp = OPENCLAW_CONFIG + '.tmp';
+        fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+        fs.renameSync(tmp, OPENCLAW_CONFIG);
+    }
+
+    // ========== 本地 Agent 文件操作 ==========
+
+    async listAgentsLocal() {
+        const agentsDir = path.join(OPENCLAW_HOME, 'agents');
+        const agents: any[] = [];
+        try {
+            if (fs.existsSync(agentsDir)) {
+                for (const d of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+                    if (d.isDirectory()) agents.push({ id: d.name, name: d.name });
+                }
+            }
+        } catch {
+            // silent
+        }
+        if (agents.length === 0) agents.push({ id: 'main', name: 'main' });
+        return { agents };
+    }
+
+    async getAgentFiles(agentId: string) {
+        const dir = path.join(OPENCLAW_HOME, 'agents', agentId, 'agent');
+        try {
+            return { files: fs.existsSync(dir) ? fs.readdirSync(dir) : [] };
+        } catch {
+            return { files: [] };
+        }
+    }
+
+    async getAgentFile(agentId: string, filename: string) {
+        const fp = path.join(OPENCLAW_HOME, 'agents', agentId, 'agent', filename);
+        try {
+            return { filename, content: fs.readFileSync(fp, 'utf-8') };
+        } catch {
+            return { filename, content: '' };
+        }
+    }
+
+    async setAgentFile(agentId: string, filename: string, content: string) {
+        const dir = path.join(OPENCLAW_HOME, 'agents', agentId, 'agent');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, filename), content, 'utf-8');
+    }
+}