acp-ts 1.2.2 → 1.2.4

package/dist/utils.d.ts

@@ -1,3 +1,9 @@
+export declare const logger: {
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+};
 export declare function getDecryptKey(aid: string, password: string): Promise<string | null>;
 export declare function savePrivateKey(aid: string, privateKey: string, password: string): Promise<void>;
 export declare function createAid(aid: string, apiUrl: string, seedPassword: string): Promise<boolean>;

package/dist/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
 exports.getDecryptKey = getDecryptKey;
 exports.savePrivateKey = savePrivateKey;
 exports.createAid = createAid;
@@ -7,6 +8,22 @@ const datamanager_1 = require("./datamanager");
 const cert_1 = require("./cert");
 const jsrsasign_1 = require("jsrsasign");
 const api_1 = require("./api");
+function getTimestamp() {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, '0');
+    const d = String(now.getDate()).padStart(2, '0');
+    const h = String(now.getHours()).padStart(2, '0');
+    const min = String(now.getMinutes()).padStart(2, '0');
+    const s = String(now.getSeconds()).padStart(2, '0');
+    return `${y}/${m}/${d} ${h}:${min}:${s}`;
+}
+exports.logger = {
+    log: (...args) => console.log(`[${getTimestamp()}]`, ...args),
+    warn: (...args) => console.warn(`[${getTimestamp()}]`, ...args),
+    error: (...args) => console.error(`[${getTimestamp()}]`, ...args),
+    info: (...args) => console.info(`[${getTimestamp()}]`, ...args),
+};
 // 解密私钥数据
 function decryptPrivateKey(encryptedData, password) {
     try {
@@ -16,7 +33,7 @@ function decryptPrivateKey(encryptedData, password) {
         return privateKeyPEM;
     }
     catch (err) {
-        console.error('私钥解密失败:', err);
+        exports.logger.error('私钥解密失败:', err);
         return null;
     }
 }
@@ -29,7 +46,7 @@ function encryptPrivateKey(privateKeyPEM, password) {
         return encryptedPEM;
     }
     catch (err) {
-        console.error('私钥加密失败:', err);
+        exports.logger.error('私钥加密失败:', err);
         return null;
     }
 }

package/dist/websocket.d.ts

@@ -26,17 +26,28 @@ declare class WSClient {
     private _isReconnecting;
     private options;
     private rawMessageCallback;
+    private reconnectNeededCallback;
+    private _isReconnectNeededRunning;
     constructor(options?: WSClientOptions);
     /**
      * 检查 WebSocket 是否已连接
      */
     private isConnected;
     connectToServer(wsServer: string, aid: string, sinature: string): Promise<void>;
+    /**
+     * 注册"快速重连全部失败"回调，通知上层需要重新鉴权
+     */
+    onReconnectNeeded(cb: () => void): void;
+    /**
+     * 更新 WebSocket URL（上层重新获取 signature 后调用）
+     */
+    updateWsUrl(url: string): void;
     /**
      * 重连 WebSocket（供外部调用，如心跳重连后触发）
      * 会关闭旧连接，重置状态，重新建立连接
+     * @param newUrl 可选，传入新的 wsUrl（重新鉴权后使用）
      */
-    reconnect(): Promise<void>;
+    reconnect(newUrl?: string): Promise<void>;
     createSession(cb: (status: ACPMessageSessionResponse) => void): void;
     invite(receiver: string, sessionId: string, identifyingCode: string, cb?: (((status: InviteStatus) => void) | null)): void;
     onStatusChange(cb: (status: ConnectionStatus) => void): void;

package/dist/websocket.js

@@ -40,6 +40,7 @@ exports.WSClient = exports.isNodeEnvironment = void 0;
 const uuid_1 = require("uuid");
 const mitt_1 = __importDefault(require("mitt"));
 const https = __importStar(require("https"));
+const utils_1 = require("./utils");
 // 统一的环境检测函数
 exports.isNodeEnvironment = typeof process !== 'undefined' &&
     process.versions != null &&
@@ -67,8 +68,10 @@ class WSClient {
         this._isReconnecting = false;
         this.options = {};
         this.rawMessageCallback = null;
+        this.reconnectNeededCallback = null;
+        this._isReconnectNeededRunning = false;
         this.options = options || {};
-        this.maxRetries = (_a = this.options.maxRetries) !== null && _a !== void 0 ? _a : 5;
+        this.maxRetries = (_a = this.options.maxRetries) !== null && _a !== void 0 ? _a : 2;
     }
     /**
      * 检查 WebSocket 是否已连接
@@ -87,21 +90,37 @@ class WSClient {
             await this.connect();
         }
     }
+    /**
+     * 注册"快速重连全部失败"回调，通知上层需要重新鉴权
+     */
+    onReconnectNeeded(cb) {
+        this.reconnectNeededCallback = cb;
+    }
+    /**
+     * 更新 WebSocket URL（上层重新获取 signature 后调用）
+     */
+    updateWsUrl(url) {
+        this.wsUrl = url;
+    }
     /**
      * 重连 WebSocket（供外部调用，如心跳重连后触发）
      * 会关闭旧连接，重置状态，重新建立连接
+     * @param newUrl 可选，传入新的 wsUrl（重新鉴权后使用）
      */
-    async reconnect() {
+    async reconnect(newUrl) {
         if (this._isReconnecting) {
-            console.log('[WS] 已在重连中，跳过');
+            utils_1.logger.log('[WS] 已在重连中，跳过');
             return;
         }
-        if (!this.wsUrl) {
-            console.error('[WS] 重连失败: wsUrl 为空，尚未进行过初始连接');
+        if (!this.wsUrl && !newUrl) {
+            utils_1.logger.error('[WS] 重连失败: wsUrl 为空，尚未进行过初始连接');
             return;
         }
         this._isReconnecting = true;
-        console.log('[WS] 开始 WebSocket 重连...');
+        if (newUrl) {
+            this.wsUrl = newUrl;
+        }
+        utils_1.logger.log('[WS] 开始 WebSocket 重连...');
         try {
             // 关闭旧连接（标记为正常关闭，避免触发 onclose 重试）
             if (this.socket) {
@@ -116,10 +135,10 @@ class WSClient {
             this.updateStatus('reconnecting');
             // 重新建立连接
             await this.connect();
-            console.log('[WS] WebSocket 重连成功');
+            utils_1.logger.log('[WS] WebSocket 重连成功');
         }
         catch (error) {
-            console.error('[WS] WebSocket 重连失败:', error);
+            utils_1.logger.error('[WS] WebSocket 重连失败:', error);
             this.updateStatus('error');
         }
         finally {
@@ -174,7 +193,7 @@ class WSClient {
     sendRaw(message, to, sessionId) {
         var _a;
         if (!this.isConnected()) {
-            console.error('[WS] sendRaw: WebSocket连接未建立或已断开');
+            utils_1.logger.error('[WS] sendRaw: WebSocket连接未建立或已断开');
             return false;
         }
         try {
@@ -195,14 +214,14 @@ class WSClient {
             return true;
         }
         catch (error) {
-            console.error('发送原始消息失败:', error);
+            utils_1.logger.error('发送原始消息失败:', error);
             return false;
         }
     }
     send(message, to, sessionId, identifyingCode) {
         var _a;
         if (!message || message.trim().length === 0) {
-            console.error('发送的消息不能为空');
+            utils_1.logger.error('发送的消息不能为空');
             return;
         }
         if (!this.isConnected()) {
@@ -250,7 +269,7 @@ class WSClient {
             (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(msg));
         }
         catch (error) {
-            console.error('发送消息失败:', error);
+            utils_1.logger.error('发送消息失败:', error);
             this.emitter.emit('message', {
                 type: 'error',
                 content: JSON.stringify([{ content: '发送消息失败' }])
@@ -289,7 +308,7 @@ class WSClient {
                             this.handleMessage(data);
                         }
                         catch (error) {
-                            console.error('解析消息失败:', error);
+                            utils_1.logger.error('解析消息失败:', error);
                         }
                     };
                     this.socket.onclose = (event) => {
@@ -297,21 +316,35 @@ class WSClient {
                         this.updateStatus('disconnected');
                         if (!this.isNormalClose && !event.wasClean && retryCount < this.maxRetries) {
                             retryCount++;
-                            const retryDelay = Math.min(retryCount * 1000, 10000);
-                            console.warn(`WebSocket连接断开，${retryDelay}ms后重试 (${retryCount}/${this.maxRetries})...`);
+                            const retryDelay = retryCount * 1000;
+                            utils_1.logger.warn(`WebSocket连接断开，${retryDelay}ms后快速重试 (${retryCount}/${this.maxRetries})...`);
                             setTimeout(attemptConnect, retryDelay);
                         }
                         else if (!this.isNormalClose && retryCount >= this.maxRetries) {
                             if (!resolved) {
+                                // 首次连接就失败，直接 reject
                                 resolved = true;
                                 reject(new Error(`WebSocket连接失败，已达到最大重试次数 (${this.maxRetries})`));
                             }
+                            else if (this.reconnectNeededCallback
+                                && !this._isReconnectNeededRunning
+                                && !this._isReconnecting // 避免 reconnect() 内部的 connect() 失败再次触发，形成循环
+                            ) {
+                                // 曾经连接成功过、后来断开且快速重试耗尽 → 通知上层重新鉴权
+                                utils_1.logger.warn('[WS] 快速重试耗尽，触发 onReconnectNeeded 回调');
+                                this._isReconnectNeededRunning = true;
+                                // 回调可能是异步的，用 Promise 确保标志位在异步完成后才重置
+                                Promise.resolve()
+                                    .then(() => this.reconnectNeededCallback())
+                                    .catch((err) => utils_1.logger.error('[WS] onReconnectNeeded 回调执行失败:', err))
+                                    .finally(() => { this._isReconnectNeededRunning = false; });
+                            }
                         }
                         this.isNormalClose = false;
                     };
                     this.socket.onerror = (error) => {
                         var _a, _b;
-                        console.error('WebSocket 错误:', {
+                        utils_1.logger.error('WebSocket 错误:', {
                             error,
                             readyState: (_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState,
                             url: this.wsUrl,
@@ -324,12 +357,12 @@ class WSClient {
                     };
                 }
                 catch (err) {
-                    console.error('创建 WebSocket 实例失败:', err);
+                    utils_1.logger.error('创建 WebSocket 实例失败:', err);
                     this.updateStatus('error');
                     if (retryCount < this.maxRetries) {
                         retryCount++;
                         const retryDelay = retryCount * 1000;
-                        console.warn(`创建失败，${retryCount}秒后重试...`);
+                        utils_1.logger.warn(`创建失败，${retryCount}秒后重试...`);
                         setTimeout(attemptConnect, retryDelay);
                     }
                     else {
@@ -358,7 +391,7 @@ class WSClient {
     }
     createSessionId() {
         if (!this.isConnected()) {
-            console.error('WebSocket连接未建立，无法创建会话');
+            utils_1.logger.error('WebSocket连接未建立，无法创建会话');
             return;
         }
         try {
@@ -375,17 +408,17 @@ class WSClient {
             this.socket.send(JSON.stringify(msg));
         }
         catch (error) {
-            console.error('发送创建会话请求失败:', error);
+            utils_1.logger.error('发送创建会话请求失败:', error);
         }
     }
     sendInviteMessage(receiver, sessionId, identifyingCode) {
         var _a;
         if (!receiver || !sessionId || !identifyingCode) {
-            console.error('邀请参数不完整');
+            utils_1.logger.error('邀请参数不完整');
             return;
         }
         if (!this.isConnected()) {
-            console.error('WebSocket连接未建立，无法发送邀请');
+            utils_1.logger.error('WebSocket连接未建立，无法发送邀请');
             return;
         }
         try {
@@ -402,7 +435,7 @@ class WSClient {
             (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(msg));
         }
         catch (error) {
-            console.error('发送邀请失败:', error);
+            utils_1.logger.error('发送邀请失败:', error);
         }
     }
     handleMessage(message) {
@@ -434,7 +467,7 @@ class WSClient {
         else if (cmd === "invite_agent_req") {
             // 收到邀请请求，自动接受
             const { session_id, inviter_id, invite_code } = data;
-            console.log(`收到来自 ${inviter_id} 的会话邀请，会话ID: ${session_id}`);
+            utils_1.logger.log(`收到来自 ${inviter_id} 的会话邀请，会话ID: ${session_id}`);
             this.acceptInvite(session_id, inviter_id, invite_code);
         }
         else if (cmd === "session_message") {
@@ -443,7 +476,7 @@ class WSClient {
     }
     acceptInvite(sessionId, inviterId, inviteCode) {
         if (!this.isConnected()) {
-            console.error('WebSocket连接未建立，无法接受邀请');
+            utils_1.logger.error('WebSocket连接未建立，无法接受邀请');
             return;
         }
         try {
@@ -458,11 +491,11 @@ class WSClient {
                 }
             };
             this.socket.send(JSON.stringify(msg));
-            console.log(`已接受会话邀请: ${sessionId}`);
+            utils_1.logger.log(`已接受会话邀请: ${sessionId}`);
             this.isOnline = true;
         }
         catch (error) {
-            console.error('接受邀请失败:', error);
+            utils_1.logger.error('接受邀请失败:', error);
         }
     }
     /**
@@ -470,7 +503,7 @@ class WSClient {
      * 当心跳客户端收到邀请时，调用此方法通过 WebSocket 加入会话
      */
     acceptInviteFromHeartbeat(sessionId, inviterId, inviteCode) {
-        console.log(`[WebSocket] 通过心跳通道收到邀请，加入会话: ${sessionId}`);
+        utils_1.logger.log(`[WebSocket] 通过心跳通道收到邀请，加入会话: ${sessionId}`);
         this.acceptInvite(sessionId, inviterId, inviteCode);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acp-ts",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "基于 ACP智能体通信协议 的智能体通信库，提供智能体身份管理和实时通信功能",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",