genesys-cloud-streaming-client 19.5.1-develop.15 → 19.6.0-release.1

package/README.md

@@ -1,20 +1,23 @@
-# Genesys Cloud Streaming Client #
+## Streaming Client
+[![Test Matrix](https://github.com/purecloudlabs/genesys-cloud-streaming-client/actions/workflows/matrix.yml/badge.svg)](https://github.com/purecloudlabs/genesys-cloud-streaming-client/actions/workflows/matrix.yml)
 
-This project is a Bitbucket repository that contains the pipeline infrastructure for the open source [Genesys Cloud Streaming Client](https://github.com/purecloudlabs/genesys-cloud-streaming-client) hosted on GitHub.
+### Overview
+Client library for streaming-service
 
-### Playbook
-See [docs/playbook.md](docs/playbook.md).
+### Installation
+Run `npm install` in order to install all the dependencies
 
-### What is this repository for?
+### Testing
+Run the tests using `npm test` in the command line
 
-Current guidance from security and the CI/CD teams is to not have the pipeline infrastructure available in open source repositories. This repository is used to host the pipeline infrastructure for the Genesys Cloud Streaming Client so that we may retain access to the CDN and ability to publish to NPM.
+**In order to see code coverage run `npm run test:coverage`**
 
-### Contributions
+### Build for Local Use
+Run the script `npm run build`
 
-* Leave all source code in the GitHub repository.
-* Only pipeline infrastructure should be in this repository.
+### Linting and Style
+semistandard has been added and you can run linting through the command line via `npm run lint` script
 
-### Who do I talk to?
+To fix minor styling errors, run `npm run lint:fix`
 
-* gcmediastreamsignal@genesys.com
-* Client Signaling and Streaming Team (STREAM).
+**If you can configure you editor to run linting while typing or on save this is preferrable**

package/dist/cjs/alerting-leader.d.ts

@@ -0,0 +1,14 @@
+import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export declare class AlertingLeaderExtension implements StreamingClientExtension {
+    private client;
+    private connectionId?;
+    private alertableInteractionTypes;
+    constructor(client: Client, options: IClientOptions);
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private markAsAlertable;
+    get expose(): AlertingLeaderApi;
+}
+export interface AlertingLeaderApi {
+}

package/dist/cjs/alerting-leader.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingLeaderExtension = void 0;
+const utils_1 = require("./utils");
+class AlertingLeaderExtension {
+    constructor(client, options) {
+        var _a;
+        this.client = client;
+        this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        var _a, _b;
+        this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
+        if (this.alertableInteractionTypes.length !== 0) {
+            this.markAsAlertable();
+        }
+    }
+    async markAsAlertable() {
+        const userId = this.client.config.userId;
+        const connectionsRequestOptions = {
+            method: 'patch',
+            host: this.client.config.apiHost,
+            authToken: this.client.config.authToken,
+            logger: this.client.logger,
+            data: {
+                alertable: true
+            }
+        };
+        // STREAM-1204
+        // There's a race condition between the backend service knowing about the connection
+        // and us marking the connection as alertable. For now, we'll just retry with some delay.
+        const maxRetries = 16;
+        let retryCount = 0;
+        const retry = (0, utils_1.retryPromise)(() => this.client.http.requestApi(`apps/users/${userId}/connections/${this.connectionId}`, connectionsRequestOptions), () => {
+            retryCount++;
+            if (retryCount >= maxRetries) {
+                this.client.logger.info('Max retries reached for marking connection as alertable');
+                return false;
+            }
+            return true;
+        }, 500, this.client.logger);
+        return retry.promise
+            .catch(() => {
+            this.client.logger.warn('Could not mark this connection as alertable; this client may not alert for incoming interactions');
+        });
+    }
+    get expose() {
+        return {};
+    }
+}
+exports.AlertingLeaderExtension = AlertingLeaderExtension;

package/dist/cjs/client.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Logger } from 'genesys-cloud-client-logger';
 import './polyfills';
+import { AlertingLeaderExtension, AlertingLeaderApi } from './alerting-leader';
 import { Notifications, NotificationsAPI } from './notifications';
 import { WebrtcExtension, WebrtcExtensionAPI } from './webrtc';
 import { Ping } from './ping';
@@ -39,6 +40,8 @@ export declare class Client extends EventEmitter {
     _webrtcSessions: WebrtcExtension;
     messenger: MessengerExtension;
     _messenger: MessengerExtensionApi;
+    alertingLeader: AlertingLeaderApi;
+    _alertingLeader: AlertingLeaderExtension;
     _ping: Ping;
     constructor(options: IClientOptions);
     private handleSendEventFromExtension;
@@ -60,6 +63,15 @@ export declare class Client extends EventEmitter {
     private backoffConnectRetryHandler;
     private networkErrorNeedsAuth;
     private saslErrorIsRetryable;
+    /**
+     * Performs an active network connectivity check by querying the API.
+     * navigator.onLine is unreliable (VPNs, virtual adapters, etc.), so we
+     * actually reach out to verify we can talk to the server.
+     *
+     * Returns true if connectivity is confirmed, false otherwise.
+     * This is advisory only — it does not gate connection attempts.
+     */
+    checkNetworkConnectivity(): Promise<boolean>;
     private makeConnectionAttempt;
     private setupConnectionMonitoring;
     private prepareForConnect;

package/dist/cjs/client.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const limiter_1 = require("limiter");
 const genesys_cloud_client_logger_1 = require("genesys-cloud-client-logger");
 require("./polyfills");
+const alerting_leader_1 = require("./alerting-leader");
 const notifications_1 = require("./notifications");
 const webrtc_1 = require("./webrtc");
 const ping_1 = require("./ping");
@@ -15,7 +16,6 @@ const interfaces_1 = require("./types/interfaces");
 const events_1 = tslib_1.__importDefault(require("events"));
 const connection_manager_1 = require("./connection-manager");
 const exponential_backoff_1 = require("exponential-backoff");
-const offline_error_1 = tslib_1.__importDefault(require("./types/offline-error"));
 const sasl_error_1 = tslib_1.__importDefault(require("./types/sasl-error"));
 const timeout_error_1 = require("./types/timeout-error");
 const messenger_1 = require("./messenger");
@@ -25,7 +25,8 @@ const user_cancelled_error_1 = tslib_1.__importDefault(require("./types/user-can
 const extensions = {
     notifications: notifications_1.Notifications,
     webrtcSessions: webrtc_1.WebrtcExtension,
-    messenger: messenger_1.MessengerExtension
+    messenger: messenger_1.MessengerExtension,
+    alertingLeader: alerting_leader_1.AlertingLeaderExtension
 };
 const STANZA_DISCONNECTED = 'stanzaDisconnected';
 const NO_LONGER_SUBSCRIBED = 'notify:no_longer_subscribed';
@@ -198,7 +199,18 @@ class Client extends events_1.default {
         this.activeStanzaInstance = undefined;
         this.emit('disconnected', { reconnecting: this.autoReconnect });
         if (this.autoReconnect) {
-            return this.connect({ keepTryingOnFailure: true });
+            return this.connect({ keepTryingOnFailure: true })
+                .catch(error => {
+                this.logger.error('Failed to auto reconnect', {
+                    keepTryingOnFailure: true,
+                    stanzaInstanceId: disconnectedInstance.id,
+                    channelId: disconnectedInstance.channelId
+                });
+                this.emit('disconnected', {
+                    error,
+                    reconnecting: false
+                });
+            });
         }
     }
     handleNoLongerSubscribed(stanzaInstance) {
@@ -453,14 +465,14 @@ class Client extends events_1.default {
                 // retry after comes in seconds, we need to return milliseconds
                 const retryDelay = parseInt(retryAfter, 10) * 1000;
                 additionalErrorDetails.retryDelay = retryDelay;
-                this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
+                this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails);
                 await (0, utils_1.delay)(retryDelay);
                 this.logger.debug('finished waiting for retry-after');
                 return true;
             }
         }
         const connectionData = this.increaseBackoff();
-        this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
+        this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails);
         this.logger.debug('debug: retry info', { expectedRetryInMs: connectionData.currentDelayMs, appName: this.config.appName, clientId: this.logger.clientId });
         return true;
     }
@@ -472,14 +484,57 @@ class Client extends events_1.default {
         const retryConditions = ['encryption-required', 'incorrect-encoding', 'invalid-mechanism', 'malformed-request', 'mechanism-too-weak'];
         return retryConditions.includes(error.condition);
     }
+    /**
+     * Performs an active network connectivity check by querying the API.
+     * navigator.onLine is unreliable (VPNs, virtual adapters, etc.), so we
+     * actually reach out to verify we can talk to the server.
+     *
+     * Returns true if connectivity is confirmed, false otherwise.
+     * This is advisory only — it does not gate connection attempts.
+     */
+    async checkNetworkConnectivity() {
+        // Quick hint check first — if the browser says offline, that's a strong signal
+        if (!navigator.onLine) {
+            this.logger.warn('navigator.onLine reports offline — connectivity may be unavailable');
+            this.emit('networkConnectivityWarning', { reason: 'navigator.onLine is false' });
+            return false;
+        }
+        // JWT-based connections (e.g. background assistants) don't have an auth token
+        // that works with the users/me endpoint, so we can only rely on navigator.onLine
+        if (this.config.jwt && !this.config.authToken) {
+            this.logger.debug('Skipping active connectivity check in JWT mode, relying on navigator.onLine');
+            return true;
+        }
+        try {
+            const opts = {
+                method: 'get',
+                host: this.config.apiHost,
+                authToken: this.config.authToken,
+                logger: this.logger,
+                requestTimeout: 10000
+            };
+            await this.http.requestApi('users/me', opts);
+            return true;
+        }
+        catch (err) {
+            this.logger.warn('Active network connectivity check failed — connectivity may be unavailable', { error: err });
+            this.emit('networkConnectivityWarning', { reason: 'active connectivity check failed', error: err });
+            return false;
+        }
+    }
     async makeConnectionAttempt() {
         var _a, _b;
         if (this.cancelConnectionAttempt) {
             throw new user_cancelled_error_1.default('Connection attempt cancelled');
         }
-        if (!navigator.onLine) {
-            throw new offline_error_1.default('Browser is offline, skipping connection attempt');
-        }
+        // navigator.onLine is unreliable — use it as a hint, not a gate.
+        // Fire off an active connectivity check in the background. It will
+        // log and emit warnings if there's an issue, but we don't wait for it.
+        this.checkNetworkConnectivity().then(isConnected => {
+            if (!isConnected) {
+                this.logger.warn('Network connectivity check failed, but proceeding with connection attempt anyway');
+            }
+        });
         let stanzaInstance;
         const previousConnectingState = this.connecting;
         try {
@@ -553,9 +608,9 @@ class Client extends events_1.default {
             }
         }
         if (this.hardReconnectRequired) {
-            let jidPromise;
-            if (this.config.jid) {
-                jidPromise = Promise.resolve(this.config.jid);
+            let userPromise;
+            if (this.config.userId && this.config.jid) {
+                userPromise = Promise.resolve({ userId: this.config.userId, jid: this.config.jid });
             }
             else {
                 const jidRequestOpts = {
@@ -564,8 +619,13 @@ class Client extends events_1.default {
                     authToken: this.config.authToken,
                     logger: this.logger
                 };
-                jidPromise = await this.http.requestApi('users/me', jidRequestOpts)
-                    .then(res => res.data.chat.jabberId);
+                userPromise = this.http.requestApi('users/me', jidRequestOpts)
+                    .then(res => {
+                    return {
+                        userId: res.data.id,
+                        jid: res.data.chat.jabberId
+                    };
+                });
             }
             // If no jidResource is provided, generate a random one to maintain ourselves.
             this.jidResource = this.config.jidResource || (0, uuid_1.v4)();
@@ -577,7 +637,8 @@ class Client extends events_1.default {
             };
             const channelPromise = await this.http.requestApi('notifications/channels?connectionType=streaming', channelRequestOpts)
                 .then(res => res.data.id);
-            const [jid, channelId] = await Promise.all([jidPromise, channelPromise]);
+            const [{ userId, jid }, channelId] = await Promise.all([userPromise, channelPromise]);
+            this.config.userId = userId;
             this.config.jid = jid;
             this.config.jidResource = this.jidResource;
             this.config.channelId = channelId;
@@ -609,7 +670,7 @@ class Client extends events_1.default {
         return Client.version;
     }
     static get version() {
-        return '19.5.1';
+        return '19.6.0';
     }
 }
 exports.Client = Client;

package/dist/cjs/notifications.d.ts

@@ -11,6 +11,7 @@ export declare class Notifications implements StreamingClientExtension {
     topicPriorities: any;
     debouncedResubscribe: () => Promise<BulkSubscribeResult>;
     enablePartialBulkResubscribe: boolean;
+    private internalSubscriptions;
     constructor(client: any, options?: IClientOptions);
     get pubsubHost(): string;
     handleStanzaInstanceChange(stanza: NamedAgent): void;
@@ -47,6 +48,12 @@ export declare class Notifications implements StreamingClientExtension {
     };
     setTopicPriorities(priorities?: {}): void;
     subscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean, priority?: number): Promise<TopicSubscribeResult>;
+    /**
+     * Use `_subscribeInternal` when subscribing to a topic from within streaming-client itself.
+     * Internal subscriptions won't be overwritten by subscriptions from consumers and will be prioritized
+     * over subscriptions from consumers.
+     */
+    _subscribeInternal(topic: string): Promise<PubsubSubscriptionWithOptions | void>;
     unsubscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean): Promise<any>;
     bulkSubscribe(topics: string[], options?: BulkSubscribeOpts, priorities?: {
         [topicName: string]: number;

package/dist/cjs/notifications.js

@@ -18,6 +18,7 @@ class Notifications {
         this.subscriptions = {};
         this.bulkSubscriptions = {};
         this.topicPriorities = {};
+        this.internalSubscriptions = [];
         this.client = client;
         this.enablePartialBulkResubscribe = (_a = options === null || options === void 0 ? void 0 : options.enablePartialBulkResubscribe) !== null && _a !== void 0 ? _a : false;
         client.on('pubsub:event', this.pubsubEvent.bind(this));
@@ -41,7 +42,11 @@ class Notifications {
         this.stanzaInstance = stanza;
         if (needsToResub) {
             this.client.logger.info('resubscribing due to hard reconnect');
-            void this.debouncedResubscribe();
+            this.debouncedResubscribe().catch((err) => {
+                const msg = 'Error resubscribing to topics';
+                this.client.logger.error(msg, err);
+                this.client.emit('pubsub:error', { msg, err });
+            });
         }
     }
     topicHandlers(topic) {
@@ -330,6 +335,21 @@ class Notifications {
         }
         return topicResult;
     }
+    /**
+     * Use `_subscribeInternal` when subscribing to a topic from within streaming-client itself.
+     * Internal subscriptions won't be overwritten by subscriptions from consumers and will be prioritized
+     * over subscriptions from consumers.
+     */
+    async _subscribeInternal(topic) {
+        if (this.internalSubscriptions.includes(topic)) {
+            return Promise.resolve();
+        }
+        this.setTopicPriorities({ [topic]: Number.MAX_VALUE });
+        const promise = this.xmppSubscribe(topic);
+        this.internalSubscriptions.push(topic);
+        this.bulkSubscriptions[topic] = true;
+        return promise;
+    }
     unsubscribe(topic, handler, immediate) {
         if (handler) {
             this.removeSubscription(topic, handler);
@@ -348,7 +368,7 @@ class Notifications {
     async bulkSubscribe(topics, options = { replace: false, force: false }, priorities = {}) {
         var _a;
         this.setTopicPriorities(priorities);
-        let toSubscribe = mergeAndDedup(topics, []);
+        let toSubscribe = mergeAndDedup(topics, this.internalSubscriptions);
         if (options.replace && !options.force) {
             // if this is a bulk subscription, but not a forcible one, keep all individual subscriptions
             toSubscribe = mergeAndDedup(toSubscribe, this.getActiveIndividualTopics());
@@ -388,6 +408,9 @@ class Notifications {
         topics.forEach(topic => {
             this.bulkSubscriptions[topic] = true;
         });
+        this.internalSubscriptions.forEach(topic => {
+            this.bulkSubscriptions[topic] = true;
+        });
         // Add a fallback result for any topic in the toSubscribe list that isn't already in result.
         // With partial bulk resubscribe enabled missing result means "Unknown" state but when not
         // enabled the fallback is "Permitted" for backward compatibility (success response means OK).

package/dist/cjs/types/interfaces.d.ts

@@ -24,15 +24,21 @@ export interface IClientOptions {
     customHeaders?: ICustomHeader;
     /** Allow bulk topic resubscribe to succeed or fail per-topic rather than all or nothing */
     enablePartialBulkResubscribe?: boolean;
+    /** Genesys internal use only - non-Genesys apps that pass in `alertableInteractionTypes` may experience unexpected behavior */
+    alertableInteractionTypes?: AlertableInteractionTypes[];
 }
 export interface ICustomHeader {
     [header: string]: string;
 }
+export declare enum AlertableInteractionTypes {
+    voice = "voice"
+}
 export interface IClientConfig {
     host: string;
     apiHost: string;
     authToken?: string;
     jwt?: string;
+    userId?: string;
     jid?: string;
     jidResource?: string;
     channelId: string;

package/dist/cjs/types/interfaces.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionTypes = exports.StreamingClientErrorTypes = void 0;
+exports.SessionTypes = exports.StreamingClientErrorTypes = exports.AlertableInteractionTypes = void 0;
+var AlertableInteractionTypes;
+(function (AlertableInteractionTypes) {
+    AlertableInteractionTypes["voice"] = "voice";
+})(AlertableInteractionTypes = exports.AlertableInteractionTypes || (exports.AlertableInteractionTypes = {}));
 var StreamingClientErrorTypes;
 (function (StreamingClientErrorTypes) {
     StreamingClientErrorTypes["generic"] = "generic";

package/dist/deploy-info.json

@@ -1,13 +1,13 @@
 {
-  "version": "19.5.1-develop",
-  "build": "15",
-  "buildDate": "2026-01-09T18:09:01.125Z",
+  "version": "release/v19.6.0",
+  "build": "1",
+  "buildDate": "2026-04-14T21:56:54.192Z",
   "indexFiles": [
     {
-      "file": "v19.5.1/streaming-client.browser.js"
+      "file": "v19.6.0/streaming-client.browser.js"
     },
     {
-      "file": "v19.5.1/streaming-client.browser.js.LICENSE.txt"
+      "file": "v19.6.0/streaming-client.browser.js.LICENSE.txt"
     },
     {
       "file": "v19/streaming-client.browser.js"

package/dist/es/alerting-leader.d.ts

@@ -0,0 +1,14 @@
+import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export declare class AlertingLeaderExtension implements StreamingClientExtension {
+    private client;
+    private connectionId?;
+    private alertableInteractionTypes;
+    constructor(client: Client, options: IClientOptions);
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private markAsAlertable;
+    get expose(): AlertingLeaderApi;
+}
+export interface AlertingLeaderApi {
+}

package/dist/es/alerting-leader.js

@@ -0,0 +1,50 @@
+import { __awaiter } from "tslib";
+import { retryPromise } from './utils';
+export class AlertingLeaderExtension {
+    constructor(client, options) {
+        var _a;
+        this.client = client;
+        this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        var _a, _b;
+        this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
+        if (this.alertableInteractionTypes.length !== 0) {
+            this.markAsAlertable();
+        }
+    }
+    markAsAlertable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = this.client.config.userId;
+            const connectionsRequestOptions = {
+                method: 'patch',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                data: {
+                    alertable: true
+                }
+            };
+            // STREAM-1204
+            // There's a race condition between the backend service knowing about the connection
+            // and us marking the connection as alertable. For now, we'll just retry with some delay.
+            const maxRetries = 16;
+            let retryCount = 0;
+            const retry = retryPromise(() => this.client.http.requestApi(`apps/users/${userId}/connections/${this.connectionId}`, connectionsRequestOptions), () => {
+                retryCount++;
+                if (retryCount >= maxRetries) {
+                    this.client.logger.info('Max retries reached for marking connection as alertable');
+                    return false;
+                }
+                return true;
+            }, 500, this.client.logger);
+            return retry.promise
+                .catch(() => {
+                this.client.logger.warn('Could not mark this connection as alertable; this client may not alert for incoming interactions');
+            });
+        });
+    }
+    get expose() {
+        return {};
+    }
+}

package/dist/es/client.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Logger } from 'genesys-cloud-client-logger';
 import './polyfills';
+import { AlertingLeaderExtension, AlertingLeaderApi } from './alerting-leader';
 import { Notifications, NotificationsAPI } from './notifications';
 import { WebrtcExtension, WebrtcExtensionAPI } from './webrtc';
 import { Ping } from './ping';
@@ -39,6 +40,8 @@ export declare class Client extends EventEmitter {
     _webrtcSessions: WebrtcExtension;
     messenger: MessengerExtension;
     _messenger: MessengerExtensionApi;
+    alertingLeader: AlertingLeaderApi;
+    _alertingLeader: AlertingLeaderExtension;
     _ping: Ping;
     constructor(options: IClientOptions);
     private handleSendEventFromExtension;
@@ -60,6 +63,15 @@ export declare class Client extends EventEmitter {
     private backoffConnectRetryHandler;
     private networkErrorNeedsAuth;
     private saslErrorIsRetryable;
+    /**
+     * Performs an active network connectivity check by querying the API.
+     * navigator.onLine is unreliable (VPNs, virtual adapters, etc.), so we
+     * actually reach out to verify we can talk to the server.
+     *
+     * Returns true if connectivity is confirmed, false otherwise.
+     * This is advisory only — it does not gate connection attempts.
+     */
+    checkNetworkConnectivity(): Promise<boolean>;
     private makeConnectionAttempt;
     private setupConnectionMonitoring;
     private prepareForConnect;