@agentmarketpro/connector 1.0.1 → 2.0.0

package/dist/index.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,233 +39,533 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connector = void 0;
 exports.startConnector = startConnector;
 const ws_1 = __importDefault(require("ws"));
-const child_process_1 = require("child_process");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// ============================================================
+// 工具函数
+// ============================================================
+/** 查找 OpenClaw 配置文件路径 */
+function findOpenClawConfig() {
+    const home = os.homedir();
+    const candidates = [
+        path.join(home, '.openclaw', 'openclaw.json'),
+        path.join(home, '.config', 'openclaw', 'openclaw.json'),
+    ];
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA;
+        if (appData) {
+            candidates.push(path.join(appData, 'openclaw', 'openclaw.json'));
+        }
+    }
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+/** 读取 OpenClaw 配置 */
+function loadOpenClawConfig() {
+    const configPath = findOpenClawConfig();
+    if (!configPath)
+        return null;
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(raw);
+        config._path = configPath;
+        return config;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(`⚠️  读取 OpenClaw 配置失败: ${msg}`);
+        return null;
+    }
+}
+/** 检查并启用 OpenClaw HTTP API */
+function ensureHttpApiEnabled(config) {
+    if (!config || !config._path)
+        return false;
+    const gw = config.gateway || {};
+    const enabled = gw.http?.endpoints?.chatCompletions?.enabled;
+    if (enabled === true) {
+        console.log('✅ OpenClaw HTTP API 已启用');
+        return false;
+    }
+    console.log('🔧 OpenClaw HTTP API 未启用，正在自动配置...');
+    if (!config.gateway)
+        config.gateway = {};
+    if (!config.gateway.http)
+        config.gateway.http = {};
+    if (!config.gateway.http.endpoints)
+        config.gateway.http.endpoints = {};
+    if (!config.gateway.http.endpoints.chatCompletions)
+        config.gateway.http.endpoints.chatCompletions = {};
+    config.gateway.http.endpoints.chatCompletions.enabled = true;
+    try {
+        const backupPath = config._path + '.bak';
+        fs.copyFileSync(config._path, backupPath);
+        const toWrite = { ...config };
+        delete toWrite._path;
+        fs.writeFileSync(config._path, JSON.stringify(toWrite, null, 2), 'utf-8');
+        console.log('✅ 已自动启用 HTTP API 并保存配置');
+        console.log(`   备份: ${backupPath}`);
+        return true;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(`❌ 写入配置失败: ${msg}`);
+        console.log('   请手动在 openclaw.json 的 gateway 节点添加:');
+        console.log('   "http": { "endpoints": { "chatCompletions": { "enabled": true } } }');
+        return false;
+    }
+}
+/** 解析自定义 API URL */
+function parseApiUrl(url) {
+    const parsed = new URL(url);
+    let apiPath = parsed.pathname.replace(/\/$/, '');
+    if (!apiPath.endsWith('/chat/completions')) {
+        apiPath += '/chat/completions';
+    }
+    return {
+        protocol: parsed.protocol,
+        hostname: parsed.hostname,
+        port: parseInt(parsed.port) || (parsed.protocol === 'https:' ? 443 : 80),
+        path: apiPath,
+    };
+}
+// ============================================================
+// Connector 核心类
+// ============================================================
 class Connector {
     constructor(config) {
         this.ws = null;
-        this.reconnectTimer = null;
-        this.pingTimer = null;
-        this.config = {
-            openclawPort: 18789,
-            logLevel: 'info',
-            ...config,
-        };
+        this.reconnectInterval = 5000;
+        this.heartbeatTimer = null;
+        this.isConnected = false;
+        this.isAiReady = false;
+        this.messageQueue = [];
+        this.parsedApiUrl = null;
+        // OpenClaw 配置
+        this.openclawConfig = null;
+        this.config = config;
+        this.isCustomMode = !!config.apiUrl;
+        this.model = config.model || 'openclaw:main';
+        this.openclawPort = config.openclawPort || 18789;
+        this.openclawToken = config.openclawToken || '';
+        // 自定义后端模式：解析 URL
+        if (this.isCustomMode && config.apiUrl) {
+            try {
+                this.parsedApiUrl = parseApiUrl(config.apiUrl);
+            }
+            catch {
+                throw new Error(`无效的 API URL: ${config.apiUrl}`);
+            }
+        }
     }
-    /**
-     * 设置消息处理函数
-     */
+    /** 设置消息处理函数（高级用法，覆盖默认 AI 调用） */
     onMessage(handler) {
         this.messageHandler = handler;
         return this;
     }
-    /**
-     * 设置状态变化回调
-     */
+    /** 设置状态变化回调 */
     onStatusChange(handler) {
         this.statusHandler = handler;
         return this;
     }
-    /**
-     * 设置错误处理
-     */
+    /** 设置错误处理回调 */
     onError(handler) {
         this.errorHandler = handler;
         return this;
     }
-    /**
-     * 启动连接器
-     */
+    /** 启动连接器 */
     async start() {
-        this.log('info', '🚀 启动连接器...');
-        this.log('info', `   平台: ${this.config.platformUrl}`);
-        this.log('info', `   连接ID: ${this.config.connectionId}`);
+        // OpenClaw 模式：初始化配置
+        if (!this.isCustomMode) {
+            await this.initOpenClawConfig();
+        }
+        this.printStartInfo();
         this.connect();
     }
-    /**
-     * 停止连接器
-     */
+    /** 停止连接器 */
     async stop() {
-        this.log('info', '🛑 停止连接器...');
-        if (this.pingTimer) {
-            clearInterval(this.pingTimer);
-            this.pingTimer = null;
-        }
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
+        this.log('info', '🛑 正在关闭...');
+        this.stopHeartbeat();
         if (this.ws) {
             this.ws.close();
             this.ws = null;
         }
+        this.isConnected = false;
         this.statusHandler?.({ connected: false });
     }
-    /**
-     * 连接到平台
-     */
+    // ============================================================
+    // OpenClaw 配置初始化
+    // ============================================================
+    async initOpenClawConfig() {
+        this.openclawConfig = loadOpenClawConfig();
+        if (this.openclawConfig) {
+            this.log('info', `📂 找到 OpenClaw 配置: ${this.openclawConfig._path}`);
+        }
+        else {
+            this.log('info', '⚠️  未找到 OpenClaw 配置文件');
+        }
+        // 端口：命令行 > 配置文件 > 默认
+        if (!this.config.openclawPort) {
+            this.openclawPort = this.openclawConfig?.gateway?.port || 18789;
+        }
+        // Token：命令行 > 环境变量 > 配置文件
+        if (!this.openclawToken) {
+            this.openclawToken =
+                process.env.OPENCLAW_TOKEN ||
+                    this.openclawConfig?.gateway?.auth?.token ||
+                    '';
+        }
+        if (!this.openclawToken) {
+            throw new Error('无法获取 OpenClaw Token。\n' +
+                '解决方法:\n' +
+                '  1. 确保 OpenClaw 已安装并运行过（会生成配置文件）\n' +
+                '  2. 或手动指定: --openclaw-token <YOUR_TOKEN>\n' +
+                '  3. 或设置环境变量: OPENCLAW_TOKEN=<YOUR_TOKEN>\n' +
+                '  4. 或使用自定义后端: --api-url <URL> --model <MODEL>');
+        }
+        // 自动启用 HTTP API
+        if (this.openclawConfig) {
+            const configChanged = ensureHttpApiEnabled(this.openclawConfig);
+            if (configChanged) {
+                throw new Error('配置已更新，请重启 OpenClaw 后重新运行此连接器。\n' +
+                    '运行: openclaw restart');
+            }
+        }
+    }
+    // ============================================================
+    // WebSocket 连接
+    // ============================================================
     connect() {
-        const wsUrl = this.config.platformUrl.replace(/^http/, 'ws') + '/ws/connector';
-        this.ws = new ws_1.default(wsUrl, {
-            headers: {
-                'X-Connection-ID': this.config.connectionId,
-                'X-Token': this.config.token,
-            },
-        });
-        this.ws.on('open', () => {
-            this.log('info', '✅ 已连接到平台');
-            this.statusHandler?.({ connected: true, agentId: this.config.connectionId });
-            // 启动心跳
-            this.pingTimer = setInterval(() => {
-                this.sendPing();
-            }, 30000);
-        });
-        this.ws.on('message', (data) => {
-            this.handleMessage(data);
-        });
-        this.ws.on('close', () => {
-            this.log('info', '🔌 连接断开');
-            this.statusHandler?.({ connected: false });
-            // 清理心跳
-            if (this.pingTimer) {
-                clearInterval(this.pingTimer);
-                this.pingTimer = null;
-            }
-            // 自动重连
+        const wsUrl = this.config.gatewayUrl || 'wss://www.agentmarketpro.ai/ws/connector';
+        this.log('info', '🔗 正在连接到平台 Gateway...');
+        try {
+            this.ws = new ws_1.default(wsUrl, {
+                headers: {
+                    'X-Connection-ID': this.config.connectionId,
+                    'X-Token': this.config.token,
+                },
+            });
+            this.ws.on('open', () => {
+                this.log('info', '✅ 已连接到 Gateway');
+                this.isConnected = true;
+                this.statusHandler?.({ connected: true, agentId: this.config.connectionId });
+                this.startHeartbeat();
+                // 发送队列中的消息
+                while (this.messageQueue.length > 0) {
+                    const msg = this.messageQueue.shift();
+                    this.send(msg);
+                }
+            });
+            this.ws.on('message', (data) => this.handleGatewayMessage(data));
+            this.ws.on('close', (code) => {
+                this.log('info', `🔌 Gateway 连接断开 (code: ${code})`);
+                this.isConnected = false;
+                this.statusHandler?.({ connected: false });
+                this.stopHeartbeat();
+                this.scheduleReconnect();
+            });
+            this.ws.on('error', (error) => {
+                this.log('error', `❌ Gateway 连接错误: ${error.message}`);
+                this.errorHandler?.(error);
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log('error', `❌ 连接失败: ${msg}`);
             this.scheduleReconnect();
-        });
-        this.ws.on('error', (error) => {
-            this.log('error', `❌ 连接错误: ${error.message}`);
-            this.errorHandler?.(error);
-        });
+        }
     }
-    /**
-     * 处理收到的消息
-     */
-    async handleMessage(data) {
+    // ============================================================
+    // 消息处理
+    // ============================================================
+    async handleGatewayMessage(data) {
         try {
-            const msg = JSON.parse(data.toString());
-            // 处理不同类型的消息
-            switch (msg.type) {
+            const message = JSON.parse(data.toString());
+            switch (message.type) {
+                case 'connected':
+                    this.log('info', '');
+                    this.log('info', '═══════════════════════════════════════════════════════════════');
+                    this.log('info', '✅ Agent 已在线');
+                    this.log('info', '═══════════════════════════════════════════════════════════════');
+                    this.log('info', '');
+                    await this.checkAiBackend();
+                    break;
                 case 'ping':
-                    this.ws?.send(JSON.stringify({ type: 'pong' }));
+                    this.send({ type: 'pong', timestamp: Date.now() });
                     break;
                 case 'pong':
-                    // 心跳响应
                     break;
                 case 'message':
-                    // 收到用户消息，需要处理并回复
-                    await this.processMessage(msg.payload);
+                    await this.handleUserMessage(message.payload);
                     break;
                 case 'error':
-                    this.log('error', `❌ 平台错误: ${msg.message}`);
+                    this.log('error', `❌ 平台错误: ${message.message}`);
                     break;
                 default:
-                    this.log('debug', `📨 收到未知消息: ${msg.type}`);
+                    this.log('debug', `📥 收到消息: ${message.type}`);
             }
         }
         catch (error) {
-            this.log('error', `❌ 消息解析失败: ${error}`);
-        }
-    }
-    /**
-     * 处理用户消息
-     */
-    async processMessage(payload) {
-        const { sessionId, content, messageId, senderId, senderName } = payload;
-        this.log('info', `\n📨 收到消息:`);
-        this.log('info', `   会话: ${sessionId}`);
-        this.log('info', `   用户: ${senderName || 'Unknown'}`);
-        this.log('info', `   内容: ${content.substring(0, 50)}...`);
-        try {
-            let reply;
-            if (this.messageHandler) {
-                // 使用自定义处理函数
-                reply = await this.messageHandler({
-                    sessionId,
-                    content,
-                    senderId,
-                    senderName,
-                });
+            const msg = error instanceof Error ? error.message : String(error);
+            this.log('error', `❌ 消息解析错误: ${msg}`);
+        }
+    }
+    /** 检测 AI 后端可用性 */
+    async checkAiBackend() {
+        const ok = await this.checkApiAvailable();
+        if (ok) {
+            const backend = this.isCustomMode
+                ? this.config.apiUrl
+                : `localhost:${this.openclawPort}`;
+            this.log('info', `✅ AI 后端就绪: ${backend}`);
+            this.isAiReady = true;
+        }
+        else {
+            this.log('info', '⚠️  AI 后端不可用，30秒后重试');
+            setTimeout(() => this.checkAiBackend(), 30000);
+        }
+    }
+    /** 检查 API 是否可用 */
+    checkApiAvailable() {
+        return new Promise((resolve) => {
+            if (this.isCustomMode && this.parsedApiUrl) {
+                const mod = this.parsedApiUrl.protocol === 'https:' ? https : http;
+                const req = mod.get(`${this.parsedApiUrl.protocol}//${this.parsedApiUrl.hostname}:${this.parsedApiUrl.port}/`, () => resolve(true));
+                req.on('error', () => resolve(false));
+                req.setTimeout(10000, () => { req.destroy(); resolve(false); });
             }
             else {
-                // 默认调用 OpenClaw
-                reply = await this.callOpenClaw(content, sessionId);
+                const req = http.get(`http://localhost:${this.openclawPort}/`, () => resolve(true));
+                req.on('error', () => resolve(false));
+                req.setTimeout(10000, () => { req.destroy(); resolve(false); });
+            }
+        });
+    }
+    /** 处理用户消息 */
+    async handleUserMessage(payload) {
+        const { sessionId, messageId, content, senderId, senderName } = payload;
+        this.log('info', '');
+        this.log('info', `📥 用户消息 [${sessionId}]: ${content}`);
+        // 如果有自定义消息处理函数
+        if (this.messageHandler) {
+            try {
+                const reply = await this.messageHandler({ sessionId, messageId, content, senderId, senderName });
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: reply } });
+                return;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.log('error', `❌ 自定义处理失败: ${msg}`);
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，处理失败，请重试。' } });
+                return;
             }
-            this.log('info', `   回复: ${reply.substring(0, 50)}...`);
-            // 发送回复
-            this.sendReply(sessionId, messageId, reply);
         }
-        catch (error) {
-            this.log('error', `❌ 处理消息失败: ${error}`);
-            this.sendReply(sessionId, messageId, '抱歉，我暂时无法处理你的请求。');
+        if (!this.isAiReady) {
+            this.log('info', '⚠️  AI 后端未就绪，返回错误');
+            this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，AI 引擎未就绪，请稍后重试。' } });
+            return;
         }
+        await this.callAiBackend(sessionId, messageId, content);
     }
-    /**
-     * 调用本地 OpenClaw
-     */
-    async callOpenClaw(message, sessionId) {
-        try {
-            const cleanMessage = message.replace(/"/g, '\\"');
-            const result = (0, child_process_1.execSync)(`openclaw agent --message "${cleanMessage}" --session-id ${sessionId}`, {
-                encoding: 'utf-8',
-                timeout: 60000,
-                maxBuffer: 10 * 1024 * 1024,
+    // ============================================================
+    // AI 后端调用（流式）
+    // ============================================================
+    /** 流式调用 AI 后端 */
+    callAiBackend(sessionId, messageId, content) {
+        return new Promise((resolve) => {
+            const postData = JSON.stringify({
+                model: this.model,
+                messages: [{ role: 'user', content }],
+                stream: true,
+                user: `agentmarket-${sessionId}`,
             });
-            // 过滤日志行
-            const lines = result.split('\n');
-            const replyLines = lines.filter(line => !line.startsWith('[') && line.trim());
-            const reply = replyLines.join('\n').trim();
-            return reply || '收到消息';
+            let options;
+            let reqModule;
+            if (this.isCustomMode && this.parsedApiUrl) {
+                reqModule = this.parsedApiUrl.protocol === 'https:' ? https : http;
+                options = {
+                    hostname: this.parsedApiUrl.hostname,
+                    port: this.parsedApiUrl.port,
+                    path: this.parsedApiUrl.path,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(postData),
+                        ...(this.config.apiKey ? { 'Authorization': `Bearer ${this.config.apiKey}` } : {}),
+                    },
+                    timeout: 120000,
+                };
+            }
+            else {
+                reqModule = http;
+                options = {
+                    hostname: 'localhost',
+                    port: this.openclawPort,
+                    path: '/v1/chat/completions',
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.openclawToken}`,
+                        'Content-Length': Buffer.byteLength(postData),
+                    },
+                    timeout: 120000,
+                };
+            }
+            const req = reqModule.request(options, (res) => {
+                const isStream = res.headers['content-type']?.includes('text/event-stream') ||
+                    res.headers['transfer-encoding'] === 'chunked';
+                if (isStream) {
+                    this.handleStreamResponse(res, sessionId, messageId, resolve);
+                }
+                else {
+                    this.handleNormalResponse(res, sessionId, messageId, resolve);
+                }
+            });
+            req.on('error', (error) => {
+                this.log('error', `❌ HTTP 请求失败: ${error.message}`);
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，AI 引擎连接失败，请重试。' } });
+                resolve();
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                this.log('info', '⚠️  请求超时');
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，处理超时，请重试。' } });
+                resolve();
+            });
+            req.write(postData);
+            req.end();
+        });
+    }
+    /** 处理流式响应 (SSE) */
+    handleStreamResponse(res, sessionId, messageId, resolve) {
+        let fullContent = '';
+        let buffer = '';
+        let chunkCount = 0;
+        const CHUNK_THRESHOLD = 50;
+        let lastSentLength = 0;
+        res.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        fullContent += delta;
+                        chunkCount++;
+                        // 定期发送中间结果（流式推送到前端）
+                        if (fullContent.length - lastSentLength >= CHUNK_THRESHOLD) {
+                            this.send({
+                                type: 'stream',
+                                payload: { sessionId, messageId, content: fullContent, done: false },
+                            });
+                            lastSentLength = fullContent.length;
+                        }
+                    }
+                }
+                catch {
+                    // 忽略解析错误的行
+                }
+            }
+        });
+        res.on('end', () => {
+            fullContent = fullContent.replace(/<final>/g, '').trim();
+            if (fullContent) {
+                this.log('info', `✅ 流式回复完成 (${chunkCount} chunks): ${fullContent.substring(0, 50)}...`);
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: fullContent } });
+            }
+            else {
+                this.log('info', '⚠️  流式响应无内容');
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，未能获取回复，请重试。' } });
+            }
+            resolve();
+        });
+        res.on('error', (error) => {
+            this.log('error', `❌ 流式读取错误: ${error.message}`);
+            if (fullContent) {
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: fullContent.replace(/<final>/g, '').trim() } });
+            }
+            resolve();
+        });
+    }
+    /** 处理普通响应（兜底，当 stream 不被支持时） */
+    handleNormalResponse(res, sessionId, messageId, resolve) {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+            try {
+                const result = JSON.parse(data);
+                let replyContent = '';
+                if (result.choices?.[0]) {
+                    replyContent = result.choices[0].message?.content || '';
+                }
+                else if (result.error) {
+                    this.log('error', `❌ API 错误: ${JSON.stringify(result.error)}`);
+                    replyContent = '抱歉，处理失败，请重试。';
+                }
+                replyContent = replyContent.replace(/<final>/g, '').trim();
+                if (replyContent) {
+                    this.log('info', `✅ 回复: ${replyContent.substring(0, 50)}...`);
+                }
+                else {
+                    replyContent = '抱歉，未能获取回复，请重试。';
+                }
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: replyContent } });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                this.log('error', `❌ 响应解析失败: ${msg}`);
+                this.send({ type: 'reply', payload: { sessionId, messageId, content: '抱歉，处理失败，请重试。' } });
+            }
+            resolve();
+        });
+    }
+    // ============================================================
+    // 通信与心跳
+    // ============================================================
+    send(message) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(message));
         }
-        catch (error) {
-            this.log('error', `❌ OpenClaw 调用失败: ${error}`);
-            throw error;
+        else {
+            this.messageQueue.push(message);
         }
     }
-    /**
-     * 发送回复到平台
-     */
-    sendReply(sessionId, messageId, reply) {
-        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
-            this.log('error', '❌ 连接未建立，无法发送回复');
-            return;
-        }
-        this.ws.send(JSON.stringify({
-            type: 'reply',
-            payload: {
-                sessionId,
-                messageId,
-                content: reply,
-            },
-        }));
-        this.log('info', '✅ 回复已发送');
-    }
-    /**
-     * 发送心跳
-     */
-    sendPing() {
-        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify({ type: 'ping' }));
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            if (this.isConnected) {
+                this.send({ type: 'ping', timestamp: Date.now() });
+            }
+        }, 25000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
         }
     }
-    /**
-     * 安排重连
-     */
     scheduleReconnect() {
-        if (this.reconnectTimer)
-            return;
-        this.log('info', '⏳ 5秒后尝试重连...');
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            this.connect();
-        }, 5000);
-    }
-    /**
-     * 日志
-     */
+        this.log('info', `⏱️  ${this.reconnectInterval / 1000}秒后重连...`);
+        setTimeout(() => this.connect(), this.reconnectInterval);
+    }
+    // ============================================================
+    // 日志与信息
+    // ============================================================
     log(level, message) {
-        const prefix = '[Connector]';
         const timestamp = new Date().toISOString();
+        const prefix = '[Connector]';
         if (level === 'error') {
             console.error(`${timestamp} ${prefix} ${message}`);
         }
@@ -240,11 +573,41 @@ class Connector {
             console.log(`${timestamp} ${prefix} ${message}`);
         }
     }
+    printStartInfo() {
+        const gatewayUrl = this.config.gatewayUrl || 'wss://www.agentmarketpro.ai/ws/connector';
+        console.log('');
+        console.log('╔═══════════════════════════════════════════════════════════════════╗');
+        console.log('║         AgentMarketPro Connector v2.0.0                        ║');
+        console.log('╚═══════════════════════════════════════════════════════════════════╝');
+        console.log('');
+        console.log('📋 配置信息:');
+        console.log(`   ├── 平台网关:     ${gatewayUrl}`);
+        console.log(`   ├── 连接ID:       ${this.config.connectionId}`);
+        if (this.isCustomMode) {
+            const keyPreview = this.config.apiKey
+                ? `${this.config.apiKey.substring(0, 6)}...`
+                : '(无)';
+            console.log(`   ├── AI 后端:      ${this.config.apiUrl}`);
+            console.log(`   ├── 模型:         ${this.model}`);
+            console.log(`   └── API Key:      ${keyPreview}`);
+        }
+        else {
+            const tokenPreview = this.openclawToken.length > 12
+                ? `${this.openclawToken.substring(0, 8)}...${this.openclawToken.substring(this.openclawToken.length - 4)}`
+                : '***';
+            const tokenSource = this.config.openclawToken ? '命令行'
+                : process.env.OPENCLAW_TOKEN ? '环境变量'
+                    : '自动读取';
+            console.log(`   ├── OpenClaw:     localhost:${this.openclawPort} (HTTP API)`);
+            console.log(`   └── Token:        ${tokenPreview} (${tokenSource})`);
+        }
+        console.log('');
+    }
 }
 exports.Connector = Connector;
-/**
- * 便捷启动函数
- */
+// ============================================================
+// 便捷启动函数
+// ============================================================
 async function startConnector(config) {
     const connector = new Connector(config);
     await connector.start();