@webex/calling 3.12.0-next.9 → 3.12.0-next.91

package/dist/module/CallingClient/registration/register.js

@@ -1,4 +1,3 @@
-import { v4 as uuid } from 'uuid';
 import { METHOD_START_MESSAGE } from '../../common/constants';
 import { emitFinalFailure, handleRegistrationErrors, uploadLogs } from '../../common';
 import webWorkerStr from './webWorkerStr';
@@ -6,10 +5,12 @@ import { METRIC_EVENT, METRIC_TYPE, REG_ACTION, } from '../../Metrics/types';
 import { getMetricManager } from '../../Metrics';
 import { getCallManager } from '../calling';
 import log from '../../Logger';
+import { HARD_STOP_REASON } from './types';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, WorkerMessageType, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
+import { APIRequest } from '../utils/request';
 export class Registration {
     sdkConnector;
     webex;
@@ -36,6 +37,7 @@ export class Registration {
     retryAfter;
     scheduled429Retry = false;
     webWorker;
+    apiRequest;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -57,6 +59,12 @@ export class Registration {
         this.lineEmitter = lineEmitter;
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
+    }
+    getServerType(url) {
+        return ((this.primaryMobiusUris.includes(url) && 'PRIMARY') ||
+            (this.backupMobiusUris?.includes(url) && 'BACKUP') ||
+            'UNKNOWN');
     }
     getFailoverCacheKey() {
         return `${FAILOVER_CACHE_PREFIX}.${this.userId || 'unknown'}`;
@@ -131,16 +139,22 @@ export class Registration {
     }
     async deleteRegistration(url, deviceId, deviceUrl) {
         let response;
+        const requestObj = {
+            uri: `${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`,
+            method: HTTP_METHODS.DELETE,
+            headers: {
+                [CISCO_DEVICE_URL]: deviceUrl,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        };
+        if (this.apiRequest.isSocketEnabled()) {
+            requestObj.body = {
+                deviceId,
+            };
+        }
         try {
-            response = await fetch(`${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`, {
-                method: HTTP_METHODS.DELETE,
-                headers: {
-                    [CISCO_DEVICE_URL]: deviceUrl,
-                    Authorization: await this.webex.credentials.getUserToken(),
-                    trackingId: `${WEBEX_WEB_CLIENT}_${uuid()}`,
-                    [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                },
-            });
+            response = await this.apiRequest.makeRequest(requestObj);
         }
         catch (error) {
             log.warn(`Delete failed with Mobius: ${JSON.stringify(error)}`, {
@@ -151,7 +165,7 @@ export class Registration {
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
-        return response?.json();
+        return response;
     }
     async postRegistration(url) {
         const deviceInfo = {
@@ -159,7 +173,7 @@ export class Registration {
             clientDeviceUri: this.webex.internal.device.url,
             serviceData: this.jwe ? { ...this.serviceData, jwe: this.jwe } : this.serviceData,
         };
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${url}device`,
             method: HTTP_METHODS.POST,
             headers: {
@@ -171,7 +185,23 @@ export class Registration {
         });
     }
     async restorePreviousRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTORE_PREVIOUS_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}, activeMobiusUrl: ${this.activeMobiusUrl}`, loggerContext);
         let abort = false;
+        if (this.apiRequest.isSocketEnabled() &&
+            `${this.apiRequest.getConnectedWebSocketUrl()}/` !== this.activeMobiusUrl) {
+            log.info(`Disconnecting from Mobius socket to restore previous registration.`, {
+                file: REGISTRATION_FILE,
+                method: 'restorePreviousRegistration',
+            });
+            await this.apiRequest.disconnectFromMobiusSocket({
+                code: 3050,
+                reason: 'done (permanent)',
+            });
+        }
         if (this.activeMobiusUrl) {
             abort = await this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
             if (this.retryAfter) {
@@ -185,22 +215,47 @@ export class Registration {
                     abort = await this.attemptRegistrationWithServers(caller, this.backupMobiusUris);
                 }
                 else {
-                    this.restartRegistration(caller);
+                    await this.restartRegistration(caller);
                 }
                 this.retryAfter = undefined;
+                log.log(`restorePreviousRegistration completed via 429 retry-after path - caller: ${caller}`, loggerContext);
                 return true;
             }
         }
+        log.log(`restorePreviousRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
         return abort;
     }
     async handle404KeepaliveFailure(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_404_KEEPALIVE_FAILURE,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         if (caller === KEEPALIVE_UTIL) {
             const abort = await this.attemptRegistrationWithServers(caller);
             if (!abort && !this.isDeviceRegistered()) {
+                log.warn('Keepalive 404 recovery: re-registration did not complete, starting failover timer', loggerContext);
                 await this.startFailoverTimer();
             }
+            else {
+                log.log(`Keepalive 404 recovery handled - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+            }
         }
     }
+    async handle409KeepaliveFailure(lineError, error, serverType, keepaliveRetryCount) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_409_KEEPALIVE_FAILURE,
+        };
+        log.warn(`Stopping keepalive without re-registration, session superseded by another device for this user - keepaliveRetryCount: ${keepaliveRetryCount}`, loggerContext);
+        this.clearKeepaliveTimer();
+        this.metricManager.submitRegistrationMetric(METRIC_EVENT.KEEPALIVE_ERROR, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, METHODS.HANDLE_409_KEEPALIVE_FAILURE, serverType, error.headers?.trackingid ?? '', keepaliveRetryCount, lineError);
+        await this.registrationCleanup(METHODS.HANDLE_409_KEEPALIVE_FAILURE, {
+            reason: HARD_STOP_REASON.SESSION_SUPERSEDED,
+            error: lineError,
+        });
+        await uploadLogs();
+    }
     async handle429Retry(retryAfter, caller) {
         if (caller === FAILBACK_UTIL) {
             if (this.failback429RetryAttempts >= REG_FAILBACK_429_MAX_RETRIES) {
@@ -228,7 +283,7 @@ export class Registration {
                     method: REG_429_RETRY_UTIL,
                 });
                 await this.startKeepaliveTimer(this.deviceInfo.device?.uri, this.deviceInfo.keepaliveInterval, 'UNKNOWN');
-            }, retryAfter * 1000);
+            }, (retryAfter - Number(this.deviceInfo.keepaliveInterval || 0)) * 1000);
         }
         else {
             this.retryAfter = retryAfter;
@@ -279,6 +334,14 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
+            if (this.apiRequest.isSocketEnabled()) {
+                log.info('Disconnecting from primary Mobius socket for failover to backup servers', loggerContext);
+                await this.apiRequest.disconnectFromMobiusSocket({
+                    code: 3050,
+                    reason: 'done (permanent)',
+                });
+                log.log('Mobius socket disconnect complete prior to backup failover', loggerContext);
+            }
             this.saveFailoverState({
                 attempt,
                 timeElapsed,
@@ -311,7 +374,7 @@ export class Registration {
             await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
-            }, loggerContext);
+            }, loggerContext, interval < 0 ? 'Timer threshold exceeded during failover' : undefined);
         }
     }
     clearFailbackTimer() {
@@ -320,11 +383,25 @@ export class Registration {
             this.failbackTimer = undefined;
         }
     }
+    async postKeepAlive(deviceUrl, url) {
+        return this.apiRequest.makeRequest({
+            uri: `${url}/status`,
+            method: HTTP_METHODS.POST,
+            headers: {
+                [CISCO_DEVICE_URL]: deviceUrl,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            body: {
+                deviceId: this.deviceInfo.device?.deviceId,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        });
+    }
     async isPrimaryActive() {
         let status;
         for (const mobiusUrl of this.primaryMobiusUris) {
             try {
-                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/');
+                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/').replace('wss://', 'https://');
                 const response = await this.webex.request({
                     uri: `${baseUri}ping`,
                     method: HTTP_METHODS.GET,
@@ -362,14 +439,23 @@ export class Registration {
             this.rehomingIntervalMin);
     }
     initiateFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.INITIATE_FAILBACK,
+        };
         if (this.isFailbackRequired()) {
             if (!this.failbackTimer) {
                 this.failback429RetryAttempts = 0;
                 const intervalInMinutes = this.getFailbackInterval();
+                log.info(`Scheduling failback to primary - intervalMinutes: ${intervalInMinutes}`, loggerContext);
                 this.startFailbackTimer(intervalInMinutes * MINUTES_TO_SEC_MFACTOR);
             }
+            else {
+                log.info('Failback timer already scheduled, skipping', loggerContext);
+            }
         }
         else {
+            log.info('Failback not required, clearing any pending failback timer', loggerContext);
             this.failback429RetryAttempts = 0;
             this.clearFailbackTimer();
         }
@@ -382,15 +468,25 @@ export class Registration {
         });
     }
     async executeFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.EXECUTE_FAILBACK,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         await this.mutex.runExclusive(async () => {
             if (this.isFailbackRequired()) {
                 const primaryServerStatus = await this.isPrimaryActive();
                 if (Object.keys(this.callManager.getActiveCalls()).length === 0 && primaryServerStatus) {
-                    log.info(`Attempting failback to primary.`, {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info(`Attempting failback to primary.`, loggerContext);
                     await this.deregister();
+                    if (this.apiRequest.isSocketEnabled()) {
+                        log.info('Disconnecting from backup Mobius socket for failback to primary', loggerContext);
+                        await this.apiRequest.disconnectFromMobiusSocket({
+                            code: 3050,
+                            reason: 'done (permanent)',
+                        });
+                        log.log('Mobius socket disconnect complete prior to primary failback', loggerContext);
+                    }
                     const abort = await this.attemptRegistrationWithServers(FAILBACK_UTIL);
                     if (this.scheduled429Retry || abort || this.isDeviceRegistered()) {
                         return;
@@ -401,7 +497,7 @@ export class Registration {
                         return;
                     }
                     if (!this.isDeviceRegistered()) {
-                        await this.restartRegistration(this.executeFailback.name);
+                        await this.restartRegistration(loggerContext.method);
                     }
                     else {
                         this.failbackTimer = undefined;
@@ -409,10 +505,7 @@ export class Registration {
                     }
                 }
                 else {
-                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', loggerContext);
                     this.failbackTimer = undefined;
                     this.initiateFailback();
                 }
@@ -442,12 +535,18 @@ export class Registration {
         this.registrationStatus = value;
     }
     async restartRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTART_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         this.clearFailbackTimer();
         this.failback429RetryAttempts = 0;
         const abort = await this.attemptRegistrationWithServers(caller, this.primaryMobiusUris);
         if (!abort && !this.isDeviceRegistered()) {
             await this.startFailoverTimer();
         }
+        log.log(`restartRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
     }
     async handleConnectionRestoration(retry) {
         log.info(METHOD_START_MESSAGE, {
@@ -500,7 +599,13 @@ export class Registration {
         };
     }
     async triggerRegistration() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.TRIGGER_REGISTRATION,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (await this.resumeFailover()) {
+            log.info('Registration trigger handled by resumeFailover path', loggerContext);
             return;
         }
         if (this.primaryMobiusUris.length > 0) {
@@ -508,43 +613,51 @@ export class Registration {
             if (!this.isDeviceRegistered() && !abort) {
                 await this.startFailoverTimer();
             }
+            log.log(`triggerRegistration completed - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+        }
+        else {
+            log.warn('triggerRegistration skipped: no primary Mobius URIs available', loggerContext);
         }
     }
     async attemptRegistrationWithServers(caller, servers = this.primaryMobiusUris) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: REGISTER_UTIL,
+        };
         let abort = false;
         this.retryAfter = undefined;
+        let connectedWebSocketUrl;
         if (this.failoverImmediately) {
             return abort;
         }
         if (this.isDeviceRegistered()) {
-            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
-                file: REGISTRATION_FILE,
-                method: REGISTER_UTIL,
-            });
+            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, loggerContext);
             return abort;
         }
+        if (servers.length) {
+            this.apiRequest.setSocketEnabled(servers[0].startsWith('wss://'));
+        }
         for (const url of servers) {
-            const serverType = (this.primaryMobiusUris.includes(url) && 'PRIMARY') ||
-                (this.backupMobiusUris?.includes(url) && 'BACKUP') ||
-                'UNKNOWN';
+            const serverType = this.getServerType(url);
             try {
                 abort = false;
                 this.registrationStatus = RegistrationStatus.INACTIVE;
                 this.lineEmitter(LINE_EVENTS.CONNECTING);
-                log.info(`[${caller}] : Mobius url to contact: ${url}`, {
-                    file: REGISTRATION_FILE,
-                    method: REGISTER_UTIL,
-                });
+                log.info(`[${caller}] : Mobius url to contact: ${url}`, loggerContext);
+                if (this.apiRequest.isSocketEnabled()) {
+                    const wssNormalizedUrl = url.endsWith('/') ? url.slice(0, -1) : url;
+                    log.info(`[${caller}] : Connecting to Mobius WebSocket - serverType: ${serverType}, wssUrl: ${wssNormalizedUrl}`, loggerContext);
+                    connectedWebSocketUrl = await this.apiRequest.connectToMobiusSocket(wssNormalizedUrl);
+                    connectedWebSocketUrl = connectedWebSocketUrl ? `${connectedWebSocketUrl}/` : undefined;
+                    log.log(`[${caller}] : Mobius WebSocket connected - serverType: ${serverType}, connectedWebSocketUrl: ${connectedWebSocketUrl}`, loggerContext);
+                }
                 const resp = await this.postRegistration(url);
                 this.clearFailoverState();
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
-                this.setActiveMobiusUrl(url);
+                this.setActiveMobiusUrl(connectedWebSocketUrl || url);
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
-                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, {
-                    file: REGISTRATION_FILE,
-                    method: METHODS.REGISTER,
-                });
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, loggerContext);
                 this.setIntervalValues(this.deviceInfo);
                 this.metricManager.setDeviceInfo(this.deviceInfo);
                 this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, resp.headers?.trackingid ?? '', undefined, undefined);
@@ -554,22 +667,32 @@ export class Registration {
             }
             catch (err) {
                 const body = err;
-                abort = await handleRegistrationErrors(body, (clientError, finalError) => {
-                    if (finalError) {
+                const { finalError, shouldDisconnect } = await handleRegistrationErrors(body, (clientError, isFinalError) => {
+                    if (isFinalError) {
                         this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                     }
                     else {
                         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                     }
                     this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, body.headers?.trackingid ?? '', undefined, clientError);
-                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack());
+                }, { method: caller, file: REGISTRATION_FILE }, {
+                    retry429Cb: (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller),
+                    restoreRegCb: this.restoreRegistrationCallBack(),
+                }, servers.length);
+                abort = finalError;
                 if (this.registrationStatus === RegistrationStatus.ACTIVE) {
-                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, {
-                        file: REGISTRATION_FILE,
-                        method: this.attemptRegistrationWithServers.name,
-                    });
+                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, loggerContext);
                     break;
                 }
+                if (shouldDisconnect && this.apiRequest.isSocketEnabled()) {
+                    connectedWebSocketUrl = undefined;
+                    log.info(`[${caller}] : Tearing down Mobius WebSocket after registration error - serverType: ${serverType}`, loggerContext);
+                    await this.apiRequest.disconnectFromMobiusSocket({
+                        code: 3050,
+                        reason: 'done (permanent)',
+                    });
+                    log.log(`[${caller}] : Mobius WebSocket disconnect complete after registration error - serverType: ${serverType}`, loggerContext);
+                }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
                     await uploadLogs();
@@ -584,7 +707,6 @@ export class Registration {
         const RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
         await this.mutex.runExclusive(async () => {
             if (this.isDeviceRegistered()) {
-                const accessToken = await this.webex.credentials.getUserToken();
                 if (!this.webWorker) {
                     const blob = new Blob([webWorkerStr], { type: 'application/javascript' });
                     const blobUrl = URL.createObjectURL(blob);
@@ -592,17 +714,38 @@ export class Registration {
                     URL.revokeObjectURL(blobUrl);
                     this.webWorker.postMessage({
                         type: WorkerMessageType.START_KEEPALIVE,
-                        accessToken: String(accessToken),
-                        deviceUrl: String(this.webex.internal.device.url),
                         interval,
                         retryCountThreshold: RETRY_COUNT_THRESHOLD,
-                        url,
                     });
                     this.webWorker.onmessage = async (event) => {
                         const logContext = {
                             file: REGISTRATION_FILE,
                             method: KEEPALIVE_UTIL,
                         };
+                        if (event.data.type === WorkerMessageType.SEND_KEEPALIVE) {
+                            try {
+                                const res = await this.postKeepAlive(String(this.webex.internal.device.url), url);
+                                this.webWorker?.postMessage({
+                                    type: WorkerMessageType.KEEPALIVE_RESULT,
+                                    statusCode: res.statusCode,
+                                });
+                            }
+                            catch (err) {
+                                const error = {
+                                    headers: {
+                                        trackingid: err.headers?.trackingid,
+                                        'retry-after': err.headers['retry-after'],
+                                    },
+                                    statusCode: err.statusCode,
+                                    statusText: err.statusText,
+                                    type: err.type,
+                                };
+                                this.webWorker?.postMessage({
+                                    type: WorkerMessageType.KEEPALIVE_RESULT,
+                                    err: error,
+                                });
+                            }
+                        }
                         if (event.data.type === WorkerMessageType.KEEPALIVE_SUCCESS) {
                             log.info(`Sent Keepalive, status: ${event.data.statusCode}`, logContext);
                             this.lineEmitter(LINE_EVENTS.RECONNECTED);
@@ -610,12 +753,18 @@ export class Registration {
                         if (event.data.type === WorkerMessageType.KEEPALIVE_FAILURE) {
                             const error = event.data.err;
                             log.warn(`Keep-alive missed ${event.data.keepAliveRetryCount} times. Status -> ${error.statusCode} `, logContext);
-                            const abort = await handleRegistrationErrors(error, (clientError, finalError) => {
+                            const { finalError: abort, handledByCallback } = await handleRegistrationErrors(error, (clientError, finalError) => {
                                 if (finalError) {
                                     this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                                 }
                                 this.metricManager.submitRegistrationMetric(METRIC_EVENT.KEEPALIVE_ERROR, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', event.data.keepAliveRetryCount, clientError);
-                            }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller));
+                            }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE }, {
+                                retry429Cb: (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller),
+                                sessionSupersededCb: (clientError) => this.handle409KeepaliveFailure(clientError, error, serverType, event.data.keepAliveRetryCount),
+                            });
+                            if (handledByCallback) {
+                                return;
+                            }
                             if (abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
                                 this.failoverImmediately = this.isCCFlow;
                                 this.setStatus(RegistrationStatus.INACTIVE);
@@ -649,19 +798,25 @@ export class Registration {
     isReconnectPending() {
         return this.reconnectPending;
     }
-    async deregister() {
+    async deregister(closeMobiusWss = false) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.DEREGISTER,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             await this.deleteRegistration(this.activeMobiusUrl, this.deviceInfo.device?.deviceId, this.deviceInfo.device?.clientDeviceUri);
-            log.log('Registration successfully deregistered', {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
-            });
+            log.log('Registration successfully deregistered', loggerContext);
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, loggerContext);
+        }
+        if (closeMobiusWss) {
+            await this.apiRequest.disconnectFromMobiusSocket({
+                code: 3050,
+                reason: 'done (permanent)',
             });
+            log.log('Mobius socket disconnect complete after deregistration', loggerContext);
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
@@ -683,7 +838,11 @@ export class Registration {
                 rehomingIntervalMin: DEFAULT_REHOMING_INTERVAL_MIN,
             };
             const stringToReplace = `${DEVICES_ENDPOINT_RESOURCE}/${restoreData.devices[0].deviceId}`;
-            const uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            let uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            if (this.apiRequest.isSocketEnabled()) {
+                uri = uri.replace('https://', 'wss://');
+                uri = !uri.endsWith('/') ? `${uri}/` : uri;
+            }
             this.setActiveMobiusUrl(uri);
             this.registrationStatus = RegistrationStatus.ACTIVE;
             return true;
@@ -709,5 +868,48 @@ export class Registration {
             }
         }
     }
+    async handleRegistrationDownEvent(event) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_REGISTRATION_DOWN_EVENT,
+        };
+        log.info(`Registration down received - trackingId: ${event?.trackingId ?? 'unknown'}, eventId: ${event?.eventId ?? 'unknown'}`, loggerContext);
+        const [activeCall] = Object.values(this.callManager.getActiveCalls());
+        activeCall?.end();
+        await this.registrationCleanup(METHODS.HANDLE_REGISTRATION_DOWN_EVENT, {
+            reason: HARD_STOP_REASON.REGISTRATION_DOWN,
+        });
+    }
+    async registrationCleanup(caller, hardStop) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: caller,
+        };
+        log.info(`[${caller}] : Running ${hardStop.reason} cleanup`, loggerContext);
+        await this.mutex.runExclusive(async () => {
+            this.clearFailbackTimer();
+            this.clearKeepaliveTimer();
+            this.reconnectPending = false;
+            this.scheduled429Retry = false;
+            this.failoverImmediately = false;
+            this.retryAfter = undefined;
+            this.registerRetry = false;
+            this.clearFailoverState();
+            this.setStatus(RegistrationStatus.INACTIVE);
+            if (this.apiRequest.isSocketEnabled()) {
+                try {
+                    await this.apiRequest.disconnectFromMobiusSocket({
+                        code: 3050,
+                        reason: 'done (permanent)',
+                    });
+                    log.log(`Mobius socket disconnect complete after ${hardStop.reason}`, loggerContext);
+                }
+                catch (err) {
+                    log.warn(`Mobius socket disconnect failed after ${hardStop.reason}: ${String(err)}`, loggerContext);
+                }
+            }
+            this.lineEmitter(LINE_EVENTS.UNREGISTERED, undefined, hardStop.error);
+        });
+    }
 }
 export const createRegistration = (webex, serviceData, mutex, lineEmitter, logLevel, jwe) => new Registration(webex, serviceData, mutex, lineEmitter, logLevel, jwe);

package/dist/module/CallingClient/registration/types.js

@@ -1 +1,5 @@
-export {};
+export var HARD_STOP_REASON;
+(function (HARD_STOP_REASON) {
+    HARD_STOP_REASON["REGISTRATION_DOWN"] = "registration-down";
+    HARD_STOP_REASON["SESSION_SUPERSEDED"] = "session-superseded";
+})(HARD_STOP_REASON || (HARD_STOP_REASON = {}));