@koi-design/callkit 2.0.3 → 2.0.5

package/dist/index.mjs

@@ -612,12 +612,13 @@ var Call = class {
 // package.json
 var package_default = {
   name: "@koi-design/callkit",
-  version: "2.0.3",
+  version: "2.0.5",
   description: "callkit",
   author: "koi",
   license: "ISC",
   scripts: {
     build: "tsup",
+    "build:w": "tsup --watch",
     dev: "vite",
     lint: "eslint -c ../../.eslintrc.js --ext .jsx,.js,.tsx,.ts ./package --fix",
     release: "tsup && node scripts/pkg.js"
@@ -1891,36 +1892,48 @@ var Connect = class {
 var RECONNECT_CONFIG = {
   enabled: true,
   maxAttempts: 3,
-  delay: 500,
-  backoffMultiplier: 1.5,
+  delay: 1e3,
   pingInterval: 3e4,
-  pingTimeout: 5e3,
-  maxConnectsPerWindow: 5,
-  timeWindow: 6e4
-  // 60 seconds
+  pingTimeout: 5e3
 };
 var Socket = class {
   callKit;
   ws;
-  socketConfig;
   lastPingTime = void 0;
-  isConnected = false;
   pingTimer;
-  // Whether received start confirmation
-  satrtConfirm = false;
+  /**
+   * @description reconnect timer
+   */
   reconnectTimer;
-  isReconnecting = false;
+  /**
+   * @description reconnect attempts
+   */
   reconnectAttempts = 0;
-  socketError = false;
-  // Track connection attempts for rate limiting
-  connectAttemptTimes = [];
+  /**
+   * @description connect auth state
+   * @default {
+   *   satrtConfirm: false,
+   *   isConnected: false,
+   *   isReconnecting: false,
+   *   isAuthenticated: false,
+   *   isError: false
+   * }
+   */
+  connectAuthState = {
+    satrtConfirm: false,
+    isConnected: false,
+    isReconnecting: false,
+    isAuthenticated: false,
+    isError: false
+  };
+  get satrtConfirm() {
+    return this.connectAuthState.satrtConfirm;
+  }
+  get isError() {
+    return this.connectAuthState.isError;
+  }
   constructor(callKit) {
     this.callKit = callKit;
-    const { reconnect } = this.callKit.config.getConfig();
-    this.socketConfig = {
-      ...RECONNECT_CONFIG,
-      ...reconnect
-    };
   }
   init() {
     const { socket } = this.callKit.config.getConfig();
@@ -1933,16 +1946,29 @@ var Socket = class {
     });
     this.connect(socket);
   }
+  getSocketConfig() {
+    const { reconnect } = this.callKit.config.getConfig();
+    return {
+      ...RECONNECT_CONFIG,
+      ...reconnect
+    };
+  }
+  setConnectAuthState(key, value) {
+    if (this.connectAuthState[key] === value)
+      return;
+    this.connectAuthState[key] = value;
+  }
   handleDisconnect() {
-    this.isConnected = false;
-    if (!this.callKit.config.isLogin() || !this.socketConfig.enabled) {
-      this.reset();
+    this.setConnectAuthState("isConnected", false);
+    const { enabled } = this.getSocketConfig();
+    if (!this.callKit.config.isLogin() || !enabled) {
+      this.callKit.reset();
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_NOT_CONNECTED"
       });
       return;
     }
-    if (this.isReconnecting) {
+    if (this.connectAuthState.isReconnecting) {
       return;
     }
     this.attemptReconnect();
@@ -1963,13 +1989,12 @@ var Socket = class {
       });
     }
     this.ws = void 0;
-    this.isConnected = false;
+    this.setConnectAuthState("isConnected", false);
   }
   connect(socketUrl) {
     if (this.ws) {
       this.clearWebSocket();
     }
-    this.connectAttemptTimes.push(Date.now());
     this.ws = new WebSocket(socketUrl);
     this.ws.onopen = (ev) => this.onOpen(ev);
     this.ws.onclose = (ev) => this.onClose(ev);
@@ -1982,11 +2007,11 @@ var Socket = class {
       type: "INCALL",
       content: { ev }
     });
-    this.socketError = false;
-    this.isConnected = true;
+    this.setConnectAuthState("isConnected", true);
     this.lastPingTime = Date.now();
     this.checkPing();
-    if (this.isReconnecting) {
+    if (this.connectAuthState.isReconnecting) {
+      this.setConnectAuthState("isReconnecting", false);
       this.callKit.logger.info("reconnect success", {
         caller: "Socket.onOpen",
         type: "INCALL",
@@ -1999,10 +2024,15 @@ var Socket = class {
         event: "INCALL_RECONNECT_SUCCESS"
       });
     }
-    this.resetReconnectState();
   }
-  resetReconnectState() {
-    this.isReconnecting = false;
+  resetConnectState() {
+    this.connectAuthState = {
+      satrtConfirm: false,
+      isConnected: false,
+      isReconnecting: false,
+      isAuthenticated: false,
+      isError: false
+    };
     this.reconnectAttempts = 0;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
@@ -2015,13 +2045,9 @@ var Socket = class {
       type: "INCALL",
       content: { ev }
     });
-    if (this.socketError) {
-      return;
-    }
     this.handleDisconnect();
   }
   onError(ev) {
-    this.socketError = true;
     this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
       event: "INCALL_CONNECT_ERROR",
       err: ev
@@ -2071,6 +2097,20 @@ var Socket = class {
     this.confirmAck(data);
     if (data.event === SocketReceiveEvent.PONG) {
       this.lastPingTime = Date.now();
+      this.setConnectAuthState("isAuthenticated", true);
+      this.callKit.logger.info("socket onMessage pong Authenticated", {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: content,
+          event: SocketReceiveEvent.PONG,
+          isAuthenticated: true
+        }
+      });
+      this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+        event: "INCALL_AUTHENTICATED",
+        isAuthenticated: true
+      });
       return;
     }
     if (data.event === SocketReceiveEvent.START_CONFIRM) {
@@ -2082,7 +2122,7 @@ var Socket = class {
           event: SocketReceiveEvent.START_CONFIRM
         }
       });
-      this.satrtConfirm = true;
+      this.setConnectAuthState("satrtConfirm", true);
     }
     if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
       this.callKit.logger.info("call success", {
@@ -2196,12 +2236,10 @@ var Socket = class {
           event: SocketReceiveEvent.CLOSE
         }
       });
-      this.send(SocketSendEvent.END, {
-        agentId: userInfo.agentId
-      });
+      this.send(SocketSendEvent.END, { agentId: userInfo.agentId });
     }
     if (data.event === SocketReceiveEvent.ERROR) {
-      this.socketError = true;
+      this.setConnectAuthState("isError", true);
       this.callKit.reset();
       this.callKit.logger.error(data.msg, {
         caller: `Socket.onMessage:${data.event}`,
@@ -2213,7 +2251,7 @@ var Socket = class {
       });
     }
     if (data.event === SocketReceiveEvent.SESSION_ERROR) {
-      this.socketError = true;
+      this.setConnectAuthState("isError", true);
       this.callKit.reset();
       this.callKit.logger.error(data.msg, {
         caller: `Socket.onMessage:${data.event}`,
@@ -2240,7 +2278,7 @@ var Socket = class {
     this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
   }
   send(event, message) {
-    if (!this.isConnected) {
+    if (!this.connectAuthState.isConnected) {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_NOT_CONNECTED"
       });
@@ -2299,7 +2337,7 @@ var Socket = class {
     }
   }
   ping() {
-    if (!this.isConnected)
+    if (!this.connectAuthState.isConnected)
       return;
     this.send(SocketSendEvent.PING);
     this.callKit.logger.info(`socket ping`, {
@@ -2310,12 +2348,12 @@ var Socket = class {
       }
     });
     const now = Date.now();
-    const { pingInterval, pingTimeout } = this.socketConfig;
+    const { pingInterval, pingTimeout } = this.getSocketConfig();
     if (now - this.lastPingTime > pingInterval + pingTimeout) {
-      if (this.ws && this.isConnected) {
+      if (this.ws && this.connectAuthState.isConnected) {
         this.ws.close(4001, "ping timeout");
       } else {
-        this.reset();
+        this.callKit.reset();
       }
       this.callKit.logger.error("socket ping timeout", {
         caller: "Socket.ping",
@@ -2331,23 +2369,29 @@ var Socket = class {
       clearInterval(this.pingTimer);
     }
     this.ping();
+    const { pingInterval } = this.getSocketConfig();
     this.pingTimer = setInterval(() => {
       this.ping();
-    }, this.socketConfig.pingInterval);
+    }, pingInterval);
   }
   /**
    * reset socket connection and all states
    */
-  async reset() {
+  async reset(config) {
+    const { focus = false } = config || {};
     if (this.pingTimer) {
       clearInterval(this.pingTimer);
       this.pingTimer = void 0;
     }
-    this.resetReconnectState();
+    if (focus) {
+      this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+        event: "INCALL_RESET"
+      });
+      this.resetConnectState();
+      this.setConnectAuthState("isConnected", false);
+    }
     this.lastPingTime = void 0;
-    this.satrtConfirm = false;
-    this.socketError = false;
-    this.connectAttemptTimes = [];
+    this.setConnectAuthState("satrtConfirm", false);
     this.clearWebSocket();
   }
   attemptReconnect() {
@@ -2355,34 +2399,12 @@ var Socket = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = void 0;
     }
-    const { maxConnectsPerWindow, timeWindow } = this.socketConfig;
-    if (maxConnectsPerWindow && timeWindow) {
-      const now = Date.now();
-      this.connectAttemptTimes = this.connectAttemptTimes.filter(
-        (time) => now - time < timeWindow
-      );
-      if (this.connectAttemptTimes.length >= maxConnectsPerWindow) {
-        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
-          event: "INCALL_RECONNECT_ERROR"
-        });
-        this.callKit.logger.warn("Connection rate limit exceeded", {
-          caller: "Socket.attemptReconnect",
-          type: "INCALL",
-          content: {
-            errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
-            attempts: this.connectAttemptTimes.length,
-            maxConnectsPerWindow,
-            timeWindow
-          }
-        });
-        return;
-      }
-    }
-    if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+    const { maxAttempts } = this.getSocketConfig();
+    if (this.reconnectAttempts >= maxAttempts) {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_RECONNECT_ERROR"
       });
-      this.reset();
+      this.callKit.reset();
       this.callKit.logger.error("Maximum reconnection attempts reached", {
         caller: "Socket.attemptReconnect",
         type: "INCALL",
@@ -2398,17 +2420,17 @@ var Socket = class {
         event: "INCALL_RECONNECT_START"
       });
     }
-    this.isReconnecting = true;
+    this.setConnectAuthState("isReconnecting", true);
     this.reconnectAttempts += 1;
-    const { delay } = this.socketConfig;
+    const { delay } = this.getSocketConfig();
     this.callKit.logger.info(
-      `Preparing reconnection attempt ${this.reconnectAttempts}/${this.socketConfig.maxAttempts}, delay: ${delay}ms`,
+      `Preparing reconnection attempt ${this.reconnectAttempts}/${maxAttempts}, delay: ${delay}ms`,
       {
         caller: "Socket.attemptReconnect",
         type: "INCALL",
         content: {
           reconnectAttempts: this.reconnectAttempts,
-          maxAttempts: this.socketConfig.maxAttempts,
+          maxAttempts,
           delay
         }
       }
@@ -2483,6 +2505,13 @@ var CallKit = class {
         encryptionPassword
       }
     });
+    if (this.socket.isError) {
+      this.logger.warn("socket is error", {
+        caller: "CallKit.login",
+        content: { username, password, extra, socketError: this.socket.isError }
+      });
+      return;
+    }
     try {
       const user = await this.api.login({
         userName: username,
@@ -2534,7 +2563,7 @@ var CallKit = class {
       try {
         await this.api.loginOut({ sessionId });
       } catch (error) {
-        this.logger.error(error, {
+        this.logger.warn(error, {
           caller: "CallKit.logout",
           content: {
             errCode: ErrorCode.API_USER_LOGOUT_ERROR
@@ -2610,9 +2639,6 @@ var CallKit = class {
     });
     this.connect.unregister();
   }
-  async stop() {
-    await this.connect.stop();
-  }
   async hangup() {
     if (!this.config.check())
       return;
@@ -2695,11 +2721,13 @@ var CallKit = class {
       userStatus: status
     });
   }
-  async reset() {
+  async _reset(config) {
+    const { focus = false } = config || {};
     this.logger.info("reset", {
       caller: "CallKit.reset",
       content: {
-        connectStatus: this.connect.connectStatus
+        connectStatus: this.connect.connectStatus,
+        focus
       }
     });
     if (this.connect.isCalling()) {
@@ -2710,7 +2738,14 @@ var CallKit = class {
       await this.logout({ isReset: false });
     }
     await this.config.reset();
-    await this.socket.reset();
+    await this.socket.reset({ focus });
+  }
+  /**
+   * reset callkit
+   * @description recover the callkit to the initial state
+   */
+  async reset() {
+    await this._reset({ focus: true });
   }
   on(event, callback) {
     this.listener.push({