@openfin/cloud-interop-core-api 0.0.1-alpha.39beb33 → 0.0.1-alpha.3cbe14e

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
+var axios = require('axios');
 var mqtt = require('mqtt');
-var sharedUtils = require('@openfin/shared-utils');
 
 class CloudInteropAPIError extends Error {
     code;
@@ -17,295 +17,6 @@ class AuthorizationError extends CloudInteropAPIError {
     }
 }
 
-class EventController {
-    #eventListeners = new Map();
-    addEventListener(type, callback) {
-        const listeners = this.#eventListeners.get(type) || [];
-        listeners.push(callback);
-        this.#eventListeners.set(type, listeners);
-    }
-    removeEventListener(type, callback) {
-        const listeners = this.#eventListeners.get(type) || [];
-        const index = listeners.indexOf(callback);
-        if (index !== -1) {
-            listeners.splice(index, 1);
-        }
-        this.#eventListeners.set(type, listeners);
-    }
-    once(type, callback) {
-        const listener = (...args) => {
-            this.removeEventListener(type, listener);
-            // @ts-expect-error - TS doesn't like the spread operator here
-            callback(...args);
-        };
-        this.addEventListener(type, listener);
-    }
-    emitEvent(type, ...args) {
-        const listeners = this.#eventListeners.get(type) || [];
-        listeners.forEach((listener) => listener(...args));
-    }
-}
-
-const APP_ID_DELIM = '::';
-const getRequestHeaders = (connectionParameters) => {
-    const headers = {};
-    headers['Content-Type'] = 'application/json';
-    if (connectionParameters.authenticationType === 'jwt' && connectionParameters.jwtAuthenticationParameters) {
-        const tokenResult = connectionParameters.jwtAuthenticationParameters.jwtRequestCallback();
-        if (!tokenResult) {
-            throw new Error('jwtRequestCallback must return a token');
-        }
-        headers['x-of-auth-id'] = connectionParameters.jwtAuthenticationParameters.authenticationId;
-        headers['Authorization'] =
-            typeof tokenResult === 'string' ? `Bearer ${tokenResult}` : `Bearer ${Buffer.from(JSON.stringify(tokenResult)).toString('base64')}`;
-    }
-    if (connectionParameters.authenticationType === 'basic' && connectionParameters.basicAuthenticationParameters) {
-        const { username, password } = connectionParameters.basicAuthenticationParameters;
-        headers['Authorization'] = `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
-    }
-    return headers;
-};
-/**
- * Encodes all app intents in the format: `appId::sourceId::sessionId`,
- * where sourceId and sessionId are URI encoded
- * @param appIntents
- * @param source
- * @returns
- */
-const encodeAppIntents = (appIntents, { sessionId, sourceId }) => appIntents.map((intent) => ({
-    ...intent,
-    apps: intent.apps.map((app) => {
-        const id = encodeURIComponent(app.appId);
-        const sId = encodeURIComponent(sourceId);
-        return { ...app, appId: `${id}${APP_ID_DELIM}${sId}${APP_ID_DELIM}${sessionId}` };
-    }),
-}));
-/**
- * Decodes all app intents by URI decoding the parts previously encoded by `encodeAppIntents`
- * @param appIntents
- * @returns
- */
-const decodeAppIntents = (appIntents) => appIntents.map((intent) => ({
-    ...intent,
-    apps: intent.apps.map((app) => {
-        const [encodedAppId, encodedSourceId, sessionId] = app.appId.split(APP_ID_DELIM);
-        const id = decodeURIComponent(encodedAppId);
-        const sourceId = decodeURIComponent(encodedSourceId);
-        return { ...app, appId: `${id}${APP_ID_DELIM}${sourceId}${APP_ID_DELIM}${sessionId}` };
-    }),
-}));
-/**
- * Decodes the app id to extract the sessionId, returns '' if not able to parse
- * @param app
- * @returns
- */
-const parseSessionId = (appId) => (typeof appId === 'string' ? appId : appId.appId).split(APP_ID_DELIM)?.[2]?.trim() ?? '';
-const getSourceFromSession = (sessionDetails) => ({
-    sessionId: sessionDetails.sessionId,
-    sourceId: sessionDetails.sourceId,
-    userId: sessionDetails.sub,
-    orgId: sessionDetails.orgId,
-    platformId: sessionDetails.platformId,
-});
-
-const MIN_TIMEOUT = 500;
-const DEFAULT_TIMEOUT = 3000;
-const newDiscovery = () => ({
-    id: undefined,
-    pendingIntentDetailsEvents: [],
-    sessionCount: 0,
-    responseCount: 0,
-    state: 'not-started',
-});
-class IntentController {
-    #url;
-    #mqttClient;
-    #sessionDetails;
-    #connectionParams;
-    #events;
-    #logger;
-    #discovery = newDiscovery();
-    #discoveryTimeout;
-    constructor(url, mqttClient, sessionDetails, connectionParameters, events, logger) {
-        this.#url = url;
-        this.#mqttClient = mqttClient;
-        this.#sessionDetails = sessionDetails;
-        this.#connectionParams = connectionParameters;
-        this.#events = events;
-        this.#logger = logger;
-    }
-    async startIntentDiscovery(options) {
-        if (this.#discovery.state === 'in-progress') {
-            throw new Error('Intent discovery already in progress');
-        }
-        const { timeout = DEFAULT_TIMEOUT, findOptions } = options;
-        // clamp min value to 500ms
-        const clampedTimeout = Math.max(timeout, MIN_TIMEOUT);
-        try {
-            const startResponse = await fetch(`${this.#url}/api/intents/${this.#sessionDetails.sessionId}`, {
-                method: 'POST',
-                headers: getRequestHeaders(this.#connectionParams),
-                body: JSON.stringify({ findOptions }),
-            });
-            if (!startResponse.ok) {
-                throw new Error(startResponse.statusText);
-            }
-            // TODO: type this response?
-            const json = await startResponse.json();
-            this.#discovery.id = json.discoveryId;
-            this.#discovery.sessionCount = json.sessionCount;
-            this.#discovery.state = 'in-progress';
-            // Listen out for discovery results directly sent to us
-            await this.#mqttClient.subscribeAsync(`${this.#sessionDetails.sessionRootTopic}/commands/${this.#discovery.id}`);
-            this.#discoveryTimeout = setTimeout(() => this.#endIntentDiscovery(), clampedTimeout);
-        }
-        catch (error) {
-            // Clean up any ongoing discoveries
-            this.#endIntentDiscovery();
-            throw new CloudInteropAPIError('Error starting intent discovery', 'ERR_STARTING_INTENT_DISCOVERY', error);
-        }
-    }
-    async #endIntentDiscovery() {
-        if (this.#discovery.state !== 'in-progress') {
-            // TODO: remove debug logs
-            this.#logger('debug', 'Intent discovery not in progress');
-            return;
-        }
-        if (this.#discoveryTimeout) {
-            clearTimeout(this.#discoveryTimeout);
-            this.#discoveryTimeout = undefined;
-        }
-        this.#discovery.state = 'ended';
-        // emit our aggregated events
-        this.#events.emitEvent('aggregate-intent-details', { responses: this.#discovery.pendingIntentDetailsEvents });
-        // gracefully end discovery
-        await this.#mqttClient.unsubscribeAsync(`${this.#sessionDetails.sessionRootTopic}/commands/${this.#discovery.id}`).catch(() => {
-            this.#logger('warn', `Error ending intent discovery: could not unsubscribe from discovery id ${this.#discovery.id}`);
-        });
-        await fetch(`${this.#url}/api/intents/${this.#sessionDetails.sessionId}/${this.#discovery.id}`, {
-            method: 'DELETE',
-            headers: getRequestHeaders(this.#connectionParams),
-        })
-            .then((deleteResponse) => {
-            if (!deleteResponse.ok) {
-                throw new Error(`Error ending intent discovery: ${deleteResponse.statusText}`);
-            }
-            this.#logger('debug', 'Intent discovery ended');
-        })
-            .catch((error) => {
-            this.#logger('warn', `Error ending intent discovery: ${error}`);
-        });
-        // clean up
-        this.#discovery = newDiscovery();
-    }
-    async raiseIntent({ raiseOptions, appId }) {
-        const targetSessionId = parseSessionId(appId);
-        if (!targetSessionId) {
-            // TODO: should we add more info here about the format?
-            throw new CloudInteropAPIError(`Invalid AppId specified, must be encoded as a cloud-session app id`, 'ERR_INVALID_TARGET_SESSION_ID');
-        }
-        const postResponse = await fetch(`${this.#url}/api/intents/${this.#sessionDetails.sessionId}/sessions/${targetSessionId}`, {
-            method: 'POST',
-            headers: getRequestHeaders(this.#connectionParams),
-            body: JSON.stringify({ raiseOptions }),
-        });
-        if (!postResponse.ok) {
-            // TODO: maybe add a debug flag to print these when dev'ing?
-            // console.log(`Error raising intent: ${await postResponse.text()}`);
-            throw new CloudInteropAPIError(`Error raising intent`, 'ERR_RAISING_INTENT', new Error(postResponse.statusText));
-        }
-    }
-    async reportAppIntents(discoveryId, intents) {
-        intents = encodeAppIntents(intents, getSourceFromSession(this.#sessionDetails));
-        try {
-            const reportResponse = await fetch(`${this.#url}/api/intents/${this.#sessionDetails.sessionId}/${discoveryId}`, {
-                method: 'POST',
-                headers: getRequestHeaders(this.#connectionParams),
-                body: JSON.stringify({ intents }),
-            });
-            if (reportResponse.ok) {
-                return true;
-            }
-            throw new CloudInteropAPIError('Error reporting intents', 'ERR_REPORTING_INTENTS', new Error(reportResponse.statusText));
-        }
-        catch (error) {
-            this.#logger('warn', `Error reporting intents for discovery ID ${discoveryId}: ${error}`);
-        }
-        return false;
-    }
-    async sendIntentResult(initiatingSessionId, result) {
-        const { sessionId } = getSourceFromSession(this.#sessionDetails);
-        const resultResponse = await fetch(`${this.#url}/api/intents/${initiatingSessionId}/result/${sessionId}`, {
-            method: 'POST',
-            headers: getRequestHeaders(this.#connectionParams),
-            body: JSON.stringify({ result }),
-        });
-        if (!resultResponse.ok) {
-            throw new CloudInteropAPIError('Error sending intent result', 'ERR_SENDING_INTENT_RESULT', new Error(resultResponse.statusText));
-        }
-    }
-    handleCommandMessage(message) {
-        switch (message.command) {
-            case 'report-intents': {
-                if (message.initiatingSessionId === this.#sessionDetails?.sessionId) {
-                    // Ignore if this originated from us
-                    return;
-                }
-                const { command: _, ...event } = message;
-                this.#events.emitEvent('report-intents', event);
-                break;
-            }
-            case 'intent-details': {
-                /**
-                 * We aggregate intent details commands from all connected sessions on the server side
-                 * to ensure upstream clients don't have to do this. Also given @openfin/cloud-interop
-                 * exposes FDC3 compliant APIs, there is no concept of streaming available, hence we
-                 * aggregate the responses here and send them in a synchronous manner.
-                 */
-                const { command: _, ...event } = message;
-                // Decode intents before emitting to client
-                event.intents = decodeAppIntents(event.intents);
-                // always emit individual intent-details events in addition to aggregate-intent-details
-                // for flexibility after intent discovery has ended, this can be useful for late-joining
-                // clients nearing the timeout
-                this.#events.emitEvent('intent-details', event);
-                if (message.discoveryId !== this.#discovery.id || this.#discovery.state !== 'in-progress') {
-                    // Ignore if its any other discovery id for some reason, or
-                    // if we're not in the middle of a discovery
-                    return;
-                }
-                this.#discovery.responseCount += 1;
-                this.#logger('debug', `Received intent details from ${message.source.sessionId}, received: ${this.#discovery.responseCount}, out of connected sessions: ${this.#discovery.sessionCount - 1}`);
-                this.#discovery.pendingIntentDetailsEvents.push(event);
-                const allResponded = this.#discovery.responseCount === this.#discovery.sessionCount - 1;
-                if (allResponded) {
-                    this.#endIntentDiscovery();
-                }
-                break;
-            }
-            case 'raise-intent': {
-                if (message.targetSessionId === this.#sessionDetails?.sessionId) {
-                    const { command: _, ...event } = message;
-                    this.#events.emitEvent('raise-intent', event);
-                }
-                break;
-            }
-            case 'intent-result': {
-                if (message.initiatingSessionId === this.#sessionDetails?.sessionId) {
-                    // Return result to originator and end discovery
-                    const { command: _, ...resultEvent } = message;
-                    this.#events.emitEvent('intent-result', resultEvent);
-                }
-                break;
-            }
-            default: {
-                this.#logger('warn', `Unknown command message received:\n${JSON.stringify(message, null, 2)}`);
-                break;
-            }
-        }
-    }
-}
-
 // Error codes as defined in https://docs.emqx.com/en/cloud/latest/connect_to_deployments/mqtt_client_error_codes.html
 const BadUserNamePasswordError = 134;
 /**
@@ -326,9 +37,8 @@ class CloudInteropAPI {
     };
     #reconnectRetries = 0;
     #connectionParams;
+    #eventListeners = new Map();
     #attemptingToReconnect = false;
-    #events = new EventController();
-    #intents;
     constructor(cloudInteropSettings) {
         this.#cloudInteropSettings = cloudInteropSettings;
     }
@@ -354,102 +64,105 @@ class CloudInteropAPI {
         this.#keepAliveIntervalSeconds = parameters.keepAliveIntervalSeconds || this.#keepAliveIntervalSeconds;
         this.#logger = parameters.logger || this.#logger;
         const { sourceId, platformId } = this.#connectionParams;
-        const createSessionResponse = await fetch(`${this.#cloudInteropSettings.url}/api/sessions`, {
-            method: 'POST',
-            headers: getRequestHeaders(this.#connectionParams),
-            body: JSON.stringify({ sourceId: sourceId.trim(), platformId }),
-        });
-        if (!createSessionResponse.ok) {
-            if (createSessionResponse.status === 401 || createSessionResponse.status === 403) {
-                throw new AuthorizationError();
-            }
-            throw new CloudInteropAPIError();
-        }
-        if (createSessionResponse.status !== 201) {
-            throw new CloudInteropAPIError(`Failed to connect to the Cloud Interop service: ${this.#cloudInteropSettings.url}`, 'ERR_CONNECT', new Error(createSessionResponse.statusText));
-        }
-        this.#sessionDetails = (await createSessionResponse.json());
-        const sessionRootTopic = this.#sessionDetails.sessionRootTopic;
-        const clientOptions = {
-            keepalive: this.#keepAliveIntervalSeconds,
-            clientId: this.#sessionDetails.sessionId,
-            clean: true,
-            protocolVersion: 5,
-            // The "will" message will be published on an unexpected disconnection
-            // The server can then tidy up.  So it needs every for this client to do that, the session details is perfect
-            will: {
-                topic: 'interop/lastwill',
-                payload: Buffer.from(JSON.stringify(this.#sessionDetails)),
-                qos: 0,
-                retain: false,
-            },
-            username: this.#sessionDetails.token,
-        };
-        this.#mqttClient = await mqtt.connectAsync(this.#sessionDetails.url, clientOptions);
-        // TODO: Dynamic intent discovery
-        // search for any ongoing discoveries in DB and fire report-intents on self
-        this.#logger('log', `Cloud Interop successfully connected to ${this.#cloudInteropSettings.url}`);
-        this.#mqttClient.on('error', async (error) => {
-            // We will receive errors for each failed reconnection attempt
-            // We don't want to disconnect on these else we will never reconnect
-            if (!this.#attemptingToReconnect) {
-                await this.#disconnect(false);
+        try {
+            const createSessionResponse = await axios.post(`${this.#cloudInteropSettings.url}/api/sessions`, {
+                sourceId,
+                platformId,
+            }, {
+                headers: this.#getRequestHeaders(),
+            });
+            if (createSessionResponse.status !== 201) {
+                throw new CloudInteropAPIError(`Failed to connect to the Cloud Interop service: ${this.#cloudInteropSettings.url}`, 'ERR_CONNECT', createSessionResponse.status);
             }
-            if (error instanceof mqtt.ErrorWithReasonCode) {
-                switch (error.code) {
-                    case BadUserNamePasswordError: {
-                        await this.#disconnect(false);
-                        this.#logger('warn', `Session expired`);
-                        this.#events.emitEvent('session-expired');
-                        return;
-                    }
-                    default: {
-                        this.#logger('error', `Unknown Infrastructure Error Code ${error.code} : ${error.message}${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}`);
-                        // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
-                        if (!this.#attemptingToReconnect) {
-                            this.#events.emitEvent('error', new CloudInteropAPIError(`Unknown Infrastructure Error Code ${error.code} : ${error.message}`, 'ERR_INFRASTRUCTURE', error));
-                            break;
+            this.#sessionDetails = createSessionResponse.data;
+            const sessionRootTopic = this.#sessionDetails.sessionRootTopic;
+            const clientOptions = {
+                keepalive: this.#keepAliveIntervalSeconds,
+                clientId: this.#sessionDetails.sessionId,
+                clean: true,
+                protocolVersion: 5,
+                // The "will" message will be published on an unexpected disconnection
+                // The server can then tidy up.  So it needs every for this client to do that, the session details is perfect
+                will: {
+                    topic: 'interop/lastwill',
+                    payload: Buffer.from(JSON.stringify(this.#sessionDetails)),
+                    qos: 0,
+                    retain: false,
+                },
+                username: this.#sessionDetails.token,
+            };
+            this.#mqttClient = await mqtt.connectAsync(this.#sessionDetails.url, clientOptions);
+            this.#logger('log', `Cloud Interop successfully connected to ${this.#cloudInteropSettings.url}`);
+            this.#mqttClient.on('error', async (error) => {
+                // We will receive errors for each failed reconnection attempt
+                // We don't won't to disconnect on these else we will never reconnect
+                if (!this.#attemptingToReconnect) {
+                    await this.#disconnect(false);
+                }
+                if (error instanceof mqtt.ErrorWithReasonCode) {
+                    switch (error.code) {
+                        case BadUserNamePasswordError: {
+                            await this.#disconnect(false);
+                            this.#logger('warn', `Session expired`);
+                            this.#emitEvent('session-expired');
+                            return;
+                        }
+                        default: {
+                            this.#logger('error', `Unknown Infrastructure Error Code ${error.code} : ${error.message}${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}`);
+                            // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
+                            if (!this.#attemptingToReconnect) {
+                                this.#emitEvent('error', new CloudInteropAPIError(`Unknown Infrastructure Error Code ${error.code} : ${error.message}`, 'ERR_INFRASTRUCTURE', error));
+                                break;
+                            }
                         }
                     }
                 }
-            }
-            else {
-                this.#logger('error', `Unknown Error${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}: ${error}`);
-                // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
-                if (!this.#attemptingToReconnect) {
-                    this.#events.emitEvent('error', new CloudInteropAPIError(`Unknown Error`, 'ERR_UNKNOWN', error));
+                else {
+                    this.#logger('error', `Unknown Error${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}: ${error}`);
+                    // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
+                    if (!this.#attemptingToReconnect) {
+                        this.#emitEvent('error', new CloudInteropAPIError(`Unknown Error`, 'ERR_UNKNOWN', error));
+                    }
                 }
+            });
+            this.#mqttClient.on('reconnect', () => {
+                this.#attemptingToReconnect = true;
+                this.#reconnectRetries += 1;
+                this.#logger('debug', `Cloud Interop attempting reconnection - ${this.#reconnectRetries}...`);
+                if (this.#reconnectRetries === this.#reconnectRetryLimit) {
+                    this.#logger('warn', `Cloud Interop reached max reconnection attempts - ${this.#reconnectRetryLimit}...`);
+                    this.#disconnect(true);
+                }
+                this.#emitEvent('reconnecting', this.#reconnectRetries);
+            });
+            // Does not fire on initial connection, only successful reconnection attempts
+            this.#mqttClient.on('connect', () => {
+                this.#logger('debug', `Cloud Interop successfully reconnected after ${this.#reconnectRetries} attempts`);
+                this.#reconnectRetries = 0;
+                this.#attemptingToReconnect = false;
+                this.#emitEvent('reconnected');
+            });
+            this.#mqttClient.on('message', (topic, message) => {
+                if (!this.#sessionDetails) {
+                    this.#logger('warn', 'Received message when session not connected');
+                    return;
+                }
+                this.#handleCommand(topic, message, this.#sessionDetails);
+            });
+            // Subscribe to all context groups
+            this.#mqttClient.subscribe(`${sessionRootTopic}/context-groups/#`);
+            // Listen out for global commands
+            this.#mqttClient.subscribe(`${sessionRootTopic}/commands`);
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                if (error.response?.status === 401 || error.response?.status === 403) {
+                    throw new AuthorizationError();
+                }
+                throw new CloudInteropAPIError();
             }
-        });
-        this.#mqttClient.on('reconnect', () => {
-            this.#attemptingToReconnect = true;
-            this.#reconnectRetries += 1;
-            this.#logger('debug', `Cloud Interop attempting reconnection - ${this.#reconnectRetries}...`);
-            if (this.#reconnectRetries === this.#reconnectRetryLimit) {
-                this.#logger('warn', `Cloud Interop reached max reconnection attempts - ${this.#reconnectRetryLimit}...`);
-                this.#disconnect(true);
-            }
-            this.#events.emitEvent('reconnecting', this.#reconnectRetries);
-        });
-        // Does not fire on initial connection, only successful reconnection attempts
-        this.#mqttClient.on('connect', () => {
-            this.#logger('debug', `Cloud Interop successfully reconnected after ${this.#reconnectRetries} attempts`);
-            this.#reconnectRetries = 0;
-            this.#attemptingToReconnect = false;
-            this.#events.emitEvent('reconnected');
-        });
-        this.#mqttClient.on('message', (topic, message) => {
-            if (!this.#sessionDetails) {
-                this.#logger('warn', 'Received message when session not connected');
-                return;
-            }
-            this.#handleMessage(topic, message, this.#sessionDetails);
-        });
-        // Subscribe to all context groups
-        this.#mqttClient.subscribe(`${sessionRootTopic}/context-groups/#`);
-        // Listen out for global commands
-        this.#mqttClient.subscribe(`${sessionRootTopic}/commands`);
-        this.#initControllers(this.#mqttClient, this.#sessionDetails, this.#connectionParams);
+            throw error;
+        }
     }
     /**
      * Disconnects from the Cloud Interop service
@@ -470,79 +183,46 @@ class CloudInteropAPI {
      * @memberof CloudInteropAPI
      */
     async setContext(contextGroup, context) {
-        // TODO: make context of type OpenFin.Context
         if (!this.#sessionDetails || !this.#connectionParams) {
             throw new Error('Session not connected');
         }
-        if (!this.#mqttClient) {
-            throw new Error('MQTT client not connected');
-        }
         const payload = {
             context,
             timestamp: Date.now(),
         };
-        const postResponse = await fetch(`${this.#cloudInteropSettings.url}/api/context-groups/${this.#sessionDetails.sessionId}/${contextGroup}`, {
-            method: 'POST',
-            headers: getRequestHeaders(this.#connectionParams),
-            body: JSON.stringify(payload),
+        await axios.post(`${this.#cloudInteropSettings.url}/api/context-groups/${this.#sessionDetails.sessionId}/${contextGroup}`, payload, {
+            headers: this.#getRequestHeaders(),
         });
-        if (!postResponse.ok) {
-            throw new CloudInteropAPIError(`Error setting context for ${contextGroup}`, 'ERR_SETTING_CONTEXT', new Error(postResponse.statusText));
-        }
-    }
-    /**
-     * Starts an intent discovery operation
-     *
-     * @return {*}  {Promise<void>}
-     * @memberof CloudInteropAPI
-     * @throws {CloudInteropAPIError} - If an error occurs during intent discovery
-     */
-    async startIntentDiscovery(options) {
-        this.#throwIfNotConnected();
-        return this.#intents?.startIntentDiscovery(options);
-    }
-    async raiseIntent(options) {
-        this.#throwIfNotConnected();
-        return this.#intents?.raiseIntent(options);
-    }
-    async reportAppIntents(discoveryId, intents) {
-        this.#throwIfNotConnected();
-        return this.#intents?.reportAppIntents(discoveryId, intents) ?? false;
-    }
-    async sendIntentResult(initiatingSessionId, result) {
-        this.#throwIfNotConnected();
-        return this.#intents?.sendIntentResult(initiatingSessionId, result);
-    }
-    parseSessionId(appId) {
-        return parseSessionId(appId);
     }
     addEventListener(type, callback) {
-        this.#events.addEventListener(type, callback);
+        const listeners = this.#eventListeners.get(type) || [];
+        listeners.push(callback);
+        this.#eventListeners.set(type, listeners);
     }
     removeEventListener(type, callback) {
-        this.#events.removeEventListener(type, callback);
-    }
-    once(type, callback) {
-        this.#events.once(type, callback);
+        const listeners = this.#eventListeners.get(type) || [];
+        const index = listeners.indexOf(callback);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+        this.#eventListeners.set(type, listeners);
     }
     async #disconnect(fireDisconnectedEvent) {
-        if (!this.#sessionDetails || !this.#connectionParams) {
+        if (!this.#sessionDetails) {
             return;
         }
         try {
-            const disconnectResponse = await fetch(`${this.#cloudInteropSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
-                method: 'DELETE',
-                headers: getRequestHeaders(this.#connectionParams),
+            const disconnectResponse = await axios.delete(`${this.#cloudInteropSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
+                headers: this.#getRequestHeaders(),
             });
             if (disconnectResponse.status !== 200) {
-                throw new CloudInteropAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', new Error(disconnectResponse.statusText));
+                throw new CloudInteropAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', disconnectResponse.status);
             }
         }
-        catch (error) {
-            throw new CloudInteropAPIError('Error during disconnection', 'ERR_DISCONNECT', error);
+        catch {
+            throw new CloudInteropAPIError('Error during disconnection', 'ERR_DISCONNECT');
         }
         finally {
-            this.#destroyControllers();
             this.#mqttClient?.removeAllListeners();
             await this.#mqttClient?.endAsync(true);
             this.#sessionDetails = undefined;
@@ -550,42 +230,27 @@ class CloudInteropAPI {
             this.#reconnectRetries = 0;
             this.#attemptingToReconnect = false;
             if (fireDisconnectedEvent) {
-                this.#events.emitEvent('disconnected');
+                this.#emitEvent('disconnected');
             }
         }
     }
-    #handleMessage(topic, message, sessionDetails) {
+    #handleCommand(topic, message, sessionDetails) {
         if (message.length === 0 || !sessionDetails) {
             // Ignore clean up messages
             return;
         }
         const messageEnvelope = JSON.parse(message.toString());
         if (topic.startsWith(`${sessionDetails.sessionRootTopic}/context-groups/`)) {
-            const contextEvent = messageEnvelope;
-            if (contextEvent.source.sessionId === sessionDetails.sessionId) {
+            if (messageEnvelope.source.sessionId === sessionDetails.sessionId) {
                 return;
             }
-            const { contextGroup, context, source, history } = contextEvent;
-            this.#events.emitEvent('context', { contextGroup, context, source, history: { ...history, clientReceived: Date.now() } });
-        }
-        else if (topic.startsWith(`${sessionDetails.sessionRootTopic}/commands`)) {
-            this.#handleCommandMessage(messageEnvelope);
+            const { channelName: contextGroup, payload: context, source, history } = messageEnvelope;
+            this.#emitEvent('context', { contextGroup, context, source, history: { ...history, clientReceived: Date.now() } });
         }
     }
-    #handleCommandMessage(message) {
-        switch (message.command) {
-            case 'report-intents':
-            case 'intent-details':
-            case 'raise-intent':
-            case 'intent-result': {
-                this.#intents?.handleCommandMessage(message);
-                break;
-            }
-            default: {
-                this.#logger('warn', `Unknown command message received:\n${JSON.stringify(message, null, 2)}`);
-                break;
-            }
-        }
+    #emitEvent(type, ...args) {
+        const listeners = this.#eventListeners.get(type) || [];
+        listeners.forEach((listener) => listener(...args));
     }
     #validateConnectParams = (parameters) => {
         if (!parameters) {
@@ -594,9 +259,6 @@ class CloudInteropAPI {
         if (!parameters.sourceId) {
             throw new Error('sourceId must be provided');
         }
-        if (parameters.sourceId.includes(APP_ID_DELIM)) {
-            throw new Error(`sourceId cannot contain "${APP_ID_DELIM}"`);
-        }
         if (!parameters.platformId) {
             throw new Error('platformId must be provided');
         }
@@ -609,28 +271,29 @@ class CloudInteropAPI {
             throw new Error('basicAuthenticationParameters must be provided when using basic authentication');
         }
     };
-    #initControllers(mqttClient, sessionDetails, connectionParameters) {
-        this.#intents = new IntentController(this.#cloudInteropSettings.url, mqttClient, sessionDetails, connectionParameters, this.#events, this.#logger);
-    }
-    #destroyControllers() {
-        this.#intents = undefined;
-    }
-    #throwIfNotConnected() {
-        if (!this.#sessionDetails || !this.#connectionParams) {
-            throw new Error('Session not connected');
+    #getRequestHeaders = () => {
+        if (!this.#connectionParams) {
+            throw new Error('Connect parameters must be provided');
         }
-        if (!this.#mqttClient) {
-            throw new Error('MQTT client not connected');
+        const headers = new axios.AxiosHeaders();
+        headers['Content-Type'] = 'application/json';
+        if (this.#connectionParams.authenticationType === 'jwt' && this.#connectionParams.jwtAuthenticationParameters) {
+            const tokenResult = this.#connectionParams.jwtAuthenticationParameters.jwtRequestCallback();
+            if (!tokenResult) {
+                throw new Error('jwtRequestCallback must return a token');
+            }
+            headers['x-of-auth-id'] = this.#connectionParams.jwtAuthenticationParameters.authenticationId;
+            headers['Authorization'] =
+                typeof tokenResult === 'string' ? `Bearer ${tokenResult}` : `Bearer ${Buffer.from(JSON.stringify(tokenResult)).toString('base64')}`;
         }
-    }
+        if (this.#connectionParams.authenticationType === 'basic' && this.#connectionParams.basicAuthenticationParameters) {
+            const { username, password } = this.#connectionParams.basicAuthenticationParameters;
+            headers['Authorization'] = `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
+        }
+        return headers;
+    };
 }
 
 exports.AuthorizationError = AuthorizationError;
 exports.CloudInteropAPI = CloudInteropAPI;
 exports.CloudInteropAPIError = CloudInteropAPIError;
-Object.keys(sharedUtils).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-        enumerable: true,
-        get: function () { return sharedUtils[k]; }
-    });
-});