@webex/calling 3.12.0-mobius-socket.19 → 3.12.0-mobius-socket.20

package/dist/mobius-socket/mobius-socket.js

@@ -17,7 +17,6 @@ var _isArray = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/ar
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
 var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
 var _typeof2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/typeof"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
@@ -26,6 +25,7 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _get2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/get"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _events = require("events");
 var _backoff = _interopRequireDefault(require("backoff"));
 var _socket = _interopRequireDefault(require("./socket"));
@@ -34,14 +34,15 @@ function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymb
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-nocheck
-/* eslint-disable require-jsdoc */ /*!
+function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file
- */
+ */ // @ts-ignore - backoff library does not have type definitions
 var normalReconnectReasons = ['idle', 'done (forced)'];
 var MOBIUS_SOCKET_NAMESPACE = 'MobiusSocket';
 var TOKEN_REFRESH_INTERVAL_MS = 1 * 60 * 60 * 1000; // 1 hour
 
+// Extended Socket type with dynamic properties
+
 function normalizeMobiusAuthToken(token) {
   return token.replace(/^Bearer\s+/i, '');
 }
@@ -51,6 +52,22 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
     var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     (0, _classCallCheck2.default)(this, MobiusSocket);
     _this = _callSuper(this, MobiusSocket);
+    (0, _defineProperty2.default)(_this, "webex", void 0);
+    (0, _defineProperty2.default)(_this, "config", void 0);
+    (0, _defineProperty2.default)(_this, "logger", void 0);
+    (0, _defineProperty2.default)(_this, "connected", void 0);
+    (0, _defineProperty2.default)(_this, "connecting", void 0);
+    (0, _defineProperty2.default)(_this, "hasEverConnected", void 0);
+    (0, _defineProperty2.default)(_this, "socket", void 0);
+    (0, _defineProperty2.default)(_this, "backoffCall", void 0);
+    // backoff library has no types
+    (0, _defineProperty2.default)(_this, "shutdownSwitchoverBackoffCall", void 0);
+    // backoff library has no types
+    (0, _defineProperty2.default)(_this, "seenAsyncEventIds", void 0);
+    (0, _defineProperty2.default)(_this, "connectPromise", void 0);
+    (0, _defineProperty2.default)(_this, "socketUrl", void 0);
+    (0, _defineProperty2.default)(_this, "tokenRefreshTimer", void 0);
+    (0, _defineProperty2.default)(_this, "tokenRefreshInFlight", void 0);
     if (!webex) {
       throw new Error('A Webex instance is required when initializing MobiusSocket');
     }
@@ -82,8 +99,7 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Attach event listeners to a socket.
-     * @param {Socket} socket - The socket to attach listeners to
-     * @returns {void}
+     * @param socket - The socket to attach listeners to
      */
   }, {
     key: "attachSocketEventListeners",
@@ -92,15 +108,15 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       socket.on('close', function (event) {
         return _this2.onclose(event, socket);
       });
-      socket.on('message', function () {
-        return _this2.onmessage.apply(_this2, arguments);
+      socket.on('message', function (event) {
+        return _this2.onmessage(event);
       });
     }
 
     /**
      * Tracks a newly seen async_event ID and reports whether a duplicate should be suppressed.
-     * @param {object} envelope - Parsed websocket message envelope.
-     * @returns {boolean} True when the event has already been seen.
+     * @param envelope - Parsed websocket message envelope
+     * @returns True when the event has already been seen
      */
   }, {
     key: "trackAsyncEventAndShouldSuppressDuplicate",
@@ -111,7 +127,7 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       if (this.seenAsyncEventIds.has(envelope.eventId)) {
         // Refresh recency so frequently retransmitted eventIds stay protected longer.
         // This deletion and setting again makes the data recent since javascript map maintains order as well
-        var previousValue = this.seenAsyncEventIds.get(envelope.eventId);
+        var previousValue = this.seenAsyncEventIds.get(envelope.eventId) || true;
         this.seenAsyncEventIds.delete(envelope.eventId);
         this.seenAsyncEventIds.set(envelope.eventId, previousValue);
         this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": duplicate async_event suppressed, eventId=").concat(envelope.eventId));
@@ -119,8 +135,8 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }
       this.logger.log("".concat(MOBIUS_SOCKET_NAMESPACE, ": tracking async_event, eventId=").concat(envelope.eventId));
       this.seenAsyncEventIds.set(envelope.eventId, true);
-      if (this.seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
-        var oldestEventId = this.seenAsyncEventIds.keys().next().value;
+      if (this.config.dedupCacheMaxSize && this.seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
+        var oldestEventId = this.seenAsyncEventIds.keys().next().value || '';
         this.seenAsyncEventIds.delete(oldestEventId);
         this.logger.log("".concat(MOBIUS_SOCKET_NAMESPACE, ": evicted oldest async_event from dedup cache, eventId=").concat(oldestEventId));
       }
@@ -182,7 +198,7 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Get the websocket URL for the currently connected socket.
-     * @returns {string|undefined} The connected websocket URL, or undefined when not connected.
+     * @returns The connected websocket URL, or undefined when not connected
      */
   }, {
     key: "getConnectedWebSocketUrl",
@@ -196,14 +212,13 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Sends a websocket request and resolves when the matching response arrives.
-     * @param {MobiusSocketRequestPayload} payload - The websocket request payload.
-     * @param {MobiusSocketRequestOptions} [options={}] - Additional request options.
-     * @returns {Promise<SocketResponse>}
+     * @param payload - The websocket request payload
+     * @param options - Additional request options
+     * @returns Promise that resolves with the socket response
      */
   }, {
     key: "sendWssRequest",
     value: function sendWssRequest(payload) {
-      var _this4 = this;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       if (!payload || (0, _typeof2.default)(payload) !== 'object' || (0, _isArray.default)(payload)) {
         return _promise.default.reject(new Error('`payload` is required'));
@@ -211,34 +226,14 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       if (!this.socket || !this.socket.connected) {
         return _promise.default.reject(new Error('Mobius socket is not connected'));
       }
-      var requestConfigOptions = {
-        timeout: options.timeout,
-        matchesResponse: function matchesResponse(response, request) {
-          return (response === null || response === void 0 ? void 0 : response.type) === 'response_event' && (response === null || response === void 0 ? void 0 : response.subtype) === request.type && (response === null || response === void 0 ? void 0 : response.trackingId) === request.trackingId;
-        },
-        getStatusCode: function getStatusCode(response) {
-          return response === null || response === void 0 ? void 0 : response.statusCode;
-        },
-        getStatusMessage: function getStatusMessage(response) {
-          return response === null || response === void 0 ? void 0 : response.statusMessage;
-        },
-        createError: function createError(response, statusCode, statusMessage) {
-          return _this4.createWssResponseError(response, statusCode, statusMessage);
-        },
-        createTimeoutError: function createTimeoutError(request) {
-          return _this4.createWssResponseError({
-            type: 'response_event',
-            subtype: request.type,
-            trackingId: request.trackingId
-          }, 408, 'Mobius websocket response timed out');
-        }
-      };
-      return this.socket.sendRequest(payload, requestConfigOptions);
+      return this.socket.sendRequest(payload, {
+        timeout: options.timeout
+      });
     }
 
     /**
      * Check if the socket is connected.
-     * @returns {boolean} True if connected.
+     * @returns True if connected
      */
   }, {
     key: "isConnected",
@@ -248,15 +243,17 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Connect to Mobius.
-     * @param {string} [webSocketUrl] - Optional websocket URL override. Falls back to the device websocket URL.
-     * @returns {Promise<void>} Resolves when connection flow completes.
+     * @param webSocketUrl - Optional websocket URL override. Falls back to the device websocket URL
+     * @returns Promise that resolves when connection flow completes
      */
   }, {
     key: "connect",
     value: function connect(webSocketUrl) {
       var _this$socket2,
         _this$socket3,
-        _this5 = this;
+        _this$webex$internal$,
+        _this$webex$internal$2,
+        _this4 = this;
       if (this.connectPromise) {
         this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection already in progress, returning existing promise"));
         return this.connectPromise;
@@ -278,11 +275,11 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }
       this.connecting = true;
       this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": starting connection attempt").concat(Number(this.config.initialConnectionMaxRetries) === 0 && !this.hasEverConnected ? ' (initial retries disabled)' : ''));
-      var connectPromise = _promise.default.resolve(this.webex.internal.device.registered || this.webex.internal.device.register()).then(function () {
-        _this5.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connecting"));
-        return _this5.connectWithBackoff(_this5.socketUrl);
+      var connectPromise = _promise.default.resolve(this.webex.internal.device.registered || ((_this$webex$internal$ = (_this$webex$internal$2 = this.webex.internal.device).register) === null || _this$webex$internal$ === void 0 ? void 0 : _this$webex$internal$.call(_this$webex$internal$2))).then(function () {
+        _this4.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connecting"));
+        return _this4.connectWithBackoff(_this4.socketUrl);
       }).finally(function () {
-        _this5.connectPromise = undefined;
+        _this4.connectPromise = undefined;
       });
       this.connectPromise = connectPromise;
       return connectPromise;
@@ -290,13 +287,13 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
 
     /**
      * Disconnect the Mobius socket.
-     * @param {MobiusSocketCloseOptions} [options] - Optional websocket close options (code, reason).
-     * @returns {Promise<void>} Resolves after disconnect cleanup and close handling complete.
+     * @param options - Optional websocket close options (code, reason)
+     * @returns Promise that resolves after disconnect cleanup and close handling complete
      */
   }, {
     key: "disconnect",
     value: function disconnect(options) {
-      var _this6 = this;
+      var _this5 = this;
       this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, "#disconnect: connecting state: ").concat(this.connecting, ",\n       connected state: ").concat(this.connected, ", socket exists: ").concat(!!this.socket, ",\n       options: ").concat((0, _stringify.default)(options)));
       if (this.backoffCall) {
         this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": aborting connection"));
@@ -319,41 +316,30 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       this.socket.connecting = false;
       this.socket.connected = false;
       return _promise.default.resolve(this.socket.close(options || undefined)).finally(function () {
-        _this6.connected = false;
-        _this6.stopTokenRefreshTimer();
+        _this5.connected = false;
+        _this5.stopTokenRefreshTimer();
       });
     }
-
-    // eslint-disable-next-line class-methods-use-this
-  }, {
-    key: "createWssResponseError",
-    value: function createWssResponseError(response, statusCode, statusMessage) {
-      var error = new Error(statusMessage || "Mobius websocket request failed with status ".concat(statusCode || 'unknown'));
-      error.name = 'MobiusSocketResponseError';
-      error.statusCode = statusCode;
-      error.statusMessage = statusMessage;
-      error.response = response;
-      error.trackingId = response === null || response === void 0 ? void 0 : response.trackingId;
-      return error;
-    }
   }, {
     key: "prepareUrl",
     value: function prepareUrl(webSocketUrl) {
       if (!webSocketUrl) {
         // TODO: Circle back to this logic when mobius implements the shutdown switchover
-        webSocketUrl = this.webex.internal.device.webSocketUrl;
+        webSocketUrl = this.webex.internal.device.webSocketUrl || '';
       }
       return _promise.default.resolve(webSocketUrl);
     }
   }, {
     key: "attemptConnection",
     value: function attemptConnection(socketUrl, callback) {
-      var _this7 = this;
+      var _this6 = this;
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       var _options$isShutdownSw = options.isShutdownSwitchover,
         isShutdownSwitchover = _options$isShutdownSw === void 0 ? false : _options$isShutdownSw,
-        _options$onSuccess = options.onSuccess,
-        onSuccess = _options$onSuccess === void 0 ? null : _options$onSuccess;
+        _options$attemptOptio = options.attemptOptions,
+        attemptOptions = _options$attemptOptio === void 0 ? {} : _options$attemptOptio;
+      var _attemptOptions$onSuc = attemptOptions.onSuccess,
+        onSuccess = _attemptOptions$onSuc === void 0 ? null : _attemptOptions$onSuc;
       var socket = new _socket.default();
       socket.connecting = true;
       var newWSUrl;
@@ -378,7 +364,7 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }
       return this.prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover).then(function (webSocketUrl) {
         newWSUrl = webSocketUrl;
-        _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mobius socket, success, url: ").concat(newWSUrl));
+        _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(isShutdownSwitchover ? '[shutdown] switchover' : '', " connected to mobius socket, success, url: ").concat(newWSUrl));
 
         // Custom success handler for shutdown switchover
         if (onSuccess) {
@@ -393,52 +379,54 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       }).catch(function (reason) {
         // For shutdown, simpler error handling - just callback for retry
         if (isShutdownSwitchover) {
-          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover attempt failed"), reason);
+          _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": [shutdown] switchover attempt failed"), reason);
           return callback(reason);
         }
 
         // Normal connection error handling
-        var backoffCallNormal = _this7.backoffCall;
+        var backoffCallNormal = _this6.backoffCall;
         // Suppress connection errors that appear to be network related (code 1006).
         if (reason.code !== 1006 && backoffCallNormal && (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) > 0) {
-          _this7.emitEvent('connection_failed', reason, {
+          _this6.emitEvent('connection_failed', reason, {
             retries: backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()
           });
         }
-        _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection attempt failed"), reason, (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) === 0 ? reason.stack : '');
+        _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connection attempt failed"), reason, (backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.getNumRetries()) === 0 ? reason.stack : '');
 
         // UnknownResponse is produced by IE for any 4XXX; treat it like a bad
         // web socket url and let WDM handle the token checking
         if (reason instanceof _errors.UnknownResponse) {
-          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unknown response code, refreshing device registration"));
-          return _this7.webex.internal.device.refresh().then(function () {
+          var _this6$webex$internal, _this6$webex$internal2;
+          _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unknown response code, refreshing device registration"));
+          return (_this6$webex$internal = (_this6$webex$internal2 = _this6.webex.internal.device).refresh) === null || _this6$webex$internal === void 0 ? void 0 : _this6$webex$internal.call(_this6$webex$internal2).then(function () {
             return callback(reason);
           });
         }
         // NotAuthorized implies expired token
         if (reason instanceof _errors.NotAuthorized) {
-          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received authorization error, reauthorizing"));
-          return _this7.webex.credentials.refresh({
+          var _this6$webex$credenti, _this6$webex$credenti2;
+          _this6.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": received authorization error, reauthorizing"));
+          return (_this6$webex$credenti = (_this6$webex$credenti2 = _this6.webex.credentials).refresh) === null || _this6$webex$credenti === void 0 ? void 0 : _this6$webex$credenti.call(_this6$webex$credenti2, {
             force: true
           }).then(function () {
             return callback(reason);
           });
         }
         if (reason instanceof _errors.BadRequest || reason instanceof _errors.Forbidden) {
-          _this7.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unrecoverable response from ").concat(MOBIUS_SOCKET_NAMESPACE));
+          _this6.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": received unrecoverable response from ").concat(MOBIUS_SOCKET_NAMESPACE));
           backoffCallNormal === null || backoffCallNormal === void 0 ? void 0 : backoffCallNormal.abort();
           return callback(reason);
         }
         return callback(reason);
       }).catch(function (reason) {
-        _this7.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to handle connection failure"), reason);
+        _this6.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to handle connection failure"), reason);
         callback(reason);
       });
     }
   }, {
     key: "prepareAndOpenSocket",
     value: function prepareAndOpenSocket(socket, socketUrl) {
-      var _this8 = this;
+      var _this7 = this;
       var isShutdownSwitchover = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
       return _promise.default.all([this.prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(function (_ref) {
@@ -446,27 +434,27 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
           webSocketUrl = _ref2[0],
           token = _ref2[1];
         var options = {
-          forceCloseDelay: _this8.config.forceCloseDelay,
-          wssResponseTimeout: _this8.config.wssResponseTimeout,
+          forceCloseDelay: _this7.config.forceCloseDelay,
+          wssResponseTimeout: _this7.config.wssResponseTimeout,
           token: normalizeMobiusAuthToken(token.toString()),
           refreshToken: function refreshToken() {
-            return _this8.refreshToken();
+            return _this7.refreshToken();
           },
-          trackingId: "".concat(_this8.webex.sessionId, "_").concat((0, _now.default)()),
-          logger: _this8.logger
+          trackingId: "".concat(_this7.webex.sessionId, "_").concat((0, _now.default)()),
+          logger: _this7.logger
         };
-        if (_this8.webex.config.defaultMobiusSocketOptions) {
+        if (_this7.webex.config.defaultMobiusSocketOptions) {
           var customOptionsMsg = isShutdownSwitchover ? 'setting custom options for switchover' : 'setting custom options';
-          _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(customOptionsMsg));
-          options = _objectSpread(_objectSpread({}, options), _this8.webex.config.defaultMobiusSocketOptions);
+          _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(customOptionsMsg));
+          options = _objectSpread(_objectSpread({}, options), _this7.webex.config.defaultMobiusSocketOptions);
         }
 
         // Only promote the socket reference for normal connections.
         // Shutdown switchover keeps the old socket active until the new one succeeds.
         if (!isShutdownSwitchover) {
-          _this8.socket = socket;
+          _this7.socket = socket;
         }
-        _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, " ").concat(logPrefix, " url: ").concat(webSocketUrl));
+        _this7.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, " ").concat(logPrefix, " url: ").concat(webSocketUrl));
         return socket.open(webSocketUrl, options).then(function () {
           return webSocketUrl;
         });
@@ -475,48 +463,47 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "connectWithBackoff",
     value: function connectWithBackoff(webSocketUrl) {
-      var _this9 = this;
+      var _this8 = this;
       var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var _context$isShutdownSw = context.isShutdownSwitchover,
         isShutdownSwitchover = _context$isShutdownSw === void 0 ? false : _context$isShutdownSw,
         _context$attemptOptio = context.attemptOptions,
         attemptOptions = _context$attemptOptio === void 0 ? {} : _context$attemptOptio;
       return new _promise.default(function (resolve, reject) {
-        // eslint-disable-next-line prefer-const
         var call;
-        var isInitialConnect = !isShutdownSwitchover && !_this9.hasEverConnected;
-        var initialRetryLimit = _this9.config.initialConnectionMaxRetries == null ? null : Number(_this9.config.initialConnectionMaxRetries);
+        var isInitialConnect = !isShutdownSwitchover && !_this8.hasEverConnected;
+        var initialRetryLimit = _this8.config.initialConnectionMaxRetries == null ? null : Number(_this8.config.initialConnectionMaxRetries);
         var isInitialConnectWithoutRetries = isInitialConnect && initialRetryLimit === 0;
         var onComplete = function onComplete(err) {
           if (isShutdownSwitchover) {
-            _this9.shutdownSwitchoverBackoffCall = undefined;
+            _this8.shutdownSwitchoverBackoffCall = undefined;
           } else {
-            _this9.backoffCall = undefined;
+            _this8.backoffCall = undefined;
           }
           if (err) {
             var msg = isShutdownSwitchover ? "[shutdown] switchover failed after ".concat(call.getNumRetries(), " retries") : "failed to connect after ".concat(call.getNumRetries(), " retries");
-            _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, "; ").concat(err));
+            _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, "; ").concat(err));
             // Only mutate socket flags for normal connections.
             // During shutdown switchover, this.socket is the old live socket — don't touch it.
-            if (!isShutdownSwitchover && _this9.socket) {
-              _this9.socket.connecting = false;
-              _this9.socket.connected = false;
+            if (!isShutdownSwitchover && _this8.socket) {
+              _this8.socket.connecting = false;
+              _this8.socket.connected = false;
             }
             return reject(err);
           }
 
           // For normal connections, mark the socket as connected.
           // Shutdown switchover promotion is handled by the onSuccess callback.
-          if (!isShutdownSwitchover && _this9.socket) {
-            _this9.socket.connecting = false;
-            _this9.socket.connected = true;
+          if (!isShutdownSwitchover && _this8.socket) {
+            _this8.socket.connecting = false;
+            _this8.socket.connected = true;
           }
           if (!isShutdownSwitchover) {
-            _this9.connecting = false;
-            _this9.connected = true;
-            _this9.hasEverConnected = true;
-            _this9.startTokenRefreshTimer();
-            _this9.emitEvent('online');
+            _this8.connecting = false;
+            _this8.connected = true;
+            _this8.hasEverConnected = true;
+            _this8.startTokenRefreshTimer();
+            _this8.emitEvent('online');
           }
           return resolve();
         };
@@ -524,57 +511,63 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
         call = _backoff.default.call(function (callback) {
           var attemptNum = call.getNumRetries();
           var attemptLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": executing ").concat(attemptLogPrefix, " attempt ").concat(attemptNum));
-          _this9.attemptConnection(webSocketUrl, callback, attemptOptions);
+          _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": executing ").concat(attemptLogPrefix, " attempt ").concat(attemptNum));
+          _this8.attemptConnection(webSocketUrl, callback, attemptOptions);
         }, function (err) {
           return onComplete(err);
         });
         call.setStrategy(new _backoff.default.ExponentialStrategy({
-          initialDelay: _this9.config.backoffTimeReset,
-          maxDelay: _this9.config.backoffTimeMax
+          initialDelay: _this8.config.backoffTimeReset,
+          maxDelay: _this8.config.backoffTimeMax
         }));
         if (isInitialConnectWithoutRetries) {
           call.retryIf(function () {
             return false;
           });
-        } else if (isInitialConnect && initialRetryLimit > 0) {
+        } else if (isInitialConnect && initialRetryLimit !== null && initialRetryLimit > 0) {
           call.failAfter(initialRetryLimit);
-        } else if (_this9.config.maxRetries) {
-          call.failAfter(_this9.config.maxRetries);
+        } else if (_this8.config.maxRetries) {
+          call.failAfter(_this8.config.maxRetries);
         }
 
         // Store backoff call reference BEFORE starting (so it's available in attemptConnection)
         if (isShutdownSwitchover) {
-          _this9.shutdownSwitchoverBackoffCall = call;
+          _this8.shutdownSwitchoverBackoffCall = call;
         } else {
-          _this9.backoffCall = call;
+          _this8.backoffCall = call;
         }
         call.on('abort', function () {
           var msg = isShutdownSwitchover ? 'Shutdown Switchover' : 'Connection';
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, " aborted"));
+          _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(msg, " aborted"));
           reject(new Error("MobiusSocket ".concat(msg, " Aborted")));
         });
         call.on('callback', function (err) {
           if (err) {
             if (isInitialConnectWithoutRetries) {
-              _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": initial connect failed; retries already disabled"));
+              _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": initial connect failed; retries already disabled"));
               return;
             }
             var number = call.getNumRetries();
-            var delay = Math.min(call.strategy_.nextBackoffDelay_, _this9.config.backoffTimeMax);
+            var delay = Math.min(call.strategy_.nextBackoffDelay_, _this8.config.backoffTimeMax || Infinity);
             var callbackLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : '';
-            _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(callbackLogPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms"));
+            _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": ").concat(callbackLogPrefix, " failed to connect; attempting retry ").concat(number + 1, " in ").concat(delay, " ms"));
             /* istanbul ignore if */
             if (process.env.NODE_ENV === 'development') {
-              _this9.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": "), err, err.stack);
+              _this8.logger.debug("".concat(MOBIUS_SOCKET_NAMESPACE, ": "), err, err.stack);
             }
             return;
           }
-          _this9.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connected"));
+          _this8.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": connected"));
         });
         call.start();
       });
     }
+
+    /**
+     * Safely emits an event, catching and logging any errors from event handlers.
+     * @param eventName - The name of the event to emit
+     * @param args - Arguments to pass to event handlers
+     */
   }, {
     key: "emitEvent",
     value: function emitEvent(eventName) {
@@ -591,19 +584,28 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
         this.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": error occurred in event handler:"), error, ' with args: ', [eventName].concat(args));
       }
     }
+
+    /**
+     * Starts a periodic timer to refresh the authentication token.
+     * Token refresh occurs every hour while connected.
+     */
   }, {
     key: "startTokenRefreshTimer",
     value: function startTokenRefreshTimer() {
-      var _this0 = this;
+      var _this9 = this;
       if (this.tokenRefreshTimer || !this.connected) {
         return;
       }
       this.tokenRefreshTimer = setInterval(function () {
-        _this0.refreshToken().catch(function (error) {
-          _this0.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": periodic token refresh failed"), error);
+        _this9.refreshToken().catch(function (error) {
+          _this9.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": periodic token refresh failed"), error);
         });
       }, TOKEN_REFRESH_INTERVAL_MS);
     }
+
+    /**
+     * Stops the periodic token refresh timer.
+     */
   }, {
     key: "stopTokenRefreshTimer",
     value: function stopTokenRefreshTimer() {
@@ -613,10 +615,18 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
       clearInterval(this.tokenRefreshTimer);
       this.tokenRefreshTimer = undefined;
     }
+
+    /**
+     * Refreshes the authentication token and re-authenticates the socket connection.
+     * @returns Promise that resolves when token refresh and re-authentication complete
+     */
   }, {
     key: "refreshToken",
     value: function refreshToken() {
-      var _this1 = this;
+      var _this$webex$credentia,
+        _this$webex$credentia2,
+        _this$webex$credentia3,
+        _this0 = this;
       if (this.tokenRefreshInFlight) {
         return this.tokenRefreshInFlight;
       }
@@ -624,26 +634,27 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
         this.stopTokenRefreshTimer();
         return _promise.default.resolve();
       }
-      var tokenPromise = this.webex.credentials.canRefresh ? this.webex.credentials.refresh({
+      var tokenPromise = this.webex.credentials.canRefresh ? (_this$webex$credentia = (_this$webex$credentia2 = this.webex.credentials).refresh) === null || _this$webex$credentia === void 0 ? void 0 : (_this$webex$credentia3 = _this$webex$credentia.call(_this$webex$credentia2, {
         force: true
-      }).then(function () {
-        return _this1.webex.credentials.getUserToken();
+      })) === null || _this$webex$credentia3 === void 0 ? void 0 : _this$webex$credentia3.then(function () {
+        return _this0.webex.credentials.getUserToken();
       }) : this.webex.credentials.getUserToken();
       this.tokenRefreshInFlight = tokenPromise.then(function (token) {
-        var _this1$socket;
+        var _this0$socket;
         if (!token) {
           throw new Error('Mobius token refresh did not return a token');
         }
         var refreshedToken = normalizeMobiusAuthToken(token.toString());
-        if ((_this1$socket = _this1.socket) !== null && _this1$socket !== void 0 && _this1$socket.connected) {
-          return _this1.socket.refresh(refreshedToken);
+        if (!((_this0$socket = _this0.socket) !== null && _this0$socket !== void 0 && _this0$socket.connected)) {
+          _this0.logger.warn("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket is not connected, skipping token refresh"));
+          return undefined;
         }
-        return undefined;
+        return _this0.socket.refresh(refreshedToken);
       }).catch(function (error) {
-        _this1.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to refresh/re-auth Mobius socket"), error);
+        _this0.logger.error("".concat(MOBIUS_SOCKET_NAMESPACE, ": failed to refresh/re-auth Mobius socket"), error);
         throw error;
       }).finally(function () {
-        _this1.tokenRefreshInFlight = undefined;
+        _this0.tokenRefreshInFlight = undefined;
       });
       return this.tokenRefreshInFlight;
     }
@@ -713,7 +724,7 @@ var MobiusSocket = /*#__PURE__*/function (_EventEmitter) {
             break;
           case 1000:
           case 3050:
-            if (normalReconnectReasons.includes(reason)) {
+            if (reason && normalReconnectReasons.includes(reason)) {
               this.logger.info("".concat(MOBIUS_SOCKET_NAMESPACE, ": socket disconnected; reconnecting"));
               if (isActiveSocket) {
                 this.emitEvent('offline.transient', event);