@koi-design/callkit 1.0.24-beta.27 → 1.0.24-beta.29

package/dist/index.d.ts

@@ -100,6 +100,10 @@ declare const KitEvent: {
      * Server initiated call
      */
     KIT_INVITE: string;
+    /**
+     * Server outgoing initiated call
+     */
+    KIT_OUTGOING_INVITE: string;
     /**
      * Connecting
      */
@@ -189,15 +193,30 @@ declare const EncryptionMethod: {
     INTERNAL: string;
 };
 type EncryptionMethodType = (typeof EncryptionMethod)[keyof typeof EncryptionMethod];
+declare const LogGatherEnum: {
+    ENABLE: number;
+    DISABLE: number;
+};
+type LogGatherEnumType = (typeof LogGatherEnum)[keyof typeof LogGatherEnum];
 declare const CallSourceType: {
     phoneNum: number;
     workOrderId: number;
 };
 
 type LoggerLevel = 'debug' | 'log' | 'warn' | 'error' | 'silent';
+declare const LogDataEnum: {
+    readonly SIP: "sip";
+    readonly INCALL: "incall";
+    readonly AJAX: "ajax";
+    readonly ERROR: "error";
+    readonly RECONNECT: "reconnect";
+    readonly ALL: "all";
+};
+type LogDataType = (typeof LogDataEnum)[keyof typeof LogDataEnum];
 declare class Logger {
     prefix: string;
     level: LoggerLevel;
+    logData: Record<LogDataType, any[]>;
     private callKit;
     constructor(callKit: CallKit, level?: LoggerLevel);
     setLevel(level: LoggerLevel): void;
@@ -205,6 +224,7 @@ declare class Logger {
     log(msg: any, extra?: Object): void;
     warn(msg: any, extra?: Object): void;
     error(msg: any, extra?: any): void;
+    addLogData(type: LogDataType, data: any): void;
     output(color: string): (msg: any, extra?: Object) => void;
 }
 
@@ -288,6 +308,7 @@ interface IConfig {
         iceInfo: string[];
         iceGatheringTimeout: number;
         encryptionMethod: EncryptionMethodType;
+        logGather: LogGatherEnumType;
     };
     isAutoUpdateUserStatus: boolean;
 }
@@ -301,6 +322,7 @@ declare class Config {
     reset: () => void;
     validate: () => boolean;
     isLogin: () => boolean;
+    isLogGatherEnable: () => boolean;
     check(): boolean;
 }
 

package/dist/index.global.js

@@ -3161,6 +3161,37 @@ var WebCall = (() => {
     }
   });
 
+  // node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js
+  var require_stringify = __commonJS({
+    "node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js"(exports, module) {
+      exports = module.exports = stringify2;
+      exports.getSerialize = serializer;
+      function stringify2(obj, replacer, spaces, cycleReplacer) {
+        return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+      }
+      function serializer(replacer, cycleReplacer) {
+        var stack = [], keys = [];
+        if (cycleReplacer == null)
+          cycleReplacer = function(key, value) {
+            if (stack[0] === value)
+              return "[Circular ~]";
+            return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+          };
+        return function(key, value) {
+          if (stack.length > 0) {
+            var thisPos = stack.indexOf(this);
+            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+            if (~stack.indexOf(value))
+              value = cycleReplacer.call(this, key, value);
+          } else
+            stack.push(value);
+          return replacer == null ? value : replacer.call(this, key, value);
+        };
+      }
+    }
+  });
+
   // package/index.ts
   var package_exports = {};
   __export(package_exports, {
@@ -3335,6 +3366,10 @@ var WebCall = (() => {
      * Server initiated call
      */
     KIT_INVITE: "invite",
+    /**
+     * Server outgoing initiated call
+     */
+    KIT_OUTGOING_INVITE: "outgoingInvite",
     // /**
     //  * Referral
     //  */
@@ -3578,6 +3613,10 @@ var WebCall = (() => {
     NONE: "NONE",
     INTERNAL: "INTERNAL"
   };
+  var LogGatherEnum = {
+    ENABLE: 1,
+    DISABLE: 2
+  };
   var constrainsDefault = {
     audio: {
       autoGainControl: true,
@@ -3597,9 +3636,11 @@ var WebCall = (() => {
     SIP_CONNECT_ERROR: "SIP_CONNECT_ERROR",
     SIP_RECONNECT_ERROR: "SIP_RECONNECT_ERROR",
     SIP_RECONNECT_SUCCESS: "SIP_RECONNECT_SUCCESS",
+    SIP_RECONNECTING: "SIP_RECONNECTING",
     INCALL_CONNECT_ERROR: "INCALL_CONNECT_ERROR",
     INCALL_RECONNECT_ERROR: "INCALL_RECONNECT_ERROR",
     INCALL_RECONNECT_SUCCESS: "INCALL_RECONNECT_SUCCESS",
+    INCALL_RECONNECTING: "INCALL_RECONNECTING",
     OPTIONS_HEARTBEAT_EXPIRED: "OPTIONS_HEARTBEAT_EXPIRED",
     USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR"
   };
@@ -3723,7 +3764,8 @@ var WebCall = (() => {
         fsPort: "",
         iceInfo: [],
         iceGatheringTimeout: 0,
-        encryptionMethod: EncryptionMethod.INTERNAL
+        encryptionMethod: EncryptionMethod.INTERNAL,
+        logGather: LogGatherEnum.DISABLE
       },
       // EXECUTE setUserStatus
       isAutoUpdateUserStatus: true
@@ -3755,7 +3797,8 @@ var WebCall = (() => {
           fsPort: "",
           iceInfo: [],
           iceGatheringTimeout: this.config.userInfo.iceGatheringTimeout,
-          encryptionMethod: EncryptionMethod.INTERNAL
+          encryptionMethod: EncryptionMethod.INTERNAL,
+          logGather: LogGatherEnum.DISABLE
         };
         this.callKit.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
       }
@@ -3768,6 +3811,7 @@ var WebCall = (() => {
       return true;
     };
     isLogin = () => this.validate();
+    isLogGatherEnable = () => this.config.userInfo.logGather === LogGatherEnum.ENABLE;
     check() {
       if (!this.isLogin()) {
         this.callKit.logger.error("User not logged in", {
@@ -3780,16 +3824,41 @@ var WebCall = (() => {
   };
 
   // package/logger.ts
+  var import_json_stringify_safe = __toESM(require_stringify());
+  var LogDataEnum = {
+    SIP: "sip",
+    INCALL: "incall",
+    AJAX: "ajax",
+    ERROR: "error",
+    RECONNECT: "reconnect",
+    ALL: "all"
+  };
   function getLevel(level) {
     return LoggerLevelMap[level];
   }
   var Logger = class {
     prefix = "CallKit";
     level = "debug";
+    logData = {
+      sip: [],
+      incall: [],
+      ajax: [],
+      error: [],
+      reconnect: [],
+      all: []
+    };
     callKit;
     constructor(callKit, level) {
       this.callKit = callKit;
       this.level = level || "debug";
+      this.logData = {
+        sip: [],
+        incall: [],
+        ajax: [],
+        error: [],
+        reconnect: [],
+        all: []
+      };
     }
     setLevel(level) {
       this.level = level;
@@ -3828,6 +3897,60 @@ var WebCall = (() => {
       error.data = rest;
       throw error;
     }
+    addLogData(type, data) {
+      if (!this.callKit.config.isLogGatherEnable()) {
+        return;
+      }
+      let logData = {
+        type,
+        timestamp: (/* @__PURE__ */ new Date()).valueOf(),
+        time: (/* @__PURE__ */ new Date()).toLocaleString(),
+        data: ""
+      };
+      if (type === LogDataEnum.INCALL) {
+        logData.data = (0, import_json_stringify_safe.default)({
+          // customField
+          callKitSocketFrom: data?.callKitSocketFrom,
+          type: data?.ev.type || data?.type,
+          data: data?.ev.data || data?.data,
+          // message
+          origin: data?.ev.origin || data?.origin,
+          lastEventId: data?.ev.lastEventId || data?.lastEventId,
+          isTrusted: data?.ev.isTrusted || data?.isTrusted,
+          // close
+          code: data?.ev.code || data?.code,
+          reason: data?.ev.reason || data?.reason,
+          wasClean: data?.ev.wasClean || data?.wasClean
+        });
+      } else {
+        logData = (0, import_json_stringify_safe.default)(data);
+      }
+      switch (type) {
+        case LogDataEnum.SIP:
+          this.logData.sip.push(logData);
+          this.logData.all.push(logData);
+          break;
+        case LogDataEnum.INCALL:
+          this.logData.incall.push(logData);
+          this.logData.all.push(logData);
+          break;
+        case LogDataEnum.AJAX:
+          this.logData.ajax.push(logData);
+          this.logData.all.push(logData);
+          break;
+        case LogDataEnum.RECONNECT:
+          this.logData.reconnect.push(logData);
+          this.logData.all.push(logData);
+          break;
+        case LogDataEnum.ERROR:
+          this.logData.error.push(logData);
+          this.logData.all.push(logData);
+          break;
+        default:
+          this.logData.all.push(logData);
+          break;
+      }
+    }
     output(color) {
       return (msg, extra = {}) => {
         const now = /* @__PURE__ */ new Date();
@@ -18520,6 +18643,11 @@ var WebCall = (() => {
                 lastOptionsUpdateTime: that.lastOptionsUpdateTime,
                 now
               });
+              that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+                event: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
+                lastOptionsUpdateTime: that.lastOptionsUpdateTime,
+                now
+              });
               that.clearObserveOptionsHeartbeatInterval();
             }
           }
@@ -18531,6 +18659,7 @@ var WebCall = (() => {
           if (request2.method === "OPTIONS") {
             that.lastOptionsUpdateTime = (/* @__PURE__ */ new Date()).getTime();
           }
+          that.callKit.logger.addLogData(LogDataEnum.SIP, request2);
           return originalReceiveRequest(request2);
         };
       };
@@ -18576,6 +18705,20 @@ var WebCall = (() => {
           };
           if (this.isOutgoing) {
             this.currentSession.accept(options);
+            this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
+              getInviteData: () => {
+                const { request: request2 } = this.currentSession;
+                const headerNames = Object.keys(request2.headers);
+                const xHeaders = {};
+                headerNames.filter(
+                  (name) => name.toLocaleLowerCase().startsWith("x-antaios")
+                ).forEach((name) => {
+                  xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
+                });
+                this.callKit.logger.debug("get invite data", xHeaders);
+                return xHeaders;
+              }
+            });
           } else {
             this.callKit.trigger(KitEvent.KIT_INVITE, {
               accept: () => {
@@ -18961,12 +19104,21 @@ var WebCall = (() => {
           "socket reconnect times",
           this.socketConfig.maxAttempts
         );
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_RECONNECTING,
+          attempts: this.reconnectAttempts,
+          err: ev
+        });
         this.attemptReconnect();
       } else if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
         this.callKit.trigger(KitEvent.CONNECT_EVENT, {
           event: ConnectEvent.INCALL_RECONNECT_ERROR,
           err: ev
         });
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_RECONNECT_ERROR,
+          err: ev
+        });
         this.reset();
         this.callKit.logger.error(
           "Reconnection failed, maximum retry attempts reached",
@@ -18985,6 +19137,10 @@ var WebCall = (() => {
     }
     onOpen(ev) {
       this.callKit.logger.debug("socket onOpen", ev);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onOpen",
+        ev
+      });
       this.isConnected = true;
       this.lastPingTime = Date.now();
       this.checkPing();
@@ -19003,11 +19159,19 @@ var WebCall = (() => {
     }
     onClose(ev) {
       this.callKit.logger.debug("socket onClose", ev);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onClose",
+        ev
+      });
       if ((ev.code !== 1e3 || !ev.wasClean) && this.callKit.connect.isRegistered()) {
         this.callKit.trigger(KitEvent.CONNECT_EVENT, {
           event: ConnectEvent.INCALL_CONNECT_ERROR,
           err: ev
         });
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_CONNECT_ERROR,
+          err: ev
+        });
         this.reconnect(ev);
       } else {
         this.isConnected = false;
@@ -19025,6 +19189,10 @@ var WebCall = (() => {
         errCode: ErrorCode.SOCKET_CONNECT_ERROR,
         data: ev
       });
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onError",
+        ev
+      });
       if (this.isReconnecting) {
         this.attemptReconnect();
       }
@@ -19032,6 +19200,10 @@ var WebCall = (() => {
     onMessage(ev) {
       const data = JSON.parse(ev.data);
       this.callKit.logger.debug("socket onMessage", data);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onMessage",
+        ev
+      });
       if (data.event === SocketReceiveEvent.PONG) {
         this.lastPingTime = Date.now();
         return;
@@ -19288,16 +19460,37 @@ var WebCall = (() => {
         this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, UserStatus.offline);
         return;
       }
-      await this.callKit.api.setUserStatus({
+      const postData = {
         agentId,
         userStatus: status
-      }).then(() => {
+      };
+      const logData = {
+        postData,
+        url: "/agent/user/changeStatus",
+        status: "send",
+        startTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        startTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      };
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, logData);
+      await this.callKit.api.setUserStatus(postData).then(() => {
         this.userStatus = status;
         this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, status);
+        this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+          ...logData,
+          status: "success",
+          endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+          endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+        });
       }).catch((err) => {
         this.callKit.logger.error(err, {
           errCode: ErrorCode.API_USER_STATUS_UPDATE_ERROR
         });
+        this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+          ...logData,
+          status: "error",
+          endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+          endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+        });
       });
     }
     async sendHangUpReason(data) {
@@ -19390,6 +19583,7 @@ var WebCall = (() => {
           fsPort: user.fsPort,
           iceInfo: user.iceInfo,
           iceGatheringTimeout: user.iceGatheringTimeout,
+          logGather: user.logGather,
           // encryptionType is in extra
           ...extra
         });