claw_messenger 1.0.0

package/dist/openclaw-client.d.ts

@@ -0,0 +1,41 @@
+export interface OpenClawMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
+}
+export interface Logger {
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+}
+export declare function getOpenClawEnv(baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare class OpenClawClient {
+    static maxConcurrency: number;
+    static runningCount: number;
+    static waitQueue: Array<() => void>;
+    static conversationHistory: Map<string, OpenClawMessage[]>;
+    static maxHistoryRounds: number;
+    static maxMessageLength: number;
+    static activeRequests: Map<string, AbortController>;
+    private gatewayStarting;
+    private gatewayStarted;
+    private gatewayUrl;
+    private log;
+    constructor(gatewayUrl?: string, log?: Logger);
+    static acquireSlot(): Promise<void>;
+    static releaseSlot(): void;
+    ensureGatewayRunning(): Promise<boolean>;
+    private _getConversationHistory;
+    private _addToHistory;
+    clearHistory(fromUser: string): void;
+    private _buildMessagesWithHistory;
+    cancelActiveRequest(fromUser: string): boolean;
+    chatStream(message: string, fromUser: string, onDelta: (delta: string) => void | Promise<void>, onDone: (fullText: string) => void | Promise<void>, onError?: (error: Error) => void | Promise<void>): Promise<void>;
+    private _downloadImageAsBase64;
+    private _doChatStream;
+}

package/dist/openclaw-client.js

@@ -0,0 +1,530 @@
+import { spawn } from 'child_process';
+import net from 'net';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+import { createLogger } from './logger.js';
+const DEFAULT_GATEWAY_PORT = 18789;
+const defaultLogger = createLogger('openclaw-client');
+function logInfo(log, msg) {
+    if (log === null || log === void 0 ? void 0 : log.info) {
+        log.info(msg);
+    }
+    else {
+        defaultLogger.info(msg);
+    }
+}
+function logWarn(log, msg) {
+    if (log === null || log === void 0 ? void 0 : log.warn) {
+        log.warn(msg);
+    }
+    else {
+        defaultLogger.warn(msg);
+    }
+}
+function logError(log, msg) {
+    if (log === null || log === void 0 ? void 0 : log.error) {
+        log.error(msg);
+    }
+    else {
+        defaultLogger.error(msg);
+    }
+}
+function getRealHomeDir() {
+    const envHome = process.env.CLAW_SERVICE_HOME || process.env.USERPROFILE || process.env.HOME;
+    if (envHome && !envHome.includes('systemprofile')) {
+        return envHome;
+    }
+    const homeDir = os.homedir();
+    if (!homeDir.includes('systemprofile')) {
+        return homeDir;
+    }
+    const usersDir = 'C:\\Users';
+    if (fs.existsSync(usersDir)) {
+        const entries = fs.readdirSync(usersDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !['Public', 'Default', 'All Users', 'Default User'].includes(entry.name)) {
+                const candidate = path.join(usersDir, entry.name);
+                if (fs.existsSync(path.join(candidate, '.openclaw'))) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    return homeDir;
+}
+export function getOpenClawEnv(baseEnv = process.env) {
+    const realHome = getRealHomeDir();
+    const env = Object.assign({}, baseEnv);
+    const systemHome = os.homedir();
+    env.USERPROFILE = realHome;
+    env.HOME = realHome;
+    if (process.platform === 'win32') {
+        const match = realHome.match(/^([A-Za-z]:)(.*)$/);
+        if (match) {
+            env.HOMEDRIVE = match[1];
+            env.HOMEPATH = match[2];
+        }
+        const fixPath = (originalPath) => {
+            if (!originalPath)
+                return null;
+            const lowerOriginal = originalPath.toLowerCase();
+            const lowerSystemHome = systemHome.toLowerCase();
+            if (lowerOriginal.includes(lowerSystemHome)) {
+                const idx = lowerOriginal.indexOf(lowerSystemHome);
+                return originalPath.substring(0, idx) + realHome + originalPath.substring(idx + systemHome.length);
+            }
+            return null;
+        };
+        if (baseEnv.APPDATA) {
+            const fixed = fixPath(baseEnv.APPDATA);
+            if (fixed)
+                env.APPDATA = fixed;
+        }
+        if (!env.APPDATA) {
+            env.APPDATA = path.join(realHome, 'AppData', 'Roaming');
+        }
+        if (baseEnv.LOCALAPPDATA) {
+            const fixed = fixPath(baseEnv.LOCALAPPDATA);
+            if (fixed)
+                env.LOCALAPPDATA = fixed;
+        }
+        if (!env.LOCALAPPDATA) {
+            env.LOCALAPPDATA = path.join(realHome, 'AppData', 'Local');
+        }
+    }
+    return env;
+}
+function getGatewayToken() {
+    var _a, _b;
+    const homeDir = getRealHomeDir();
+    const possibleFiles = [
+        path.join(homeDir, '.openclaw', 'openclaw.json'),
+        path.join(homeDir, '.openclaw', 'config.json'),
+        path.join(homeDir, '.openclaw', 'tools.json'),
+        path.join(homeDir, '.openclaw', 'settings.json'),
+    ];
+    for (const filePath of possibleFiles) {
+        try {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const config = JSON.parse(content);
+                const token = config.gatewayToken ||
+                    ((_b = (_a = config.gateway) === null || _a === void 0 ? void 0 : _a.auth) === null || _b === void 0 ? void 0 : _b.token) ||
+                    config.token ||
+                    config.apiKey ||
+                    config.api_key ||
+                    config.password;
+                if (token)
+                    return String(token);
+            }
+        }
+        catch (_c) {
+            // ignore
+        }
+    }
+    return null;
+}
+function checkPort(port) {
+    return new Promise((resolve) => {
+        const sock = new net.Socket();
+        sock.setTimeout(3000);
+        sock.once('connect', () => {
+            sock.destroy();
+            resolve(true);
+        });
+        sock.once('error', () => {
+            sock.destroy();
+            resolve(false);
+        });
+        sock.once('timeout', () => {
+            sock.destroy();
+            resolve(false);
+        });
+        sock.connect(port, '127.0.0.1');
+    });
+}
+function ensureChatCompletionsConfig(log) {
+    const realHome = getRealHomeDir();
+    const openclawDir = path.join(realHome, '.openclaw');
+    const configPath = path.join(openclawDir, 'openclaw.json');
+    let settings = {};
+    let existed = false;
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            settings = JSON.parse(content);
+            existed = true;
+        }
+    }
+    catch (_a) {
+        settings = {};
+    }
+    const gateway = settings.gateway || {};
+    const http = gateway.http || {};
+    const endpoints = http.endpoints || {};
+    const chatCompletions = endpoints.chatCompletions || {};
+    if (chatCompletions.enabled === true) {
+        logInfo(log, 'openclaw.json 中 chatCompletions 已启用');
+        return;
+    }
+    endpoints.chatCompletions = { enabled: true };
+    http.endpoints = endpoints;
+    gateway.http = http;
+    settings.gateway = gateway;
+    try {
+        if (!fs.existsSync(openclawDir)) {
+            fs.mkdirSync(openclawDir, { recursive: true });
+        }
+        fs.writeFileSync(configPath, JSON.stringify(settings, null, 2), 'utf-8');
+        logInfo(log, `已自动在 openclaw.json 中启用 chatCompletions (${existed ? '更新' : '新建'})`);
+    }
+    catch (err) {
+        logWarn(log, `写入 openclaw.json 失败: ${err.message}`);
+    }
+}
+function startOpenClawGateway(log) {
+    return new Promise((resolve) => {
+        ensureChatCompletionsConfig(log);
+        logInfo(log, '正在启动 OpenClaw gateway...');
+        const child = spawn('openclaw', ['gateway'], {
+            shell: true,
+            windowsHide: true,
+            detached: true,
+            stdio: 'ignore',
+            env: getOpenClawEnv(),
+        });
+        child.unref();
+        let attempts = 0;
+        const maxAttempts = 20;
+        const interval = setInterval(async () => {
+            attempts++;
+            const gatewayRunning = await checkPort(DEFAULT_GATEWAY_PORT);
+            if (gatewayRunning) {
+                clearInterval(interval);
+                logInfo(log, `OpenClaw gateway 启动成功 (${DEFAULT_GATEWAY_PORT})`);
+                resolve(true);
+            }
+            else if (attempts >= maxAttempts) {
+                clearInterval(interval);
+                logWarn(log, 'OpenClaw gateway 启动超时');
+                resolve(false);
+            }
+        }, 1000);
+        child.on('error', (err) => {
+            logError(log, `启动 gateway 失败: ${err.message}`);
+            clearInterval(interval);
+            resolve(false);
+        });
+    });
+}
+export class OpenClawClient {
+    constructor(gatewayUrl = `http://127.0.0.1:${DEFAULT_GATEWAY_PORT}`, log) {
+        this.gatewayStarting = false;
+        this.gatewayStarted = false;
+        this.gatewayUrl = gatewayUrl;
+        this.log = log;
+    }
+    static async acquireSlot() {
+        if (OpenClawClient.runningCount < OpenClawClient.maxConcurrency) {
+            OpenClawClient.runningCount++;
+            return;
+        }
+        return new Promise((resolve) => OpenClawClient.waitQueue.push(resolve));
+    }
+    static releaseSlot() {
+        OpenClawClient.runningCount--;
+        if (OpenClawClient.waitQueue.length > 0) {
+            const next = OpenClawClient.waitQueue.shift();
+            OpenClawClient.runningCount++;
+            next === null || next === void 0 ? void 0 : next();
+        }
+    }
+    async ensureGatewayRunning() {
+        const gatewayRunning = await checkPort(DEFAULT_GATEWAY_PORT);
+        if (gatewayRunning) {
+            this.gatewayStarted = true;
+            return true;
+        }
+        this.gatewayStarted = false;
+        if (this.gatewayStarting) {
+            for (let i = 0; i < 25; i++) {
+                await new Promise((r) => setTimeout(r, 1000));
+                if (await checkPort(DEFAULT_GATEWAY_PORT)) {
+                    this.gatewayStarted = true;
+                    return true;
+                }
+            }
+            return false;
+        }
+        this.gatewayStarting = true;
+        try {
+            const started = await startOpenClawGateway(this.log);
+            this.gatewayStarted = started;
+            return started;
+        }
+        finally {
+            this.gatewayStarting = false;
+        }
+    }
+    _getConversationHistory(fromUser) {
+        return OpenClawClient.conversationHistory.get(fromUser) || [];
+    }
+    _addToHistory(fromUser, role, content) {
+        let history = this._getConversationHistory(fromUser);
+        const truncated = content.length > OpenClawClient.maxMessageLength
+            ? content.substring(0, OpenClawClient.maxMessageLength) + '...'
+            : content;
+        history.push({ role, content: truncated });
+        const maxMessages = OpenClawClient.maxHistoryRounds * 2;
+        if (history.length > maxMessages) {
+            history = history.slice(history.length - maxMessages);
+        }
+        OpenClawClient.conversationHistory.set(fromUser, history);
+    }
+    clearHistory(fromUser) {
+        OpenClawClient.conversationHistory.delete(fromUser);
+    }
+    _buildMessagesWithHistory(fromUser, currentMessage) {
+        const history = this._getConversationHistory(fromUser);
+        return [
+            {
+                role: 'system',
+                content: `When you need to search the web for information, you MUST emit status markers on their own lines. These markers will be removed from the final user-facing message, but the UI uses them to show a "searching web" animation and source list:
+[web_search:searching]
+[web_search:url:<URL>]
+[web_search:done]
+
+Emit [web_search:searching] when you start searching, [web_search:url:<URL>] for each source you find, and [web_search:done] when you finish. Do not explain these markers.`
+            },
+            ...history,
+            { role: 'user', content: currentMessage }
+        ];
+    }
+    cancelActiveRequest(fromUser) {
+        const active = OpenClawClient.activeRequests.get(fromUser);
+        if (active) {
+            logInfo(this.log, `取消用户活跃请求: ${fromUser}`);
+            active.abort();
+            OpenClawClient.activeRequests.delete(fromUser);
+            return true;
+        }
+        return false;
+    }
+    async chatStream(message, fromUser, onDelta, onDone, onError) {
+        var _a, _b;
+        if (!message || !message.trim()) {
+            onError === null || onError === void 0 ? void 0 : onError(new Error('消息内容为空'));
+            return;
+        }
+        const gatewayReady = await this.ensureGatewayRunning();
+        if (!gatewayReady) {
+            const err = new Error('OpenClaw gateway 启动失败');
+            logError(this.log, err.message);
+            onError === null || onError === void 0 ? void 0 : onError(err);
+            return;
+        }
+        this.cancelActiveRequest(fromUser);
+        logInfo(this.log, `准备 SSE 流式调用 OpenClaw, fromUser=${fromUser}`);
+        const gatewayToken = getGatewayToken();
+        const sessionId = `clawmessenger-${fromUser}`;
+        const messagesWithHistory = this._buildMessagesWithHistory(fromUser, message);
+        const endpoints = [
+            `${this.gatewayUrl}/v1/chat/completions`,
+            `${this.gatewayUrl}/v1/responses`,
+        ];
+        for (let i = 0; i < endpoints.length; i++) {
+            const apiUrl = endpoints[i];
+            try {
+                const fullText = await this._doChatStream(apiUrl, gatewayToken, sessionId, fromUser, messagesWithHistory, onDelta);
+                this._addToHistory(fromUser, 'user', message);
+                this._addToHistory(fromUser, 'assistant', fullText);
+                await onDone(fullText);
+                return;
+            }
+            catch (err) {
+                if (err.name === 'AbortError' || ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('aborted'))) {
+                    logInfo(this.log, `请求被用户取消: ${fromUser}`);
+                    return;
+                }
+                const is404 = ((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 404;
+                const isLast = i === endpoints.length - 1;
+                if (is404 && !isLast) {
+                    logWarn(this.log, `SSE 端点 ${apiUrl} 返回 404，尝试备用端点`);
+                    continue;
+                }
+                if (is404 && isLast) {
+                    logError(this.log, '所有 SSE 端点均返回 404。OpenClaw responses 端点未启用。');
+                    logError(this.log, '请检查 ~/.openclaw/openclaw.json 中是否包含: gateway.http.endpoints.responses.enabled = true');
+                }
+                else {
+                    logError(this.log, `SSE 请求失败: ${err.message}`);
+                }
+                onError === null || onError === void 0 ? void 0 : onError(err);
+                return;
+            }
+        }
+    }
+    async _downloadImageAsBase64(imageUrl) {
+        const response = await axios.get(imageUrl, {
+            responseType: 'arraybuffer',
+            timeout: 30000,
+            maxContentLength: 10 * 1024 * 1024,
+        });
+        const buffer = Buffer.from(response.data);
+        const base64 = buffer.toString('base64');
+        const mediaType = response.headers['content-type'] || 'image/jpeg';
+        return { base64, mediaType };
+    }
+    async _doChatStream(apiUrl, gatewayToken, sessionId, fromUser, messages, onDelta) {
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+        };
+        if (gatewayToken) {
+            headers.Authorization = `Bearer ${gatewayToken}`;
+        }
+        const lastMessage = messages[messages.length - 1];
+        const messageContent = typeof (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.content) === 'string' ? lastMessage.content : '';
+        const imageUrlMatch = messageContent.match(/\[图片\]\s*(https?:\/\/[^\s]+)/);
+        let payload;
+        if (imageUrlMatch) {
+            const imageUrl = imageUrlMatch[1];
+            const textContent = messageContent.replace(/\[图片\]\s*https?:\/\/[^\s]+/, '').trim();
+            try {
+                const imageData = await this._downloadImageAsBase64(imageUrl);
+                const messagesWithImage = messages.slice(0, -1).concat([{
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: textContent || '' },
+                            {
+                                type: 'image_url',
+                                image_url: { url: `data:${imageData.mediaType};base64,${imageData.base64}` },
+                            },
+                        ],
+                    }]);
+                payload = {
+                    model: 'openclaw',
+                    messages: messagesWithImage,
+                    stream: true,
+                    max_tokens: 2048,
+                };
+            }
+            catch (err) {
+                logWarn(this.log, `图片处理失败，回退到文本模式: ${err.message}`);
+                payload = {
+                    model: 'openclaw',
+                    messages,
+                    stream: true,
+                    max_tokens: 2048,
+                };
+            }
+        }
+        else {
+            payload = {
+                model: 'openclaw',
+                messages,
+                stream: true,
+                max_tokens: 2048,
+            };
+        }
+        logInfo(this.log, `SSE 请求: ${apiUrl}, payload=${JSON.stringify(payload).substring(0, 200)}`);
+        const abortController = new AbortController();
+        OpenClawClient.activeRequests.set(fromUser, abortController);
+        const response = await axios.post(apiUrl, payload, {
+            headers,
+            responseType: 'stream',
+            timeout: 600000,
+            signal: abortController.signal,
+        });
+        return new Promise((resolve, reject) => {
+            let fullText = '';
+            let buffer = '';
+            let lastChunkData = null;
+            let hasError = false;
+            let errorMsg = '';
+            response.data.on('data', (chunk) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data: '))
+                        continue;
+                    const dataStr = trimmed.slice(6).trim();
+                    if (dataStr === '[DONE]')
+                        continue;
+                    try {
+                        const data = JSON.parse(dataStr);
+                        lastChunkData = data;
+                        if (data.error) {
+                            hasError = true;
+                            errorMsg = typeof data.error === 'string' ? data.error : ((_a = data.error) === null || _a === void 0 ? void 0 : _a.message) || JSON.stringify(data.error);
+                            logError(this.log, `SSE chunk error: ${errorMsg}`);
+                            continue;
+                        }
+                        const choice = (_b = data.choices) === null || _b === void 0 ? void 0 : _b[0];
+                        let delta = null;
+                        if (choice) {
+                            const deltaObj = choice.delta;
+                            delta =
+                                (_h = (_g = (_f = (_e = (_c = deltaObj === null || deltaObj === void 0 ? void 0 : deltaObj.content) !== null && _c !== void 0 ? _c : (_d = choice.message) === null || _d === void 0 ? void 0 : _d.content) !== null && _e !== void 0 ? _e : choice.text) !== null && _f !== void 0 ? _f : deltaObj === null || deltaObj === void 0 ? void 0 : deltaObj.text) !== null && _g !== void 0 ? _g : deltaObj === null || deltaObj === void 0 ? void 0 : deltaObj.reasoning_content) !== null && _h !== void 0 ? _h : null;
+                        }
+                        if (delta === null || delta === undefined) {
+                            delta = (_l = (_k = (_j = data.content) !== null && _j !== void 0 ? _j : data.delta) !== null && _k !== void 0 ? _k : data.text) !== null && _l !== void 0 ? _l : null;
+                        }
+                        if (typeof delta === 'string' && delta.length > 0) {
+                            fullText += delta;
+                            Promise.resolve(onDelta(delta)).catch(reject);
+                        }
+                    }
+                    catch (_m) {
+                        // ignore parse error
+                    }
+                }
+            });
+            response.data.on('end', async () => {
+                var _a;
+                OpenClawClient.activeRequests.delete(fromUser);
+                logInfo(this.log, `SSE 流结束, 长度=${fullText.length}`);
+                if (hasError) {
+                    reject(new Error(`OpenClaw SSE 错误: ${errorMsg}`));
+                    return;
+                }
+                if (fullText.length === 0) {
+                    const choices = lastChunkData === null || lastChunkData === void 0 ? void 0 : lastChunkData.choices;
+                    const message = (_a = choices === null || choices === void 0 ? void 0 : choices[0]) === null || _a === void 0 ? void 0 : _a.message;
+                    const lastContent = message === null || message === void 0 ? void 0 : message.content;
+                    if (typeof lastContent === 'string' && lastContent.length > 0) {
+                        fullText = lastContent;
+                    }
+                }
+                if (fullText.length === 0) {
+                    reject(new Error('OpenClaw SSE 返回空内容'));
+                    return;
+                }
+                try {
+                    await onDelta('');
+                    resolve(fullText);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            response.data.on('error', (err) => {
+                OpenClawClient.activeRequests.delete(fromUser);
+                logError(this.log, `SSE 流错误: ${err.message}`);
+                reject(err);
+            });
+        });
+    }
+}
+OpenClawClient.maxConcurrency = 2;
+OpenClawClient.runningCount = 0;
+OpenClawClient.waitQueue = [];
+OpenClawClient.conversationHistory = new Map();
+OpenClawClient.maxHistoryRounds = 50;
+OpenClawClient.maxMessageLength = 2000;
+OpenClawClient.activeRequests = new Map();

package/dist/openclaw-config.d.ts

@@ -0,0 +1,41 @@
+interface OpenClawSettings {
+    plugins?: {
+        allow?: string[];
+        entries?: Record<string, {
+            enabled?: boolean;
+        }>;
+        installs?: Record<string, any>;
+        load?: {
+            paths?: string[];
+        };
+    };
+    [key: string]: any;
+}
+export declare function getOpenClawSettings(settingsPath?: string): Promise<OpenClawSettings | null>;
+export declare function getPluginsAllow(): Promise<string[]>;
+export declare function ensurePluginsAllow(settingsPath?: string): Promise<boolean>;
+/**
+ * 确保插件在 plugins.entries 中注册
+ * OpenClaw 只有在 entries 中配置了才会加载插件
+ */
+export declare function ensurePluginEntry(settingsPath?: string): Promise<boolean>;
+/**
+ * 确保 channels.claw_messenger 配置包含 nodeName
+ * OpenClaw 的 hasMeaningfulChannelConfig 会忽略 enabled，
+ * 只有包含非 enabled 属性时才认为 channel 已配置，从而加载插件。
+ */
+export declare function ensureChannelConfig(nodeName?: string, settingsPath?: string): Promise<boolean>;
+/**
+ * 确保 gateway HTTP chatCompletions 端点已启用
+ * 供 SSE 流式调用使用（OpenClaw 默认禁用该端点）
+ */
+export declare function ensureChatCompletionsEnabled(settingsPath?: string): Promise<boolean>;
+/**
+ * 确保网关模型支持 image 类型
+ * OpenClaw 默认模型 type 只有 "text"，插件需要 "image" 支持
+ * 遍历 gateway.http.endpoints.chatCompletions.models 中的每个模型，
+ * 如果 type 是字符串 "text" 则改为 ["text", "image"]，
+ * 如果 type 是数组则追加 "image"
+ */
+export declare function ensureImageModelSupport(settingsPath?: string): Promise<boolean>;
+export {};