@webex/contact-center 3.12.0-next.157 → 3.12.0-next.159

package/src/services/ApiAiAssistant.ts

@@ -67,6 +67,18 @@ export class ApiAIAssistant {
     this.aiFeature = aiFeature;
   }
 
+  /**
+   * Validates a caller-supplied identifier (agentId/interactionId) before it is used to
+   * construct a request. Accepts a non-empty alphanumeric identifier that may contain
+   * hyphens or underscores.
+   * @param value - the identifier to validate
+   * @returns {boolean} true when the identifier is a non-empty, well-formed string
+   * @private
+   */
+  private isValidTranscriptIdentifier(value: unknown): boolean {
+    return typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+  }
+
   private async sendWellnessBreakAction(
     action: WellnessBreakUserAction,
     method: string
@@ -625,6 +637,18 @@ export class ApiAIAssistant {
       throw detailedError;
     }
 
+    if (
+      !this.isValidTranscriptIdentifier(agentId) ||
+      !this.isValidTranscriptIdentifier(interactionId)
+    ) {
+      const {error: detailedError} = getErrorDetails(
+        new Error('INVALID_AGENT_ID_OR_INTERACTION_ID'),
+        METHODS.FETCH_HISTORIC_TRANSCRIPTS,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+
     try {
       const baseUrl = this.getBaseUrl();
       const orgId = this.webex.credentials.getOrgId();

package/src/services/WebCallingService.ts

@@ -15,11 +15,13 @@ import {TIMEOUT_DURATION, WEB_CALLING_SERVICE_FILE} from '../constants';
 import LoggerProxy from '../logger-proxy';
 import {
   DEFAULT_RTMS_DOMAIN,
+  ALLOWED_RTMS_DOMAIN,
   POST_AUTH,
   WCC_CALLING_RTMS_DOMAIN,
   DEREGISTER_WEBCALLING_LINE_MSG,
   METHODS,
 } from './constants';
+import {isAllowedUrlHost} from './core/Utils';
 
 /**
  * WebCallingService provides WebRTC calling functionality for Contact Center agents.
@@ -141,9 +143,21 @@ export default class WebCallingService extends EventEmitter {
     const rtmsURL = this.webex.internal.services.get(WCC_CALLING_RTMS_DOMAIN);
 
     try {
-      const url = new URL(rtmsURL);
+      const hostname = new URL(rtmsURL).hostname.toLowerCase();
+
+      if (!isAllowedUrlHost(rtmsURL, [ALLOWED_RTMS_DOMAIN])) {
+        LoggerProxy.error(
+          `Non-allow-listed RTMS host from u2c catalogue: ${hostname} so falling back to default domain`,
+          {
+            module: WEB_CALLING_SERVICE_FILE,
+            method: METHODS.GET_RTMS_DOMAIN,
+          }
+        );
+
+        return DEFAULT_RTMS_DOMAIN;
+      }
 
-      return url.hostname;
+      return hostname;
     } catch (error) {
       LoggerProxy.error(
         `Invalid URL from u2c catalogue: ${rtmsURL} so falling back to default domain`,

package/src/services/ai-docs/services-spec.md

@@ -70,7 +70,7 @@ Each service folder contains its own `ai-docs/` with detailed documentation. **A
 
 **Paginated data services** (AddressBook, Queue, EntryPoint) do not have dedicated ai-docs. Read their source files directly — they follow shared REST/pagination/caching patterns documented in [`ai-docs/patterns/typescript-patterns.md`](../../../ai-docs/patterns/typescript-patterns.md). `UserPreference` is also a direct REST service, but it has CRUD semantics and does not use their PageCache pattern.
 
-**WebCallingService** also has no dedicated ai-docs, but it follows a different pattern: EventEmitter-based call lifecycle orchestration around `@webex/calling` (`createClient`, line registration/deregistration, `ICall` events), `callTaskMap` tracking, and async registration flows with timeout handling. Read [`WebCallingService.ts`](../WebCallingService.ts) directly when changing browser calling behavior.
+**WebCallingService** also has no dedicated ai-docs, but it follows a different pattern: EventEmitter-based call lifecycle orchestration around `@webex/calling` (`createClient`, line registration/deregistration, `ICall` events), `callTaskMap` tracking, and async registration flows with timeout handling. Before registering the calling line it resolves the RTMS domain from the u2c service catalog through `getRTMSDomain()`, which trusts the catalog host only when it is on the `ALLOWED_RTMS_DOMAIN` allow-list and otherwise falls back to `DEFAULT_RTMS_DOMAIN`. Read [`WebCallingService.ts`](../WebCallingService.ts) directly when changing browser calling behavior.
 
 The `ContactCenter` plugin class (`cc.ts`) is the **only public entry point**. It delegates all backend work to the services layer:
 
@@ -212,6 +212,8 @@ Use [`constants.ts`](../constants.ts) as the canonical source for service-level
 
 - `DEFAULT_RTMS_DOMAIN`, `WCC_CALLING_RTMS_DOMAIN` — RTMS/WebRTC domain constants
 
+- `ALLOWED_RTMS_DOMAIN` — trusted RTMS domain suffix (`rtmsprod.net`); a catalog-provided RTMS host is used only when its hostname equals or is a subdomain of this value, otherwise `DEFAULT_RTMS_DOMAIN` is used
+
 - `METHODS` — method name constants used by `WebCallingService`
 
 ## Key Files (source of truth)
@@ -267,6 +269,8 @@ ContactCenter READY callback
 | SERVICES-R-006 | Treat Services composition as unconditionally created by the ContactCenter READY callback; Services owns no rollout or feature-flag decision. | Capability flags belong to the consuming config/task/calling collaborators, so the composition root must not silently gate construction. | `src/services/index.ts`, `src/cc.ts` | `test/unit/spec/cc.ts` | None; rollout applicability is explicitly N/A for Services. | PRESENT |
 | SERVICES-R-007 | Existing Queue and EntryPoint list methods must apply inbound, active, telephony, profile/agent-view, and `name,ASC` defaults while retaining their established parameter and full-record response types. Caller-supplied existing filter, sort, or profile inputs override defaults. Queue must also treat `sortOrder` without `sortBy` as a name sort and bypass the simple-page cache. | Defaults on the established methods let thin consumers request lists without a parallel API, while existing parameters preserve specialized behavior for other consumers and full-record types remain truthful because no field projection is requested. | `src/services/Queue.ts`, `src/services/EntryPoint.ts`, `src/types.ts` | `test/unit/spec/services/Queue.ts`, `test/unit/spec/services/EntryPoint.ts`, `test/unit/spec/cc.ts` | The backend honors the view flags and combined CMS sort value. | PRESENT |
 | SERVICES-R-008 | ApiAIAssistant wellness requests must accept no public identity or context-mutating input, read effective enablement and non-empty SDK-owned organization/agent/session context from a read-only provider supplied at construction, then POST the exact `WellnessBreakAction` custom-event body directly to `/event`; only HTTP 202 resolves successfully. Public action unions derive from exported `as const` action-value objects. | SDK-owned live context prevents callers from supplying stale/different login identities to action calls, one value/type source prevents wire drift, and direct HTTP matches the AI event endpoint rather than AQM completion semantics. | `src/services/ApiAiAssistant.ts`, `src/types.ts`, `src/index.ts`, `src/cc.ts` | `test/unit/spec/services/ApiAiAssistant.ts`, `test/unit/spec/cc.ts` | None. | PRESENT |
+| SERVICES-R-009 | `WebCallingService.getRTMSDomain()` returns a catalog-provided RTMS hostname only when it equals `ALLOWED_RTMS_DOMAIN` (`rtmsprod.net`) or is a subdomain of it; a parseable but non-allow-listed host, or a catalog value that is not a valid URL, falls back to `DEFAULT_RTMS_DOMAIN`. The rejected host is logged as a diagnostic before fallback. | The u2c service catalog is an untrusted input at the calling trust boundary; allow-listing the RTMS host prevents WebRTC registration against an attacker-controlled domain. | `src/services/WebCallingService.ts`, `src/services/constants.ts` | `test/unit/spec/services/WebCallingService.ts` | The `@webex/calling` client accepts the resolved domain string. | PRESENT |
+| SERVICES-R-010 | `ApiAIAssistant.fetchHistoricTranscripts(agentId: string, interactionId: string): Promise<HistoricTranscriptsResponse>` validates both caller-supplied identifiers before building the authenticated request, accepting only non-empty strings matching the identifier format `^[A-Za-z0-9_-]{1,128}$`. Invalid inputs reject with a typed error and no request is sent. | `agentId`/`interactionId` are caller-controlled inputs on an authenticated request boundary; validating them before use rejects malformed identifiers instead of forwarding them to the backend. | `src/services/ApiAiAssistant.ts` | `test/unit/spec/services/ApiAiAssistant.ts` | Real-time transcription feature flag must already be enabled; format validation runs after that gate. | PRESENT |
 
 ## Design Overview
 `Services` is a singleton composition root for transport-facing capabilities only. It constructs two `WebSocketManager` instances (primary Contact Center and RTD), creates `AqmReqs` on the primary manager, then creates config, agent, contact, dialer, and ConnectionService collaborators.
@@ -415,6 +419,7 @@ classDiagram
 - ApiAIAssistant, TaskManager, and UserPreference are READY-time ContactCenter collaborators, not fields constructed by Services.
 - Authentication is inherited from the host SDK through Core/WebexRequest; Services owns no credential lifecycle.
 - Rollout applicability is N/A for the Services composition root: it is created at READY and does not evaluate a feature flag.
+- Untrusted external inputs are validated at the service trust boundary: catalog-provided RTMS hosts must pass the `ALLOWED_RTMS_DOMAIN` allow-list before use, and caller-supplied `agentId`/`interactionId` must match the accepted identifier format before an authenticated transcript request is built.
 - ApiAIAssistant evaluates the current effective wellness flag and identities through its constructor-supplied read-only provider; the public object exposes no context mutator, and the Services singleton itself remains unconditionally composed.
 
 ## Concurrency & Reactive Flow
@@ -489,6 +494,8 @@ Unit tests mirror module paths under `test/unit/spec/services`. Preserve positiv
 | `SERVICES-R-006` | `test/unit/spec/cc.ts` | None. |
 | `SERVICES-R-007` | `test/unit/spec/services/Queue.ts`, `test/unit/spec/services/EntryPoint.ts`, `test/unit/spec/cc.ts` | None. |
 | `SERVICES-R-008` | `test/unit/spec/services/ApiAiAssistant.ts` | None. |
+| `SERVICES-R-009` | `test/unit/spec/services/WebCallingService.ts` | Cover allowed host, subdomain, non-allow-listed host, and unparseable catalog value fallback. |
+| `SERVICES-R-010` | `test/unit/spec/services/ApiAiAssistant.ts` | Cover valid identifiers plus empty, over-length, and disallowed-character rejections. |
 
 ## Traceability
 - Repo architecture: `../../../ai-docs/ARCHITECTURE.md` · Registry: `../../../ai-docs/SPEC_INDEX.md`

package/src/services/constants.ts

@@ -32,6 +32,16 @@ export const WCC_CALLING_RTMS_DOMAIN = 'wcc-calling-rtms-domain';
  */
 export const DEFAULT_RTMS_DOMAIN = 'rtw.prod-us1.rtmsprod.net';
 
+/**
+ * Trusted domain suffix for RTMS hosts returned by the u2c service catalog. A catalog-provided
+ * RTMS host is only used when its hostname is, or is a subdomain of, this domain; otherwise
+ * `DEFAULT_RTMS_DOMAIN` is used.
+ * @type {string}
+ * @public
+ * @ignore
+ */
+export const ALLOWED_RTMS_DOMAIN = 'rtmsprod.net';
+
 /**
  * Timeout in milliseconds for WebSocket events.
  * @type {number}

package/src/services/core/Utils.ts

@@ -103,6 +103,30 @@ export const isValidDialNumber = (
   });
 };
 
+/**
+ * Checks whether a URL's hostname is, or is a subdomain of, one of the allowed domains.
+ *
+ * @param url - The candidate URL to validate
+ * @param allowedDomains - Domains (or domain suffixes) the URL's hostname must match
+ * @returns true when the URL parses and its hostname matches an allowed domain, false otherwise
+ */
+export const isAllowedUrlHost = (
+  url: string | undefined | null,
+  allowedDomains: string[]
+): boolean => {
+  if (!url) {
+    return false;
+  }
+
+  try {
+    const hostname = new URL(url).hostname.toLowerCase();
+
+    return allowedDomains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+  } catch (error) {
+    return false;
+  }
+};
+
 export const getStationLoginErrorData = (failure: Failure, loginOption: LoginOption) => {
   let duplicateLocationMessage = 'This value is already in use';
 

package/src/services/core/ai-docs/core-spec.md

@@ -37,13 +37,13 @@ The Core service provides the foundational infrastructure layer that all other s
 
 | Component | File | Description |
 |---|---|---|
-| `WebSocketManager` | [`WebSocketManager.ts`](../websocket/WebSocketManager.ts) | Manages the WebSocket connection lifecycle including initialization, message dispatch, and graceful shutdown. Emits `message` events for incoming data and `socketClose` when the connection drops while reconnect is allowed. |
+| `WebSocketManager` | [`WebSocketManager.ts`](../websocket/WebSocketManager.ts) | Manages the WebSocket connection lifecycle including initialization, message dispatch, and graceful shutdown. Validates the subscribe/register `webSocketUrl` against the RoutingNotifs allow-list before opening a socket. Emits `message` events for incoming data and `socketClose` when the connection drops while reconnect is allowed. |
 | `ConnectionService` | [`connection-service.ts`](../websocket/connection-service.ts) | Orchestrates reconnection logic and keepalive heartbeats on top of `WebSocketManager`. Detects connection loss/recovery and emits `connectionLost` details; ContactCenter owns any `silentRelogin()` policy. |
 | `WebexRequest` | [`WebexRequest.ts`](../WebexRequest.ts) | Singleton HTTP client that forwards service/resource/method/body options to the authenticated host request API and provides `uploadLogs` diagnostics. |
 | `AqmReqs` | [`aqm-reqs.ts`](../aqm-reqs.ts) | Factory for creating request methods that send HTTP requests and wait for correlated WebSocket notifications (success or failure). Used by routing and task services to implement their API methods. |
 | `Utils` | [`Utils.ts`](../Utils.ts) | Shared utility functions including `getErrorDetails()` for standardized error handling, `generateTaskErrorObject()` for task-specific errors, and `createErrDetailsObject()` for constructing error detail objects. |
 | `Err` | [`Err.ts`](../Err.ts) | Error class definitions. `Err.Details` carries structured error metadata (status, type, trackingId) for consistent error propagation. |
-| `constants` | [`constants.ts`](../constants.ts) | Timeout values, interval durations, participant types, interaction states, and method name constants used throughout the core layer. Any new constants for core should be defined here. |
+| `constants` | [`constants.ts`](../constants.ts) | Timeout values, interval durations, participant types, interaction states, method name constants, and the `ALLOWED_ROUTING_NOTIFS_DOMAINS` WebSocket host allow-list used throughout the core layer. Any new constants for core should be defined here. |
 
 ## Purpose / Responsibility
 Own authenticated HTTP, realtime WebSocket lifecycle, AQM request correlation, reconnect/keepalive behavior, and shared error normalization.
@@ -259,13 +259,14 @@ connectionService.on('connectionLost', (details: ConnectionLostDetails) => {
 | CORE-R-004 | ConnectionService must emit transport-state details and retry `initWebSocket({body, resource})`; ContactCenter owns relogin policy. | Separating transport detection from agent recovery prevents Core from mutating package-level session state. | `src/services/core/websocket/connection-service.ts` | `test/unit/spec/services/core/websocket/connection-service.ts` | None; source and test evidence rechecked during the 2026-07-09 remediation; independent document revalidation pending. | PRESENT |
 | CORE-R-005 | The keepalive worker must use the configured 4-second interval and 16-second close-socket timeout; AQM defaults to 20 seconds unless disabled/overridden. | Accurate timing is required for predictable recovery and request failure behavior. | `src/services/core/constants.ts` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | None; source and test evidence rechecked during the 2026-07-09 remediation; independent document revalidation pending. | PRESENT |
 | CORE-R-006 | Treat Core timeout, keepalive, and recovery constants as fixed behavior controls, not rollout flags; Core owns no feature-gate evaluation. | Conflating operational constants with rollout policy could disable transport or correlation paths unexpectedly. | `src/services/core/constants.ts`, `src/services/index.ts` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | None; rollout applicability is explicitly N/A for Core. | PRESENT |
-| CORE-R-007 | When an AQM request sets `redactSensitiveLogs`, routing-failure and timeout logs must omit the request URL, bind key, response, and raw routing payload while preserving settlement and cleanup behavior. | Dynamic request paths and routing messages can contain participant identifiers or phone numbers that must not enter diagnostic logs. | `src/services/core/aqm-reqs.ts`, `src/services/core/types.ts` | `test/unit/spec/services/core/aqm-reqs.ts` | The flag is internal and opt-in; ordinary AQM logging remains backward compatible. | PRESENT |
+| CORE-R-007 | AQM routing-failure logging never emits the raw routing message payload or error verbatim; the failure-bind path logs only a fixed redacted diagnostic regardless of `redactSensitiveLogs`. When an AQM request additionally sets `redactSensitiveLogs`, timeout logs must also omit the request URL, bind key, and response while preserving settlement and cleanup behavior. | Dynamic request paths and routing messages can contain participant identifiers or phone numbers that must not enter diagnostic logs. | `src/services/core/aqm-reqs.ts`, `src/services/core/types.ts` | `test/unit/spec/services/core/aqm-reqs.ts` | The timeout flag is internal and opt-in; ordinary AQM logging remains backward compatible while routing-failure logging is unconditionally redacted. | PRESENT |
+| CORE-R-008 | `WebSocketManager` opens a socket only for a subscribe/register `webSocketUrl` that parses as a `wss` URL whose host equals, or is a subdomain of, an entry in `ALLOWED_ROUTING_NOTIFS_DOMAINS`; a malformed, non-`wss`, or non-allow-listed URL is rejected with an error and no socket is opened. | A server-controlled subscribe response could otherwise direct the realtime connection to an untrusted or non-secure endpoint. | `src/services/core/websocket/WebSocketManager.ts`, `src/services/core/constants.ts` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | The allow-list is a fixed domain set; subdomain matching is exact suffix matching on the parsed hostname. | PRESENT |
 
 ## Design Overview
 Core separates four responsibilities:
 
 1. `WebexRequest` wraps the authenticated host request API and service-catalog routing.
-2. `WebSocketManager` registers a subscription using both `body` and `resource`, connects the socket, owns the keepalive worker, and emits raw messages/socket lifecycle events.
+2. `WebSocketManager` registers a subscription using both `body` and `resource`, validates the returned `webSocketUrl` against the `ALLOWED_ROUTING_NOTIFS_DOMAINS` allow-list before connecting the socket, owns the keepalive worker, and emits raw messages/socket lifecycle events.
 3. `AqmReqs` registers bind matchers on the primary WebSocket, sends HTTP through WebexRequest, and settles requests only from matching notifications, HTTP failure, or timeout.
 4. `ConnectionService` observes message/socket liveness, emits connection-state details, and retries socket initialization. ContactCenter listens to those details and owns optional silent relogin.
 
@@ -294,7 +295,7 @@ const setState = aqmReqs.req((p: {data: Agent.StateChange}) => ({
 await setState({data: stateChangePayload});
 ```
 
-`CLOSE_SOCKET_TIMEOUT` is 16000 ms. `CONNECTIVITY_CHECK_INTERVAL` drives reconnect attempts separately. `TIMEOUT_REQ` is the 20000 ms default AQM timeout; `WEBSOCKET_EVENT_TIMEOUT` is not the active AqmReqs default. A request configuration may set internal `redactSensitiveLogs: true`; this changes only routing-failure and timeout diagnostics, not correlation, errors, timing, or cleanup.
+`CLOSE_SOCKET_TIMEOUT` is 16000 ms. `CONNECTIVITY_CHECK_INTERVAL` drives reconnect attempts separately. `TIMEOUT_REQ` is the 20000 ms default AQM timeout; `WEBSOCKET_EVENT_TIMEOUT` is not the active AqmReqs default. Routing-failure diagnostics are always redacted to a fixed message that omits the raw payload and error. A request configuration may additionally set internal `redactSensitiveLogs: true` to redact timeout diagnostics (request URL, bind key, and response); neither redaction changes correlation, errors, timing, or cleanup.
 
 ## Data Flow
 ```mermaid
@@ -365,12 +366,17 @@ sequenceDiagram
   Caller->>WSM: initWebSocket({body, resource})
   WSM->>Host: register(body, resource)
   Host-->>WSM: WebSocket URL/subscription
-  WSM->>WS: connect()
-  alt welcome
-    WS-->>WSM: Welcome event
-    WSM-->>Caller: WelcomeResponse
-  else register/connect failure
-    WSM-->>Caller: throw error
+  WSM->>WSM: validate webSocketUrl against wss + allow-list
+  alt allow-listed wss URL
+    WSM->>WS: connect()
+    alt welcome
+      WS-->>WSM: Welcome event
+      WSM-->>Caller: WelcomeResponse
+    else connect failure
+      WSM-->>Caller: throw error
+    end
+  else malformed / non-wss / non-allow-listed URL
+    WSM-->>Caller: throw error (no socket opened)
   end
 ```
 
@@ -448,6 +454,8 @@ WebSocketManager owns socket/welcome/worker state. AqmReqs owns pending success/
 
 ## Business Rules & Invariants
 - Core must preserve its typed public/event contracts and must not invent backend states or responses. Enforced in `src/services/core/WebexRequest.ts`.
+- A subscribe/register `webSocketUrl` is trusted only when it is a `wss` URL on the `ALLOWED_ROUTING_NOTIFS_DOMAINS` allow-list; otherwise `WebSocketManager` throws and never opens a socket. Enforced in `src/services/core/websocket/WebSocketManager.ts`.
+- AQM routing-failure logs never contain the raw routing payload or error verbatim. Enforced in `src/services/core/aqm-reqs.ts`.
 - Rollout applicability is N/A for Core: keepalive, timeout, and reconnect constants control behavior, while Services constructs Core without a feature gate.
 
 ## Concurrency & Reactive Flow
@@ -468,7 +476,7 @@ stateDiagram-v2
 ```
 
 ## Protocol / Wire Format
-`WebSocketManager.initWebSocket` accepts `{body: SubscribeRequest, resource: string}`. Subscription uses the host Webex request API; AqmReqs operational HTTP uses the WebexRequest wrapper. AQM request configs carry `host`, `url`, optional `method`/`data`, `notifSuccess.bind`, optional `notifFail.bind`, optional cancel bind, and optional timeout. HTTP acknowledgement never substitutes for the matching WebSocket operation result.
+`WebSocketManager.initWebSocket` accepts `{body: SubscribeRequest, resource: string}`. Subscription uses the host Webex request API; the returned `webSocketUrl` must be a `wss` URL on the `ALLOWED_ROUTING_NOTIFS_DOMAINS` allow-list or the socket is not opened. AqmReqs operational HTTP uses the WebexRequest wrapper. AQM request configs carry `host`, `url`, optional `method`/`data`, `notifSuccess.bind`, optional `notifFail.bind`, optional cancel bind, and optional timeout. HTTP acknowledgement never substitutes for the matching WebSocket operation result.
 
 ## Error Handling & Failure Modes
 | Condition | Signal (error/code/result) | Caller recovery |
@@ -712,7 +720,8 @@ export const generateTaskErrorObject = (
 ## Pitfalls
 - `initWebSocket` requires both `body` and `resource`; omitting `resource` registers against no durable subscription endpoint.
 - AqmReqs installs notification binds before HTTP and never resolves from acknowledgement; duplicate binds, timeout, and cleanup ordering are correctness-critical.
-- Sensitive AQM configurations must use the opt-in redaction flag so dynamic URLs and raw routing messages are not included in timeout/failure logs.
+- AQM routing-failure logs are always redacted; sensitive AQM configurations must also use the opt-in `redactSensitiveLogs` flag so dynamic URLs and responses are not included in timeout logs.
+- Do not open the WebSocket directly from a subscribe/register response; the `webSocketUrl` must first pass `wss` scheme and allow-listed host validation.
 - Keepalive closure (16 seconds), lost-connection detection (8 seconds), reconnect interval (5 seconds), and recovery timeout (50 seconds) are separate controls and must not be conflated.
 
 ## Module Do's / Don'ts
@@ -751,6 +760,7 @@ Unit tests mirror module paths under `test/unit/spec/services/core`. Preserve po
 | `CORE-R-005` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | Keep timer-value assertions synchronized with constants. |
 | `CORE-R-006` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | Feature-gate absence is verified from construction/source rather than a dedicated negative test. |
 | `CORE-R-007` | `test/unit/spec/services/core/aqm-reqs.ts` | None. |
+| `CORE-R-008` | `test/unit/spec/services/core/websocket/WebSocketManager.ts` | None. |
 
 ## Traceability
 - Repo architecture: `../../../../ai-docs/ARCHITECTURE.md` · Registry: `../../../../ai-docs/SPEC_INDEX.md`

package/src/services/core/aqm-reqs.ts

@@ -119,21 +119,12 @@ export default class AqmReqs {
             if ('errId' in notifFail) {
               const error = new Err.Details(notifFail.errId, msg as any);
 
-              if (c.redactSensitiveLogs) {
-                LoggerProxy.log('Routing request failed (sensitive details redacted)', {
-                  module: AQM_REQS_FILE,
-                  method: METHODS.CREATE_PROMISE,
-                });
-              } else {
-                LoggerProxy.log(`Routing request failed: ${JSON.stringify(msg)}`, {
-                  module: AQM_REQS_FILE,
-                  method: METHODS.CREATE_PROMISE,
-                });
-                LoggerProxy.log(`Routing request failed: ${error}`, {
-                  module: AQM_REQS_FILE,
-                  method: METHODS.CREATE_PROMISE,
-                });
-              }
+              // The raw routing-failure payload/error is never logged verbatim; only a
+              // redacted, non-sensitive diagnostic is emitted regardless of redactSensitiveLogs.
+              LoggerProxy.log('Routing request failed (sensitive details redacted)', {
+                module: AQM_REQS_FILE,
+                method: METHODS.CREATE_PROMISE,
+              });
               reject(error);
             } else {
               reject(notifFail.err(msg as any));

package/src/services/core/constants.ts

@@ -80,6 +80,14 @@ export const PARTICIPANT_TYPES = {
 /** Interaction state for consultation */
 export const STATE_CONSULT = 'consult';
 
+/**
+ * Trusted domains for the RoutingNotifs WebSocket connection. A `webSocketUrl` returned by the
+ * subscribe/register API is only opened when its hostname matches one of these domains exactly
+ * or is a subdomain of one of them.
+ * @ignore
+ */
+export const ALLOWED_ROUTING_NOTIFS_DOMAINS = ['cisco.com', 'ciscoccservice.com'];
+
 // Method names for core services
 export const METHODS = {
   // WebexRequest methods

package/src/services/core/websocket/WebSocketManager.ts

@@ -5,8 +5,14 @@ import {ConnectionLostDetails} from './types';
 import {CC_EVENTS, SubscribeResponse, WelcomeResponse} from '../../config/types';
 import LoggerProxy from '../../../logger-proxy';
 import workerScript from './keepalive.worker';
-import {KEEPALIVE_WORKER_INTERVAL, CLOSE_SOCKET_TIMEOUT, METHODS} from '../constants';
+import {
+  KEEPALIVE_WORKER_INTERVAL,
+  CLOSE_SOCKET_TIMEOUT,
+  METHODS,
+  ALLOWED_ROUTING_NOTIFS_DOMAINS,
+} from '../constants';
 import {WEB_SOCKET_MANAGER_FILE} from '../../../constants';
+import {isAllowedUrlHost} from '../Utils';
 
 /**
  * WebSocketManager handles the WebSocket connection for Contact Center operations.
@@ -107,7 +113,25 @@ export class WebSocketManager extends EventEmitter {
         body: connectionConfig,
         headers: isIntEnv && orgId ? {'X-ORGANIZATION-ID': orgId} : undefined,
       });
-      this.url = subscribeResponse.body.webSocketUrl;
+      const {webSocketUrl} = subscribeResponse.body;
+
+      // Only a `wss` URL whose hostname is, or is a subdomain of, one of the allow-listed
+      // RoutingNotifs domains is considered trusted.
+      let isWssUrl = false;
+
+      try {
+        isWssUrl = !!webSocketUrl && new URL(webSocketUrl).protocol === 'wss:';
+      } catch (error) {
+        isWssUrl = false;
+      }
+
+      if (!isWssUrl || !isAllowedUrlHost(webSocketUrl, ALLOWED_ROUTING_NOTIFS_DOMAINS)) {
+        throw new Error(
+          'Rejected webSocketUrl from RoutingNotifs registration: scheme or host not allow-listed'
+        );
+      }
+
+      this.url = webSocketUrl;
     } catch (e) {
       LoggerProxy.error(
         `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`,

package/test/unit/spec/cc.ts

@@ -4868,6 +4868,27 @@ describe('webex.cc', () => {
       });
     });
 
+    it('does not emit an unknown server-controlled event type', () => {
+      const payload = {
+        type: 'UnhandledMessage',
+        data: {foo: 'bar', type: 'MaliciousInjectedType'},
+      };
+
+      messageCallback(JSON.stringify(payload));
+
+      expect(emitSpy).not.toHaveBeenCalledWith('MaliciousInjectedType', expect.anything());
+    });
+
+    it('emits a known agent event type verbatim from data.type', () => {
+      const sample = {foo: 'bar', type: CC_EVENTS.AGENT_STATE_CHANGE_SUCCESS};
+
+      messageCallback(
+        JSON.stringify({type: CC_EVENTS.AGENT_STATE_CHANGE_SUCCESS, data: sample})
+      );
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.AGENT_STATE_CHANGE_SUCCESS, sample);
+    });
+
     it('should call webCallingService.setLoginOption with correct deviceType on AGENT_STATION_LOGIN_SUCCESS', () => {
       const setLoginOptionSpy = jest.spyOn(webex.cc.webCallingService, 'setLoginOption');
       const deviceType = LoginOption.EXTENSION;

package/test/unit/spec/services/ApiAiAssistant.ts

@@ -219,6 +219,19 @@ describe('ApiAIAssistant', () => {
     expect(result).toEqual(responseBody as any);
   });
 
+  it('rejects an invalid agentId/interactionId and does not call webex.request', async () => {
+    apiAIAssistant.setAIFeatureFlags({realtimeTranscripts: {enable: true}} as any);
+
+    await expect(
+      apiAIAssistant.fetchHistoricTranscripts('', 'interaction-1')
+    ).rejects.toBeDefined();
+    await expect(
+      apiAIAssistant.fetchHistoricTranscripts('test-agent-id', 'bad id!')
+    ).rejects.toBeDefined();
+
+    expect(mockWebex.request).not.toHaveBeenCalled();
+  });
+
   it('should request real-time assistance without extra context using sendEvent', async () => {
     const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
     apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);

package/test/unit/spec/services/WebCallingService.ts

@@ -198,6 +198,44 @@ describe('WebCallingService', () => {
 
     });
 
+    it('should fall back to default domain for a non-allow-listed catalog RTMS host', async () => {
+      webex.internal.services.get.mockReturnValue('wss://evil.attacker.com');
+
+      line = callingClient.getLines().line1 as ILine;
+      const deviceInfo = {
+        mobiusDeviceId: 'device123',
+        status: 'registered',
+        setError: jest.fn(),
+        getError: jest.fn(),
+        type: 'line',
+        id: 'line1',
+      };
+
+      const registeredHandler = jest.fn();
+      const lineOnSpy = jest.spyOn(line, 'on').mockImplementation((event, handler) => {
+        if (event === LINE_EVENTS.REGISTERED) {
+          registeredHandler.mockImplementation(handler);
+          handler(deviceInfo);
+        }
+      });
+      await expect(webRTCCalling.registerWebCallingLine()).resolves.toBeUndefined();
+      expect(createClient).toHaveBeenCalledWith(webex, {
+        logger: {
+          level: 'info',
+        },
+        serviceData: {
+          indicator: 'contactcenter',
+          domain: 'rtw.prod-us1.rtmsprod.net',
+        },
+      });
+      expect(lineOnSpy).toHaveBeenCalledWith(LINE_EVENTS.REGISTERED, expect.any(Function));
+      expect(line.register).toHaveBeenCalled();
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        'Non-allow-listed RTMS host from u2c catalogue: evil.attacker.com so falling back to default domain',
+        {module: WEB_CALLING_SERVICE_FILE, method: 'getRTMSDomain'}
+      );
+    });
+
     it('should reject if registration times out', async () => {
       line = callingClient.getLines().line1 as ILine;
       jest.spyOn(global, 'setTimeout').mockImplementation(((handler: TimerHandler) => {

package/test/unit/spec/services/core/Utils.ts

@@ -1036,4 +1036,26 @@ describe('Utils', () => {
     });
   });
 
+  describe('isAllowedUrlHost', () => {
+    it('returns true when the hostname exactly matches an allowed domain', () => {
+      expect(Utils.isAllowedUrlHost('wss://cisco.com', ['cisco.com'])).toBe(true);
+    });
+
+    it('returns true when the hostname is a subdomain of an allowed domain', () => {
+      expect(Utils.isAllowedUrlHost('wss://notifs.wxcc-us1.cisco.com', ['cisco.com'])).toBe(true);
+    });
+
+    it('returns false when the hostname is not in the allowed domains list', () => {
+      expect(Utils.isAllowedUrlHost('wss://evil.attacker.com', ['cisco.com'])).toBe(false);
+    });
+
+    it('returns false for an unparsable url', () => {
+      expect(Utils.isAllowedUrlHost('not-a-url', ['cisco.com'])).toBe(false);
+    });
+
+    it('returns false for a null/undefined url', () => {
+      expect(Utils.isAllowedUrlHost(null as any, ['cisco.com'])).toBe(false);
+      expect(Utils.isAllowedUrlHost(undefined as any, ['cisco.com'])).toBe(false);
+    });
+  });
 });

package/test/unit/spec/services/core/aqm-reqs.ts

@@ -610,6 +610,35 @@ describe('AqmReqs', () => {
       expect(aqm['pendingRequests']).toEqual({});
     });
 
+    it('never logs the raw routing-failure payload even when redactSensitiveLogs is not set', async () => {
+      const participantId = '+1/plain-failure-secret';
+      webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+      const conf = {
+        ...participantDropConfig(participantId, 'disabled'),
+        redactSensitiveLogs: false,
+      };
+      const promise = aqm['createPromise'](conf);
+
+      webSocketManagerInstance.emit(
+        'message',
+        JSON.stringify({
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed', participantId},
+        })
+      );
+
+      await expect(promise).rejects.toBeDefined();
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Routing request failed (sensitive details redacted)',
+        expect.objectContaining({module: AQM_REQS_FILE})
+      );
+
+      const loggedCalls = JSON.stringify((LoggerProxy.log as jest.Mock).mock.calls);
+      expect(loggedCalls).not.toContain(participantId);
+      expect(loggedCalls).not.toContain('ParticipantDropConferenceFailed');
+      expect(aqm['pendingRequests']).toEqual({});
+    });
+
     it('resolves a correlated participant-left event and clears its binds', async () => {
       jest.useFakeTimers();
       (global.window as any).setTimeout = global.setTimeout;