@webex/webex-core 3.10.0 → 3.11.0

package/src/lib/services/services.js

@@ -20,6 +20,8 @@ export const DEFAULT_CLUSTER_SERVICE = 'identityLookup';
 const CLUSTER_SERVICE = process.env.WEBEX_CONVERSATION_CLUSTER_SERVICE || DEFAULT_CLUSTER_SERVICE;
 const DEFAULT_CLUSTER_IDENTIFIER =
   process.env.WEBEX_CONVERSATION_DEFAULT_CLUSTER || `${DEFAULT_CLUSTER}:${CLUSTER_SERVICE}`;
+const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
+const CATALOG_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 /* eslint-disable no-underscore-dangle */
 /**
@@ -61,6 +63,9 @@ const Services = WebexPlugin.extend({
 
   _hostCatalog: null,
 
+  // Map of active cluster ids per service, e.g. { wdm: 'urn:TEAM:ap-southeast-2_m:wdm' }
+  _activeServices: {},
+
   /**
    * Get the registry associated with this webex instance.
    *
@@ -93,6 +98,49 @@ const Services = WebexPlugin.extend({
     return this._catalogs.get(this.webex);
   },
 
+  /**
+   * Safely access localStorage if available; returns the Storage or null.
+   * @returns {Storage|null}
+   */
+  _getLocalStorageSafe() {
+    if (typeof window !== 'undefined' && window.localStorage) {
+      return window.localStorage;
+    }
+
+    return null;
+  },
+
+  /**
+   * Determine the intended preauth selection based on the current context.
+   * @param {string|undefined} currentOrgId
+   * @returns {{selectionType: string, selectionValue: string}}
+   */
+  getIntendedPreauthSelection(currentOrgId) {
+    if (this.webex.credentials?.canAuthorize) {
+      if (currentOrgId) {
+        return {
+          selectionType: 'orgId',
+          selectionValue: currentOrgId,
+        };
+      }
+    }
+
+    const emailConfig = this.webex.config && this.webex.config.email;
+
+    if (typeof emailConfig === 'string' && emailConfig.trim()) {
+      return {
+        selectionType: 'emailhash',
+        selectionValue: sha256(emailConfig.toLowerCase()).toString(),
+      };
+    }
+
+    // fall back to proximity mode when no orgId or email available
+    return {
+      selectionType: 'mode',
+      selectionValue: 'DEFAULT_BY_PROXIMITY',
+    };
+  },
+
   /**
    * Get a service url from the current services list by name
    * from the associated instance catalog.
@@ -160,6 +208,50 @@ const Services = WebexPlugin.extend({
     return catalog.markFailedUrl(url, noPriorityHosts);
   },
 
+  /**
+   * Get all Mobius cluster host entries from the legacy host catalog.
+   * @returns {Array<{host: string, id: string, ttl: number, priority: number}>}
+   */
+  getMobiusClusters() {
+    this.logger.info('services: fetching mobius clusters');
+    const clusters = [];
+    const hostCatalog = this._hostCatalog || {};
+
+    Object.entries(hostCatalog).forEach(([host, entries]) => {
+      (entries || []).forEach((entry) => {
+        if (typeof entry?.id === 'string' && entry.id.endsWith(':mobius')) {
+          // Ensure host is included; prefer entry.host if present, else use the map key
+          const withHost = entry.host ? entry.host : host;
+          // Skip duplicates for the same host
+          if (!clusters.find((c) => c && c.host === withHost)) {
+            clusters.push({...entry, host: withHost});
+          }
+        }
+      });
+    });
+
+    return clusters;
+  },
+
+  /**
+   * Check is valid host from the legacy host catalog.
+   * @param {string} host
+   * @returns {Boolean}
+   */
+  isValidHost(host) {
+    const hostCatalog = this._hostCatalog || {};
+
+    return !!hostCatalog[host]?.length;
+  },
+  /**
+   * Merge provided active cluster mappings into current state.
+   * @param {Record<string,string>} activeServices
+   * @returns {void}
+   */
+  _updateActiveServices(activeServices) {
+    this._activeServices = {...this._activeServices, ...activeServices};
+  },
+
   /**
    * saves all the services from the pre and post catalog service
    * @param {Object} serviceUrls
@@ -191,7 +283,7 @@ const Services = WebexPlugin.extend({
    * @param {string} [param.token] - used for signin catalog
    * @returns {Promise<object>}
    */
-  updateServices({from, query, token, forceRefresh} = {}) {
+  async updateServices({from, query, token, forceRefresh} = {}) {
     const catalog = this._getCatalog();
     let formattedQuery;
     let serviceGroup;
@@ -245,7 +337,20 @@ const Services = WebexPlugin.extend({
       forceRefresh,
     })
       .then((serviceHostMap) => {
-        catalog.updateServiceUrls(serviceGroup, serviceHostMap);
+        const formattedServiceHostMap = this._formatReceivedHostmap(serviceHostMap);
+        // Build selection metadata for caching discrimination
+        let selectionMeta;
+        if (serviceGroup === 'preauth' || serviceGroup === 'signin') {
+          const key = formattedQuery && Object.keys(formattedQuery || {})[0];
+          if (key) {
+            selectionMeta = {
+              selectionType: key,
+              selectionValue: formattedQuery[key],
+            };
+          }
+        }
+        this._cacheCatalog(serviceGroup, serviceHostMap, selectionMeta);
+        catalog.updateServiceUrls(serviceGroup, formattedServiceHostMap);
         this.updateCredentialsConfig();
         catalog.status[serviceGroup].collecting = false;
       })
@@ -473,10 +578,14 @@ const Services = WebexPlugin.extend({
             ({countryCode, timezone} = clientRegionInfo);
           }
 
-          // Send the user activation request to the **License** service.
+          // Send the user activation request.
+          // Use user-onboarding service if configured, otherwise use license service.
+          const useUserOnboarding =
+            this.webex.config.services?.useUserOnboardingServiceForActivations;
+
           return this.request({
-            service: 'license',
-            resource: 'users/activations',
+            service: useUserOnboarding ? 'user-onboarding' : 'license',
+            resource: useUserOnboarding ? 'api/v1/users/activations' : 'users/activations',
             method: 'POST',
             headers: {
               accept: 'application/json',
@@ -958,7 +1067,197 @@ const Services = WebexPlugin.extend({
 
     return this.webex.internal.newMetrics.callDiagnosticLatencies
       .measureLatency(() => this.request(requestObject), 'internal.get.u2c.time')
-      .then(({body}) => this._formatReceivedHostmap(body));
+      .then(({body}) => body);
+  },
+
+  /**
+   * Cache the catalog in the bounded storage.
+   * @param {string} serviceGroup - preauth, signin, postauth
+   * @param {object} hostMap - The hostmap to cache
+   * @param {object} [meta] - Optional selection metadata used to validate cache reuse
+   * @returns {Promise<void>}
+   *
+   */
+  async _cacheCatalog(serviceGroup, hostMap, meta) {
+    let current = {};
+    let orgId;
+    try {
+      // Respect calling.cacheU2C toggle; if disabled, skip writing cache
+      if (!this.webex.config?.calling?.cacheU2C) {
+        this.logger.info(`services: skipping cache write for ${serviceGroup} as per the config`);
+
+        return;
+      }
+
+      // Persist to localStorage to survive browser refresh
+      try {
+        const ls = this._getLocalStorageSafe();
+        const cachedJson = ls ? ls.getItem(CATALOG_CACHE_KEY_V1) : null;
+        current = cachedJson ? JSON.parse(cachedJson) : {};
+      } catch (e) {
+        current = {};
+      }
+
+      try {
+        const {credentials} = this.webex;
+        orgId = credentials.getOrgId();
+      } catch (e) {
+        orgId = current.orgId;
+      }
+
+      // Capture environment fingerprint to invalidate cache across env changes
+      let {env} = current;
+      const fedramp = !!this.webex?.config?.fedramp;
+      const u2cDiscoveryUrl = this.webex?.config?.services?.discovery?.u2c;
+      env = {fedramp, u2cDiscoveryUrl};
+
+      const updated = {
+        ...current,
+        orgId: orgId || current.orgId,
+        env: env || current.env,
+        // When selection meta is provided, store as an object; otherwise keep legacy shape
+        [serviceGroup]: meta ? {hostMap, meta} : hostMap,
+        cachedAt: Date.now(),
+      };
+
+      const ls = this._getLocalStorageSafe();
+      if (ls) {
+        ls.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify(updated));
+      }
+    } catch (error) {
+      this.logger.warn('services: error caching catalog', error);
+    }
+  },
+
+  /**
+   * Load the catalog from cache and hydrate the in-memory ServiceCatalog.
+   * @returns {Promise<boolean>} true if cache was loaded, false otherwise
+   */
+  async _loadCatalogFromCache() {
+    let currentOrgId;
+    try {
+      // Respect calling.cacheU2C toggle; if disabled, skip using cache
+      if (!this.webex.config?.calling?.cacheU2C) {
+        this.logger.info('services: skipping cache warm-up as per the cache config');
+
+        return false;
+      }
+
+      const ls = this._getLocalStorageSafe();
+      if (!ls) {
+        this.logger.info('services: skipping cache warm-up as no localStorage is available');
+
+        return false;
+      }
+      const cachedJson = ls.getItem(CATALOG_CACHE_KEY_V1);
+      const cached = cachedJson ? JSON.parse(cachedJson) : undefined;
+      if (!cached) {
+        return false;
+      }
+      // TTL enforcement: clear if older than 24 hours
+      const cachedAt = Number(cached.cachedAt) || 0;
+      if (!cachedAt || Date.now() - cachedAt > CATALOG_TTL_MS) {
+        this.clearCatalogCache();
+
+        return false;
+      }
+
+      // If authorized, ensure cached org matches
+      try {
+        if (this.webex.credentials?.canAuthorize) {
+          const {credentials} = this.webex;
+          currentOrgId = credentials.getOrgId();
+          if (cached.orgId && cached.orgId !== currentOrgId) {
+            return false;
+          }
+        }
+      } catch (e) {
+        this.logger.warn('services: error checking orgId', e);
+      }
+
+      // Ensure cached environment matches current environment
+
+      const fedramp = !!this.webex.config?.fedramp;
+      const u2cDiscoveryUrl = this.webex.config?.services?.discovery?.u2c;
+      const currentEnv = {fedramp, u2cDiscoveryUrl};
+      if (cached.env) {
+        const sameEnv =
+          cached.env.fedramp === currentEnv.fedramp &&
+          cached.env.u2cDiscoveryUrl === currentEnv.u2cDiscoveryUrl;
+        if (!sameEnv) {
+          this.logger.info('services: skipping cache warm due to environment mismatch');
+
+          return false;
+        }
+      }
+
+      const catalog = this._getCatalog();
+
+      // Apply any cached groups (with preauth selection validation if available)
+      const groups = ['preauth', 'signin', 'postauth'];
+      groups.forEach((serviceGroup) => {
+        const cachedGroup = cached[serviceGroup];
+        if (!cachedGroup) {
+          return;
+        }
+
+        // Support legacy (hostMap) and new ({hostMap, meta}) shapes
+        const hostMap = cachedGroup && cachedGroup.hostMap ? cachedGroup.hostMap : cachedGroup;
+        const meta = cachedGroup?.meta;
+
+        if (serviceGroup === 'preauth' && meta) {
+          // For proximity-based selection, always fetch fresh to respect IP/region changes
+          if (meta.selectionType === 'mode') {
+            this.logger.info('services: skipping preauth cache warm for proximity mode');
+
+            return;
+          }
+
+          const intended = this.getIntendedPreauthSelection(currentOrgId);
+          const matches =
+            intended &&
+            intended.selectionType === meta.selectionType &&
+            intended.selectionValue === meta.selectionValue;
+
+          if (!matches) {
+            this.logger.info('services: skipping preauth cache warm due to selection mismatch');
+
+            return;
+          }
+        }
+
+        if (hostMap) {
+          const formatted = this._formatReceivedHostmap(hostMap);
+          catalog.updateServiceUrls(serviceGroup, formatted);
+        }
+      });
+
+      // Align credentials against warmed catalog
+      this.updateCredentialsConfig();
+
+      return true;
+    } catch (e) {
+      this.logger.warn('services: error loading catalog from cache', e);
+
+      return false;
+    }
+  },
+
+  /**
+   * Clear the catalog cache from the bounded storage.
+   * @returns {Promise<void>}
+   */
+  clearCatalogCache() {
+    try {
+      const ls = this._getLocalStorageSafe();
+      if (ls) {
+        ls.removeItem(CATALOG_CACHE_KEY_V1);
+      }
+    } catch (e) {
+      this.logger.warn('services: error clearing catalog cache', e);
+    }
+
+    return Promise.resolve();
   },
 
   /**
@@ -1038,6 +1337,7 @@ const Services = WebexPlugin.extend({
           // Validate if the token is authorized.
           if (credentials.canAuthorize) {
             // Attempt to collect the postauth catalog.
+
             return this.updateServices().catch(() => {
               this.initFailed = true;
               this.logger.warn('services: cannot retrieve postauth catalog');
@@ -1073,7 +1373,15 @@ const Services = WebexPlugin.extend({
 
     // wait for webex instance to be ready before attempting
     // to update the service catalogs
-    this.listenToOnce(this.webex, 'ready', () => {
+    // this can cause a race condition because credentials may
+    // not be valid when services is initialized
+    this.listenToOnce(this.webex, 'ready', async () => {
+      const cachedCatalog = await this._loadCatalogFromCache();
+      if (cachedCatalog) {
+        catalog.isReady = true;
+
+        return; // skip initServiceCatalogs() on reload when cache exists
+      }
       const {supertoken} = this.webex.credentials;
       // Validate if the supertoken exists.
       if (supertoken && supertoken.access_token) {

package/src/lib/services-v2/index.ts

@@ -1,7 +1,6 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-
 export {default as ServicesV2} from './services-v2';
 export {default as ServiceCatalogV2} from './service-catalog';
 export {default as ServiceDetail} from './service-detail';

package/src/lib/services-v2/service-catalog.ts

@@ -119,7 +119,7 @@ const ServiceCatalog = AmpState.extend({
     // declare namespaces outside of loop
     let existingService: IServiceDetail | undefined;
 
-    serviceDetails.forEach((service) => {
+    serviceDetails?.forEach((service) => {
       existingService = this._getServiceDetail(service.id, serviceGroup);
 
       if (existingService) {
@@ -311,13 +311,13 @@ const ServiceCatalog = AmpState.extend({
   ) {
     const currentServiceDetails = this.serviceGroups[serviceGroup];
 
-    const unusedServicesDetails = currentServiceDetails.filter((serviceDetail) =>
-      serviceDetails.every(({id}) => id !== serviceDetail.id)
+    const unusedServicesDetails = currentServiceDetails?.filter((serviceDetail) =>
+      serviceDetails?.every(({id}) => id !== serviceDetail.id)
     );
 
     this._unloadServiceDetails(serviceGroup, unusedServicesDetails);
 
-    serviceDetails.forEach((serviceObj) => {
+    serviceDetails?.forEach((serviceObj) => {
       const serviceDetail = this._getServiceDetail(serviceObj.id, serviceGroup);
       serviceObj?.serviceUrls?.sort((a, b) => {
         if (a.priority < 0 && b.priority < 0) return 0;