@wazo/sdk 0.48.3 → 0.49.1

package/dist/index.js

@@ -79,6 +79,7 @@ __webpack_require__.d(__webpack_exports__, {
     WazoApiClient: ()=>ApiClient,
     BadResponse: ()=>BadResponse,
     CTIPhone: ()=>CTIPhone,
+    RefreshTokenError: ()=>RefreshTokenError,
     CallSession: ()=>CallSession,
     Session: ()=>Session,
     setOnRefreshTokenError: ()=>setOnRefreshTokenError,
@@ -97,7 +98,7 @@ __webpack_require__.d(__webpack_exports__, {
     Contact: ()=>Contact,
     setCurrentServer: ()=>setCurrentServer,
     parsePhoneNumber: ()=>parsePhoneNumber,
-    SessionDescriptionHandler: ()=>WazoSessionDescriptionHandler,
+    SessionDescriptionHandler: ()=>lib_WazoSessionDescriptionHandler,
     default: ()=>src_0,
     SFUNotAvailableError: ()=>SFUNotAvailableError,
     Incall: ()=>Incall,
@@ -4039,6 +4040,14 @@ const auth = (client, baseUrl)=>({
         getProviderAuthUrl: (userUuid, provider)=>client.post(`${baseUrl}/users/${userUuid}/external/${provider}`, {}),
         deleteProviderToken: (userUuid, provider)=>client.delete(`${baseUrl}/users/${userUuid}/external/${provider}`)
     });
+class RefreshTokenError extends Error {
+    reason;
+    constructor(reason){
+        super(`Token refresh failed: ${reason}`);
+        this.name = 'RefreshTokenError';
+        this.reason = reason;
+    }
+}
 const base_api_client_logger = IssueReporter ? IssueReporter.loggerFor('api') : console;
 class BaseApiClient {
     client;
@@ -4052,6 +4061,9 @@ class BaseApiClient {
     refreshDomainName;
     isMobile;
     fetchOptions;
+    refreshTokenErrorNotified = false;
+    refreshTokenPromise = null;
+    refreshTokenGeneration = 0;
     constructor({ server, agent = null, refreshToken, clientId, isMobile = false, fetchOptions }){
         this.updateParameters({
             server,
@@ -4081,6 +4093,17 @@ class BaseApiClient {
         return this.refreshTokenCallback();
     }
     async refreshTokenCallback() {
+        if (this.refreshTokenPromise) return this.refreshTokenPromise;
+        const generation = this.refreshTokenGeneration;
+        const promise = this.performTokenRefresh(generation);
+        this.refreshTokenPromise = promise;
+        try {
+            return await promise;
+        } finally{
+            if (this.refreshTokenPromise === promise) this.refreshTokenPromise = null;
+        }
+    }
+    async performTokenRefresh(generation) {
         base_api_client_logger.info('refresh token callback called', {
             refreshToken: obfuscateToken(this.refreshToken),
             refreshBackend: this.refreshBackend,
@@ -4089,22 +4112,57 @@ class BaseApiClient {
             refreshExpiration: this.refreshExpiration,
             isMobile: this.isMobile
         });
-        if (!this.refreshToken) return null;
+        if (!this.refreshToken) {
+            this.notifyRefreshTokenError(new RefreshTokenError('no_refresh_token'), 'no_refresh_token', generation);
+            return null;
+        }
         try {
             const session = await this.auth.refreshToken(this.refreshToken, this.refreshBackend, this.refreshExpiration, this.isMobile, this.refreshTenantId, this.refreshDomainName);
-            if (!session) return null;
+            if (!session) {
+                this.notifyRefreshTokenError(new RefreshTokenError('empty_session'), 'empty_session', generation);
+                return null;
+            }
+            if (generation !== this.refreshTokenGeneration) {
+                base_api_client_logger.info('ignoring stale token refresh success');
+                return null;
+            }
             base_api_client_logger.info('token refreshed', {
                 token: obfuscateToken(session.token)
             });
-            if (this.onRefreshToken) this.onRefreshToken(session.token, session);
+            this.refreshTokenErrorNotified = false;
+            this.refreshTokenGeneration += 1;
             this.setToken(session.token);
+            if (this.onRefreshToken) try {
+                this.onRefreshToken(session.token, session);
+            } catch (e) {
+                base_api_client_logger.error('onRefreshToken handler failed', e);
+            }
             return session.token;
         } catch (error) {
             base_api_client_logger.error('token refresh, error', error);
-            if (this.onRefreshTokenError) this.onRefreshTokenError(error);
+            this.notifyRefreshTokenError(error, void 0, generation);
         }
         return null;
     }
+    notifyRefreshTokenError(error, reason, generation = this.refreshTokenGeneration) {
+        if (generation !== this.refreshTokenGeneration) {
+            base_api_client_logger.info('ignoring stale token refresh failure', {
+                reason
+            });
+            return;
+        }
+        if (reason) base_api_client_logger.error('token refresh failed', {
+            reason
+        });
+        if (!this.onRefreshTokenError) return;
+        if (this.refreshTokenErrorNotified) return;
+        this.refreshTokenErrorNotified = true;
+        try {
+            this.onRefreshTokenError(error);
+        } catch (e) {
+            base_api_client_logger.error('onRefreshTokenError handler failed', e);
+        }
+    }
     setToken(token) {
         this.client.setToken(token);
     }
@@ -4112,7 +4170,16 @@ class BaseApiClient {
         this.client.setTenant(tenant);
     }
     setRefreshToken(refreshToken) {
+        const changed = refreshToken !== this.refreshToken;
         this.refreshToken = refreshToken;
+        if (refreshToken) {
+            this.refreshTokenErrorNotified = false;
+            if (changed) {
+                this.refreshTokenGeneration += 1;
+                this.refreshTokenPromise = null;
+                this.client.refreshTokenPromise = null;
+            }
+        }
     }
     setRequestTimeout(requestTimeout) {
         this.client.setRequestTimeout(requestTimeout);
@@ -4870,7 +4937,7 @@ const wazoMediaStreamFactory = (constraints)=>{
     if (constraints.screen && !constraints.desktop) return navigator.mediaDevices.getDisplayMedia.call(navigator.mediaDevices, constraints);
     return navigator.mediaDevices.getUserMedia.call(navigator.mediaDevices, constraints);
 };
-class WazoSessionDescriptionHandler_WazoSessionDescriptionHandler extends session_description_handler_namespaceObject.SessionDescriptionHandler {
+class WazoSessionDescriptionHandler extends session_description_handler_namespaceObject.SessionDescriptionHandler {
     gatheredCandidates;
     eventEmitter;
     isWeb;
@@ -5172,7 +5239,7 @@ class WazoSessionDescriptionHandler_WazoSessionDescriptionHandler extends sessio
         return keysA.every((key, i)=>keysB[i] === key && this._constraintsEqual(a[key], b[key]));
     }
 }
-const WazoSessionDescriptionHandler = WazoSessionDescriptionHandler_WazoSessionDescriptionHandler;
+const lib_WazoSessionDescriptionHandler = WazoSessionDescriptionHandler;
 const lastIndexOf = (array, method)=>{
     const start = array.length - 1;
     for(let i = start; i >= 0; i--)if (method(array[i])) return i;
@@ -5242,8 +5309,12 @@ const toAssertedIdentity = (identity)=>{
 };
 const MAX_REGISTER_TRIES = 5;
 const NO_ANSWER_TIMEOUT = 86400;
+let liveClientCount = 0;
 class WebRTCClient extends Emitter {
     clientId;
+    _countedAsLive;
+    _closed;
+    lastTransportMessageAt;
     config;
     uaConfigOverrides;
     userAgent;
@@ -5314,11 +5385,32 @@ class WebRTCClient extends Emitter {
         web_rtc_client_logger.info('sdk webrtc constructor', {
             clientId: this.clientId
         });
+        liveClientCount += 1;
+        this._countedAsLive = true;
+        this._closed = false;
+        this.lastTransportMessageAt = null;
+        if (liveClientCount > 1) web_rtc_client_logger.info('sdk webrtc multiple clients alive', {
+            liveClientCount,
+            clientId: this.clientId
+        });
         this.uaConfigOverrides = uaConfigOverrides;
         this.config = config;
         this.skipRegister = config.skipRegister;
         this._buildConfig(config, session).then((newConfig)=>{
             this.config = newConfig;
+            if (this._closed) {
+                web_rtc_client_logger.info('sdk webrtc constructor, client closed during config build, skipping UA creation', {
+                    clientId: this.clientId
+                });
+                return;
+            }
+            if (this.userAgent && !session) {
+                web_rtc_client_logger.info('sdk webrtc constructor, userAgent already created, skipping', {
+                    clientId: this.clientId
+                });
+                return;
+            }
+            if (this.registerer) this._cleanupRegister();
             this.userAgent = this.createUserAgent(uaConfigOverrides);
         });
         this.audioOutputDeviceId = config.audioDeviceOutput;
@@ -5377,6 +5469,19 @@ class WebRTCClient extends Emitter {
         this.audio = media.audio;
     }
     createUserAgent(uaConfigOverrides) {
+        this.lastTransportMessageAt = null;
+        if (this.userAgent) {
+            web_rtc_client_logger.warn('sdk webrtc, stopping existing UA before creating a new one', {
+                clientId: this.clientId
+            });
+            this.userAgent.stop().catch((error)=>{
+                web_rtc_client_logger.error('sdk webrtc, error stopping previous UA', {
+                    error: error?.message,
+                    clientId: this.clientId
+                });
+            });
+            this.userAgent = null;
+        }
         const uaOptions = this._createUaOptions(uaConfigOverrides);
         web_rtc_client_logger.info('sdk webrtc, creating UA', {
             uaOptions: {
@@ -5406,6 +5511,7 @@ class WebRTCClient extends Emitter {
             web_rtc_client_logger.warn('Transport connect error', e);
         });
         ua.transport.onMessage = (rawMessage)=>{
+            this.lastTransportMessageAt = Date.now();
             const message = parser_namespaceObject.Parser.parseMessage(rawMessage, ua.transport.logger);
             ua.onTransportMessage(rawMessage);
             this.eventEmitter.emit(MESSAGE, message);
@@ -5424,6 +5530,16 @@ class WebRTCClient extends Emitter {
     isRegistered() {
         return Boolean(this.registerer && this.registerer.state === registerer_state_namespaceObject.RegistererState.Registered);
     }
+    getLastTransportMessageAt() {
+        return this.lastTransportMessageAt;
+    }
+    isTransportSuspect() {
+        if (!this.isConnected()) return true;
+        if (Object.keys(this.sipSessions).length > 0) return false;
+        const threshold = this.config.transportSilenceThresholdMs;
+        if (!threshold || !this.lastTransportMessageAt) return false;
+        return Date.now() - this.lastTransportMessageAt > threshold;
+    }
     onConnect() {
         web_rtc_client_logger.info('sdk webrtc connected', {
             method: 'delegate.onConnect',
@@ -5447,6 +5563,23 @@ class WebRTCClient extends Emitter {
             this.eventEmitter.emit(UNREGISTERED);
         }
     }
+    async _isRegistrationHealthy() {
+        if (!this.isTransportSuspect()) return true;
+        web_rtc_client_logger.warn('sdk webrtc registered but transport suspect, re-registering', {
+            clientId: this.clientId,
+            connected: this.isConnected(),
+            lastTransportMessageAt: this.lastTransportMessageAt
+        });
+        this._cleanupRegister();
+        if (this.isConnected()) {
+            this.connectionPromise = this._disconnectTransport(true);
+            await this.connectionPromise;
+            this.connectionPromise = null;
+            const transport = this.userAgent?.transport;
+            if (transport && transport.state !== transport_state_namespaceObject.TransportState.Disconnected) transport.transitionState(transport_state_namespaceObject.TransportState.Disconnected);
+        }
+        return false;
+    }
     async register(tries = 0) {
         const logInfo = {
             clientId: this.clientId,
@@ -5459,6 +5592,11 @@ class WebRTCClient extends Emitter {
             skipRegister: this.skipRegister
         };
         this.forceClosed = false;
+        this._closed = false;
+        if (!this._countedAsLive) {
+            this._countedAsLive = true;
+            liveClientCount += 1;
+        }
         if (this.skipRegister) {
             web_rtc_client_logger.info('sdk webrtc skip register...', logInfo);
             return Promise.resolve();
@@ -5468,15 +5606,19 @@ class WebRTCClient extends Emitter {
             web_rtc_client_logger.info('sdk webrtc recreating User Agent');
             this.userAgent = this.createUserAgent(this.uaConfigOverrides);
         }
-        if (!this.userAgent || this.isRegistered()) {
-            web_rtc_client_logger.info('sdk webrtc registering aborted, already registered or no UA can be created');
-            return Promise.resolve();
+        if (!this.userAgent) {
+            web_rtc_client_logger.info('sdk webrtc registering aborted, no UA can be created');
+            return;
+        }
+        if (this.isRegistered() && await this._isRegistrationHealthy()) {
+            web_rtc_client_logger.info('sdk webrtc registering aborted, already registered');
+            return;
         }
         if (this.connectionPromise || this.registerer?.waiting) {
             web_rtc_client_logger.info('sdk webrtc registering aborted due to a registration in progress.', {
                 clientId: this.clientId
             });
-            return Promise.resolve();
+            return;
         }
         const registerOptions = this._isWeb() ? {} : {
             extraContactHeaderParams: [
@@ -5577,7 +5719,6 @@ class WebRTCClient extends Emitter {
                         web_rtc_client_logger.info('sdk webrtc unregistered', {
                             clientId: this.clientId
                         });
-                        if (this.registerer) this.registerer.stateChange.addListener(onRegisterStateChange);
                         this._cleanupRegister();
                         resolve();
                     }
@@ -5771,6 +5912,11 @@ class WebRTCClient extends Emitter {
             force
         });
         this.forceClosed = force;
+        this._closed = true;
+        if (this._countedAsLive) {
+            this._countedAsLive = false;
+            liveClientCount = Math.max(0, liveClientCount - 1);
+        }
         this._cleanupMedia();
         this.connectionPromise = null;
         Object.values(this.audioElements).forEach((audioElement)=>{
@@ -6698,7 +6844,7 @@ class WebRTCClient extends Emitter {
                         ...options.peerConnectionConfiguration || {}
                     }
                 };
-                return new WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb, session);
+                return new lib_WazoSessionDescriptionHandler(uaLogger, wazoMediaStreamFactory, sdhOptions, isWeb, session);
             },
             transportOptions: {
                 traceSip: uaOptionsOverrides?.traceSip || false,
@@ -8659,6 +8805,15 @@ class WebRTCPhone extends Emitter {
     isRegistered() {
         return this.client && this.client.isRegistered();
     }
+    isConnected() {
+        return Boolean(this.client?.isConnected());
+    }
+    isTransportSuspect() {
+        return !this.client || this.client.isTransportSuspect();
+    }
+    getLastTransportMessageAt() {
+        return this.client?.getLastTransportMessageAt() ?? null;
+    }
     enableRinging() {
         WebRTCPhone_logger.info('WebRTC enable ringing');
         this.ringingEnabled = true;
@@ -8978,8 +9133,9 @@ class WebRTCPhone extends Emitter {
         const { state } = sipSession || {};
         const sessionId = this.getSipSessionId(sipSession);
         fromSession = fromSession || this.callSessions[sessionId];
+        const headerCallId = sipSession?.request?.getHeader?.('X-Wazo-Call-ID');
         const callSession = new CallSession({
-            callId: fromSession && fromSession.callId,
+            callId: fromSession?.callId || headerCallId || '',
             sipCallId: sessionId,
             sipStatus: state,
             displayName: identity ? identity.displayName || number : number,
@@ -9614,6 +9770,7 @@ const protocolDebugMessages = [
 class Phone_Phone extends Emitter {
     client;
     phone;
+    connectInFlight;
     session;
     sipLine;
     SessionState;
@@ -9683,10 +9840,37 @@ class Phone_Phone extends Emitter {
         this.sipLine = sipLine || this.getPrimaryWebRtcLine();
         if (!this.sipLine) throw new Error('Sorry, no sip lines found for this user');
         options.userUuid = session.uuid || '';
-        this.connectWithCredentials(server, this.sipLine, session.displayName(), options);
+        return this.connectWithCredentials(server, this.sipLine, session.displayName(), options);
     }
-    connectWithCredentials(server, sipLine, displayName, rawOptions = {}) {
+    async connectWithCredentials(server, sipLine, displayName, rawOptions = {}) {
         if (this.phone) return;
+        if (this.connectInFlight) {
+            Phone_logger.info('connectWithCredentials: connection already in progress, reusing it and ignoring this call\'s arguments', {
+                server,
+                sipLineId: sipLine?.id
+            });
+            return this.connectInFlight;
+        }
+        this.connectInFlight = this._connectWithCredentials(server, sipLine, displayName, rawOptions).finally(()=>{
+            this.connectInFlight = null;
+        });
+        return this.connectInFlight;
+    }
+    async _connectWithCredentials(server, sipLine, displayName, rawOptions = {}) {
+        if (this.client) {
+            Phone_logger.warn('connectWithCredentials: closing previous client before creating a new one');
+            try {
+                await this.client.close();
+            } catch (error) {
+                Phone_logger.error('connectWithCredentials: error while closing previous client', {
+                    message: error?.message
+                });
+            }
+            if (this.phone) {
+                Phone_logger.info('connectWithCredentials: phone connected while closing previous client, keeping it');
+                return;
+            }
+        }
         const [host, port = 443] = server.split(':');
         const options = rawOptions;
         options.media = options.media || {
@@ -9723,6 +9907,24 @@ class Phone_Phone extends Emitter {
         }
         this.phone = null;
     }
+    async reset() {
+        Phone_logger.info('phone reset', {
+            phone: !!this.phone,
+            client: !!this.client
+        });
+        await this.disconnect().catch((error)=>{
+            Phone_logger.error('reset: error while disconnecting phone', {
+                message: error?.message
+            });
+        });
+        if (this.client) await this.client.close().catch((error)=>{
+            Phone_logger.error('reset: error while closing client', {
+                message: error?.message
+            });
+        });
+        this.phone = null;
+        this.client = null;
+    }
     async call(extension, withCamera = false, rawSipLine = null, audioOnly = false, conference = false) {
         if (!this.phone) return;
         const sipLine = rawSipLine || this.getPrimaryWebRtcLine();