@koi-design/callkit 2.3.0-beta.9 → 2.3.1-beta.1

package/dist/index.global.js

@@ -1736,7 +1736,7 @@ var WebCall = (() => {
   var require_follow_redirects = __commonJS({
     "../../node_modules/.pnpm/follow-redirects@1.15.9/node_modules/follow-redirects/index.js"(exports, module) {
       var url = __require("url");
-      var URL = url.URL;
+      var URL2 = url.URL;
       var http = __require("http");
       var https = __require("https");
       var Writable = __require("stream").Writable;
@@ -1752,7 +1752,7 @@ var WebCall = (() => {
       })();
       var useNativeURL = false;
       try {
-        assert(new URL(""));
+        assert(new URL2(""));
       } catch (error) {
         useNativeURL = error.code === "ERR_INVALID_URL";
       }
@@ -2132,7 +2132,7 @@ var WebCall = (() => {
       function parseUrl(input) {
         var parsed;
         if (useNativeURL) {
-          parsed = new URL(input);
+          parsed = new URL2(input);
         } else {
           parsed = validateUrl(url.parse(input));
           if (!isString(parsed.protocol)) {
@@ -2142,7 +2142,7 @@ var WebCall = (() => {
         return parsed;
       }
       function resolveUrl(relative, base) {
-        return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+        return useNativeURL ? new URL2(relative, base) : parseUrl(url.resolve(base, relative));
       }
       function validateUrl(input) {
         if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -2221,7 +2221,7 @@ var WebCall = (() => {
         return typeof value === "object" && "length" in value;
       }
       function isURL(value) {
-        return URL && value instanceof URL;
+        return URL2 && value instanceof URL2;
       }
       module.exports = wrap({ http, https });
       module.exports.wrap = wrap;
@@ -3237,7 +3237,7 @@ var WebCall = (() => {
         const res = await this.post({
           url: "/auth/agentUser/login",
           method: "post",
-          data: params
+          data: { ...params, browserVersion: navigator.userAgent }
         });
         return res;
       } finally {
@@ -3700,7 +3700,11 @@ var WebCall = (() => {
     ERROR: "ERROR",
     SESSION_ERROR: "SESSION_ERROR",
     WAITING_QUEUE: "WAITING_QUEUE",
-    CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE"
+    CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE",
+    /**
+     * Agent RTP loss
+     */
+    AGENT_RTP_LOSS: "AGENT_RTP_LOSS"
   };
   var EncryptionMethod = {
     NONE: "NONE",
@@ -3889,7 +3893,7 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.3.0-beta.9",
+    version: "2.3.1-beta.1",
     description: "callkit",
     author: "koi",
     license: "ISC",
@@ -18989,8 +18993,6 @@ ${log}` : log;
         });
         return;
       }
-      const { userInfo } = this.callKit.config.getConfig();
-      const { userPart, fsIp, fsPort } = userInfo;
       const { registererOptions = {} } = this.reconnectConfig;
       this.registerer = new Registerer(this.userAgent, registererOptions);
       this.registerer.stateChange.addListener((state) => {
@@ -19024,27 +19026,26 @@ ${log}` : log;
             });
             this.setRegister(true);
             if (this.isReConnected) {
-              if (this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling()) {
-                const selfUri = `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+              if (this.canReferInCallToSelf()) {
                 this.callKit.logger.info(
                   "Reconnected, referring active session to self",
                   {
                     caller: "Connect.setupRegisterer.registererStateChange",
                     type: "SIP",
                     content: {
-                      selfUri,
+                      selfUri: this.getSelfReferUri(),
                       sessionState: this.currentSession.state,
                       connectStatus: this.connectStatus
                     }
                   }
                 );
-                this.referInCall(selfUri).catch((err) => {
+                this.referInCallToSelf().catch((err) => {
                   this.callKit.logger.error(err, {
                     caller: "Connect.setupRegisterer.registererStateChange",
                     type: "SIP",
                     content: {
                       errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
-                      selfUri
+                      selfUri: this.getSelfReferUri()
                     }
                   });
                 });
@@ -19150,7 +19151,7 @@ ${log}` : log;
         this.mediaStream = await navigator.mediaDevices.getUserMedia(constrains);
         return this.mediaStream;
       };
-      const { userPart, fsIp, fsPort, iceInfo, wsUrl } = userInfo;
+      const { userPart, fsIp, fsPort, fsPassword, iceInfo, wsUrl } = userInfo;
       const connectConfig = {
         uri: UserAgent.makeURI(`sip:${userPart}@${fsIp}:${fsPort}`),
         displayName: userPart,
@@ -19160,6 +19161,8 @@ ${log}` : log;
         },
         logLevel: "error",
         allowLegacyNotifications: true,
+        authorizationPassword: fsPassword,
+        authorizationUsername: userPart,
         contactName: userPart,
         contactParams: { transport: "wss" },
         sessionDescriptionHandlerFactory: web_exports.defaultSessionDescriptionHandlerFactory(localStreamFactory),
@@ -19873,6 +19876,199 @@ ${log}` : log;
       }
       this.currentSession.refer(target, extra?.sessionReferOptions);
     }
+    /**
+     * Get the SIP URI for "refer to self" (same as reconnection refer logic).
+     * Shared by referInCallToSelf and internal reconnection refer.
+     */
+    getSelfReferUri() {
+      const { userInfo } = this.callKit.config.getConfig();
+      const { userPart, fsIp, fsPort } = userInfo;
+      return `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+    }
+    /**
+     * Whether we can refer the current call to self (has active session in Established/Establishing and is calling).
+     * Shared by reconnection logic and referInCallToSelf.
+     */
+    canReferInCallToSelf() {
+      return !!this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling();
+    }
+    /**
+     * Refer the current call to self (e.g. Agent RTP loss recovery, post-reconnect recovery).
+     * Socket and other callers can use this without constructing referTo.
+     */
+    async referInCallToSelf(callUuid, extra) {
+      if (callUuid && this.currentCallId !== callUuid) {
+        this.callKit.logger.warn(
+          "Cannot refer in call to self: callUuid mismatch",
+          {
+            caller: "Connect.referInCallToSelf",
+            type: "SIP",
+            content: {
+              currentCallId: this.currentCallId,
+              callUuid
+            }
+          }
+        );
+        return;
+      }
+      if (!this.canReferInCallToSelf()) {
+        this.callKit.logger.warn(
+          "Cannot refer in call to self: preconditions not met",
+          {
+            caller: "Connect.referInCallToSelf",
+            type: "SIP",
+            content: {
+              hasCurrentSession: !!this.currentSession,
+              sessionState: this.currentSession?.state,
+              isCalling: this.isCalling()
+            }
+          }
+        );
+        return;
+      }
+      const selfUri = this.getSelfReferUri();
+      return this.referInCall(selfUri, extra);
+    }
+  };
+
+  // core/heartbeat-worker.ts
+  var workerCode = `
+let timer = null;
+let interval = 30000;
+
+self.onmessage = function(e) {
+  const { type, interval: newInterval } = e.data;
+  
+  if (type === 'start') {
+    if (timer) {
+      clearInterval(timer);
+    }
+    interval = newInterval || interval;
+    timer = setInterval(() => {
+      self.postMessage({ type: 'tick' });
+    }, interval);
+  }
+  
+  if (type === 'stop') {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  
+  if (type === 'updateInterval') {
+    interval = newInterval;
+    if (timer) {
+      clearInterval(timer);
+      timer = setInterval(() => {
+        self.postMessage({ type: 'tick' });
+      }, interval);
+    }
+  }
+};
+`;
+  function createHeartbeatWorker() {
+    try {
+      const blob = new Blob([workerCode], { type: "application/javascript" });
+      const workerUrl = URL.createObjectURL(blob);
+      const worker = new Worker(workerUrl);
+      URL.revokeObjectURL(workerUrl);
+      return worker;
+    } catch {
+      return null;
+    }
+  }
+  var HeartbeatManager = class {
+    worker = null;
+    fallbackTimer = null;
+    interval = 3e4;
+    onTick = null;
+    isRunning = false;
+    constructor() {
+      this.worker = createHeartbeatWorker();
+      if (this.worker) {
+        this.worker.onmessage = (e) => {
+          if (e.data.type === "tick" && this.onTick) {
+            this.onTick();
+          }
+        };
+      }
+    }
+    /**
+     * Start the heartbeat
+     * @param interval - Interval in milliseconds
+     * @param onTick - Callback function to execute on each tick
+     */
+    start(interval, onTick) {
+      this.stop();
+      this.interval = interval;
+      this.onTick = onTick;
+      this.isRunning = true;
+      if (this.worker) {
+        this.worker.postMessage({
+          type: "start",
+          interval
+        });
+      } else {
+        this.fallbackTimer = setInterval(() => {
+          if (this.onTick) {
+            this.onTick();
+          }
+        }, interval);
+      }
+    }
+    /**
+     * Stop the heartbeat
+     */
+    stop() {
+      this.isRunning = false;
+      this.onTick = null;
+      if (this.worker) {
+        this.worker.postMessage({ type: "stop" });
+      }
+      if (this.fallbackTimer) {
+        clearInterval(this.fallbackTimer);
+        this.fallbackTimer = null;
+      }
+    }
+    /**
+     * Update the heartbeat interval
+     * @param interval - New interval in milliseconds
+     */
+    updateInterval(interval) {
+      this.interval = interval;
+      if (!this.isRunning)
+        return;
+      if (this.worker) {
+        this.worker.postMessage({
+          type: "updateInterval",
+          interval
+        });
+      } else if (this.fallbackTimer && this.onTick) {
+        clearInterval(this.fallbackTimer);
+        this.fallbackTimer = setInterval(() => {
+          if (this.onTick) {
+            this.onTick();
+          }
+        }, interval);
+      }
+    }
+    /**
+     * Destroy the heartbeat manager and release resources
+     */
+    destroy() {
+      this.stop();
+      if (this.worker) {
+        this.worker.terminate();
+        this.worker = null;
+      }
+    }
+    /**
+     * Check if using Web Worker
+     */
+    isUsingWorker() {
+      return this.worker !== null;
+    }
   };
 
   // core/socket.ts
@@ -19880,7 +20076,7 @@ ${log}` : log;
     callKit;
     ws;
     lastPingTime = void 0;
-    pingTimer;
+    heartbeatManager;
     /**
      * @description reconnect timer
      */
@@ -19913,9 +20109,32 @@ ${log}` : log;
     }
     constructor(callKit) {
       this.callKit = callKit;
+      this.heartbeatManager = new HeartbeatManager();
+    }
+    get isUserSetPingTryCount() {
+      const { userInfo } = this.callKit.config.getConfig();
+      const { pingTryCount } = userInfo;
+      return Number.isInteger(pingTryCount) && pingTryCount > 0;
     }
     get reconnectConfig() {
-      return this.callKit.config.getReconnectConfig("incall");
+      const incallConfig = this.callKit.config.getReconnectConfig("incall");
+      const { userInfo } = this.callKit.config.getConfig();
+      const { pingTryCount, pingTryCountInterval } = userInfo;
+      if (pingTryCount > 0) {
+        return {
+          ...incallConfig,
+          maxAttempts: pingTryCount,
+          interval: pingTryCountInterval * 1e3
+        };
+      }
+      return incallConfig;
+    }
+    get pingInterval() {
+      const { keepaliveInterval } = this.callKit.config.getConfig().userInfo;
+      if (Number.isInteger(keepaliveInterval) && keepaliveInterval > 0) {
+        return keepaliveInterval * 1e3;
+      }
+      return this.reconnectConfig.pingInterval;
     }
     isConnected() {
       return this.connectAuthState.isConnected;
@@ -19940,7 +20159,17 @@ ${log}` : log;
       this.setConnectAuthState("isConnected", false);
       const { enabled } = this.reconnectConfig;
       if (!this.callKit.config.isLogin() || !enabled) {
-        this.callKit.reset();
+        if (this.callKit.connect.isCalling()) {
+          this.callKit.logger.warn("Disconnect during call, delay reset", {
+            caller: "Socket.handleDisconnect",
+            type: "INCALL",
+            content: {
+              connectStatus: this.callKit.connect.connectStatus
+            }
+          });
+        } else {
+          this.callKit.reset();
+        }
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
@@ -20098,6 +20327,28 @@ ${log}` : log;
         this.setConnectAuthState("startConfirm", true);
         this.cleanReconnectState();
       }
+      if (data.event === SocketReceiveEvent.AGENT_RTP_LOSS) {
+        this.callKit.logger.warn("Agent RTP loss", {
+          caller: "Socket.onMessage",
+          type: "INCALL",
+          content: {
+            data: {
+              callUuid,
+              ...content
+            },
+            event: SocketReceiveEvent.AGENT_RTP_LOSS
+          }
+        });
+        if (callUuid) {
+          this.callKit.connect.referInCallToSelf(callUuid).catch((err) => {
+            this.callKit.logger.error(err, {
+              caller: "Socket.onMessage:AGENT_RTP_LOSS",
+              type: "INCALL",
+              content: { callUuid, event: SocketReceiveEvent.AGENT_RTP_LOSS }
+            });
+          });
+        }
+      }
       if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
         this.callKit.trigger(KitEvent.CALL_RINGING, {
           time: /* @__PURE__ */ new Date(),
@@ -20146,6 +20397,18 @@ ${log}` : log;
         this.send(SocketSendEvent.END, { agentId: userInfo.agentId, callUuid });
       }
       if (data.event === SocketReceiveEvent.ERROR) {
+        if (this.callKit.connect.isCalling()) {
+          this.callKit.logger.warn("socket onMessage error during call, ignore", {
+            caller: "Socket.onMessage",
+            type: "INCALL",
+            content: {
+              errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+              isCalling: this.callKit.connect.isCalling(),
+              data: content
+            }
+          });
+          return;
+        }
         this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error(data.msg, {
@@ -20154,20 +20417,24 @@ ${log}` : log;
           content: {
             errCode: ErrorCode.SOKET_SERVER_ERROR,
             data: content,
-            callUuid
+            callUuid,
+            delayReset: this.callKit.connect.isCalling()
           }
         });
       }
       if (data.event === SocketReceiveEvent.SESSION_ERROR) {
         this.setConnectAuthState("isError", true);
-        this.callKit.reset();
+        if (!this.callKit.connect.isCalling()) {
+          this.callKit.reset();
+        }
         this.callKit.logger.error(data.msg, {
           caller: `Socket.onMessage:${data.event}`,
           type: "INCALL",
           content: {
             data: content,
             event: SocketReceiveEvent.SESSION_ERROR,
-            callUuid
+            callUuid,
+            delayReset: this.callKit.connect.isCalling()
           }
         });
       }
@@ -20199,6 +20466,18 @@ ${log}` : log;
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
+        if (this.callKit.connect.isCalling()) {
+          this.callKit.logger.warn("socket send during call, ignore", {
+            caller: "Socket.onMessage",
+            type: "INCALL",
+            content: {
+              errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+              isCalling: this.callKit.connect.isCalling(),
+              data: message
+            }
+          });
+          return;
+        }
         this.callKit.reset();
         this.callKit.logger.error("socket not connected", {
           caller: "Socket.send",
@@ -20251,8 +20530,8 @@ ${log}` : log;
         return;
       this.send(SocketSendEvent.PING);
       const now = Date.now();
-      const { pingInterval, pingTimeout } = this.reconnectConfig;
-      if (now - this.lastPingTime > pingInterval + pingTimeout) {
+      const { pingTimeout } = this.reconnectConfig;
+      if (now - this.lastPingTime > this.pingInterval + pingTimeout) {
         this.callKit.logger.warn("Ping timeout not connected", {
           caller: "Socket.ping",
           type: "INCALL",
@@ -20264,26 +20543,48 @@ ${log}` : log;
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_PING_TIMEOUT"
         });
+        if (this.isUserSetPingTryCount) {
+          this.handlePingTimeout();
+        }
       }
     }
+    handlePingTimeout() {
+      const { userInfo } = this.callKit.config.getConfig();
+      const { pingTryCount, pingTryCountInterval } = userInfo;
+      this.callKit.logger.warn("Ping timeout, user set ping try count", {
+        caller: "Socket.handlePingTimeout",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_PING_TIMEOUT,
+          isUserSetPingTryCount: this.isUserSetPingTryCount,
+          pingTryCount,
+          pingTryCountInterval
+        }
+      });
+      this.attemptReconnect();
+    }
     checkPing() {
-      if (this.pingTimer) {
-        clearInterval(this.pingTimer);
-      }
-      const { pingInterval } = this.reconnectConfig;
-      this.pingTimer = setInterval(() => {
+      this.heartbeatManager.start(this.pingInterval, () => {
         this.ping();
-      }, pingInterval);
+      });
+      this.callKit.logger.info(
+        `Heartbeat started with Worker: ${this.heartbeatManager.isUsingWorker()}`,
+        {
+          caller: "Socket.checkPing",
+          type: "INCALL",
+          content: {
+            pingInterval: this.pingInterval,
+            usingWorker: this.heartbeatManager.isUsingWorker()
+          }
+        }
+      );
     }
     /**
      * reset socket connection and all states
      */
     async reset(config) {
       const { force = false } = config || {};
-      if (this.pingTimer) {
-        clearInterval(this.pingTimer);
-        this.pingTimer = void 0;
-      }
+      this.heartbeatManager.stop();
       if (force) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RESET"
@@ -20294,6 +20595,12 @@ ${log}` : log;
       this.setConnectAuthState("startConfirm", false);
       this.clearWebSocket();
     }
+    /**
+     * Destroy the heartbeat manager
+     */
+    destroyHeartbeat() {
+      this.heartbeatManager.destroy();
+    }
     attemptReconnect() {
       if (this.reconnectTimer) {
         clearTimeout(this.reconnectTimer);
@@ -20301,19 +20608,40 @@ ${log}` : log;
       }
       const { maxAttempts } = this.reconnectConfig;
       if (this.reconnectAttempts >= maxAttempts) {
+        if (this.callKit.connect.isCalling()) {
+          this.callKit.logger.warn("reconnect during call, ignore", {
+            caller: "Socket.attemptReconnect",
+            type: "INCALL",
+            content: {
+              errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+              isCalling: this.callKit.connect.isCalling(),
+              reconnectAttempts: this.reconnectAttempts
+            }
+          });
+          return;
+        }
+        if (this.isUserSetPingTryCount) {
+          this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+            event: "INCALL_PING_TIMEOUT_RECONNECT_FAILED_MAX_ATTEMPTS"
+          });
+        }
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_ERROR"
         });
         this.setConnectAuthState("isError", true);
         this.callKit.reset();
-        this.callKit.logger.error("Maximum reconnection attempts reached", {
-          caller: "Socket.attemptReconnect",
-          type: "INCALL",
-          content: {
-            errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
-            reconnectAttempts: this.reconnectAttempts
+        this.callKit.logger.warn(
+          "Maximum reconnection attempts reached, trigger reset",
+          {
+            caller: "Socket.attemptReconnect",
+            type: "INCALL",
+            content: {
+              errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+              reconnectAttempts: this.reconnectAttempts,
+              delayReset: this.callKit.connect.isCalling()
+            }
           }
-        });
+        );
         return;
       }
       if (this.reconnectAttempts === 0) {
@@ -20419,6 +20747,7 @@ ${log}` : log;
         content: {
           username,
           password,
+          ua: navigator.userAgent,
           encryptionMethod,
           encryptionPassword
         }
@@ -20452,6 +20781,9 @@ ${log}` : log;
             iceInfo: user.iceInfo,
             iceGatheringTimeout: user.iceGatheringTimeout,
             logGather: user.logGather,
+            keepaliveInterval: user.keepaliveInterval,
+            pingTryCount: user?.pingTryCount,
+            pingTryCountInterval: user?.pingTryCountInterval,
             phoneType: user.phoneType,
             // encryptionType is in extra
             ...extra