@morgan-stanley/composeui-fdc3 0.1.0-alpha.11 → 0.1.0-alpha.12

package/dist/fdc3-iife-bundle.js

@@ -135,7 +135,7 @@
   /**
      * @license
      * author: Morgan Stanley
-     * composeui-messaging-abstractions.js v0.1.0-alpha.11
+     * composeui-messaging-abstractions.js v0.1.0-alpha.12
      * Released under the Apache-2.0 license.
      */
 
@@ -402,6 +402,12 @@
       static joinUserChannel() {
           return `${this.topicRoot}/${this.joinUserChannelSuffix}`;
       }
+      static channelSelectorFromUI(instanceId) {
+          return `${this.topicRoot}/channelSelector/UI/${instanceId}`;
+      }
+      static channelSelectorFromAPI(instanceId) {
+          return `${this.topicRoot}/channelSelector/API/${instanceId}`;
+      }
       static getInfo() {
           return `${this.topicRoot}/${this.getInfoSuffix}`;
       }
@@ -520,6 +526,7 @@
       }
       async subscribe(channelId, channelType) {
           await this.registerContextListener(channelId, channelType);
+          console.debug("Subscribed context listener with id: ", this.id, ", to channel: ", channelId, ", of type: ", channelType, ", for context type: ", this.contextType);
           const subscribeTopic = ComposeUITopic.broadcast(channelId, channelType);
           this.unsubscribable = await this.jsonMessaging.subscribeJson(subscribeTopic, async (context) => {
               if (!this.contextType || this.contextType == context.type) {
@@ -531,6 +538,7 @@
                   }
               }
           });
+          console.log("Registered context listener with id: ", this.id, ", to topic: ", subscribeTopic);
           this.isSubscribed = true;
       }
       async handleContextMessage(context) {
@@ -562,15 +570,17 @@
       }
       async unsubscribe() {
           if (!this.unsubscribable || !this.isSubscribed) {
+              console.debug("The current listener is not subscribed.");
               return;
           }
           try {
               await this.leaveChannel();
+              console.debug("Unsubscribed context listener with id: ", this.id);
           }
           catch (err) {
               console.log(err);
           }
-          this.unsubscribable.unsubscribe();
+          await this.unsubscribable.unsubscribe();
           this.isSubscribed = false;
           if (this.unsubscribeCallback) {
               this.unsubscribeCallback(this);
@@ -591,6 +601,7 @@
           this.id = response.id;
       }
       async leaveChannel() {
+          console.debug("Removing context listener with id: ", this.id);
           const request = new Fdc3RemoveContextListenerRequest(window.composeui.fdc3.config?.instanceId, this.id, this.contextType);
           const response = await this.jsonMessaging.invokeJsonService(ComposeUITopic.removeContextListener(), request);
           if (!response) {
@@ -652,7 +663,7 @@
           this.jsonMessaging = jsonMessaging;
           this.displayMetadata = displayMetadata;
       }
-      //Broadcasting on the composeui/fdc3/v2.0/broadcast topic
+      //Broadcasting on the composeui/fdc3/v2.0/<channel>/broadcast topic
       async broadcast(context) {
           //Setting the last published context message.
           this.lastContexts.set(context.type, context);
@@ -1218,13 +1229,23 @@
    *  and limitations under the License.
    *
    */
-  class MessagingChannelFactory {
+  class MessagingChannelHandler {
       jsonMessaging;
       fdc3instanceId;
+      channelSelector = undefined;
       constructor(jsonMessaging, fdc3instanceId) {
           this.jsonMessaging = jsonMessaging;
           this.fdc3instanceId = fdc3instanceId;
       }
+      [Symbol.asyncDispose]() {
+          return this.channelSelector
+              ? this.channelSelector[Symbol.asyncDispose]()
+              : Promise.resolve();
+      }
+      async configureChannelSelectorFromUI() {
+          this.channelSelector = await this.jsonMessaging.registerService(ComposeUITopic.channelSelectorFromUI(this.fdc3instanceId), this.selectUserChannelFromUIHandler);
+          console.debug("Configured channel selector for module: ", this.fdc3instanceId);
+      }
       async getChannel(channelId, channelType) {
           const topic = ComposeUITopic.findChannel();
           const message = new Fdc3FindChannelRequest(channelId, channelType);
@@ -1283,20 +1304,37 @@
           return new ComposeUIChannel(channelId, "app", this.jsonMessaging);
       }
       async joinUserChannel(channelId) {
-          const topic = ComposeUITopic.joinUserChannel();
-          const request = new Fdc3JoinUserChannelRequest(channelId, this.fdc3instanceId);
-          const response = await this.jsonMessaging.invokeJsonService(topic, request);
-          if (!response) {
-              throw new Error(ChannelError.CreationFailed);
+          try {
+              const topic = ComposeUITopic.joinUserChannel();
+              const request = new Fdc3JoinUserChannelRequest(channelId, this.fdc3instanceId);
+              const response = await this.jsonMessaging.invokeJsonService(topic, request);
+              console.debug("Received joinUserChannel response: ", response);
+              if (!response) {
+                  throw new Error(ChannelError.CreationFailed);
+              }
+              if (response.error) {
+                  throw new Error(response.error);
+              }
+              if (!response.success) {
+                  throw new Error(ChannelError.CreationFailed);
+              }
+              var channel = new ComposeUIChannel(channelId, "user", this.jsonMessaging, response.displayMetadata);
+              this.triggerChannelJoinedEvent(channel.id);
+              return channel;
           }
-          if (response.error) {
-              throw new Error(response.error);
+          catch (error) {
+              console.error("Error joining user channel: ", error);
+              throw error;
           }
-          if (!response.success) {
-              throw new Error(ChannelError.CreationFailed);
+      }
+      async triggerChannelJoinedEvent(id) {
+          try {
+              var result = await this.jsonMessaging.invokeService(ComposeUITopic.channelSelectorFromAPI(this.fdc3instanceId), id);
+              console.debug("Triggered channel selector of container: ", this.fdc3instanceId, ", with: ", id, ", and got result:", result);
+          }
+          catch (error) {
+              console.error("Error triggering channel joined event for module: ", this.fdc3instanceId, ", with channel id: ", id, ", error: ", error);
           }
-          var channel = new ComposeUIChannel(channelId, "user", this.jsonMessaging, response.displayMetadata);
-          return channel;
       }
       async getUserChannels() {
           var request = new Fdc3GetUserChannelsRequest(this.fdc3instanceId);
@@ -1343,6 +1381,31 @@
           const listener = new ComposeUIContextListener(openHandled, this.jsonMessaging, handler, contextType ?? undefined);
           return listener;
       }
+      async leaveCurrentChannel() {
+          await this.triggerChannelJoinedEvent(undefined);
+      }
+      async selectUserChannelFromUIHandler(request) {
+          try {
+              if (!request) {
+                  console.debug("Empty request received when the user channel selection was requested from UI.");
+                  return null;
+              }
+              var objectRequest = JSON.parse(request);
+              var joinUserChannelRequest = objectRequest;
+              console.debug("Parsed the request from the UI when user selected a user channel to join: ", joinUserChannelRequest);
+              if (!joinUserChannelRequest || !joinUserChannelRequest.channelId) {
+                  console.debug("Invalid request received when user selected a user channel to join to from the UI: ", request);
+                  return null;
+              }
+              //We should join the channel requested by the user from the UI. -> this will trigger the handler of the module/container to show which channel the app is joined to.
+              await window.fdc3.joinUserChannel(joinUserChannelRequest.channelId);
+              return joinUserChannelRequest.channelId;
+          }
+          catch (error) {
+              console.error("Error processing request when channel selector was invoked: ", request, ", error: ", error);
+              return null;
+          }
+      }
   }
 
   /*
@@ -1372,16 +1435,16 @@
 
   class ComposeUIIntentResolution {
       jsonMessaging;
-      channelFactory;
+      channelHandler;
       source;
       intent;
       messageId;
-      constructor(messageId, jsonMessaging, channelFactory, intent, source) {
+      constructor(messageId, jsonMessaging, channelHandler, intent, source) {
           this.messageId = messageId;
           this.intent = intent;
           this.source = source;
           this.jsonMessaging = jsonMessaging;
-          this.channelFactory = channelFactory;
+          this.channelHandler = channelHandler;
       }
       async getResult() {
           const intentResolutionRequest = new Fdc3GetIntentResultRequest(this.messageId, this.intent, this.source, this.source.version);
@@ -1393,7 +1456,7 @@
               throw new Error(result.error);
           }
           if (result.channelId && result.channelType) {
-              const channel = this.channelFactory.getChannel(result.channelId, result.channelType);
+              const channel = this.channelHandler.getChannel(result.channelId, result.channelType);
               return channel;
           }
           else if (result.context) {
@@ -1508,13 +1571,13 @@
    *
    */
   class MessagingIntentsClient {
-      channelFactory;
+      channelHandler;
       jsonMessaging;
       constructor(jsonMessaging, channelFactory) {
           if (!window.composeui.fdc3.config || !window.composeui.fdc3.config.instanceId) {
               throw new Error(ComposeUIErrors.InstanceIdNotFound);
           }
-          this.channelFactory = channelFactory;
+          this.channelHandler = channelFactory;
           this.jsonMessaging = jsonMessaging;
       }
       async findIntent(intent, context, resultType) {
@@ -1542,7 +1605,7 @@
           return message.appIntents;
       }
       async getIntentResolution(messageId, intent, source) {
-          return new ComposeUIIntentResolution(messageId, this.jsonMessaging, this.channelFactory, intent, source);
+          return new ComposeUIIntentResolution(messageId, this.jsonMessaging, this.channelHandler, intent, source);
       }
       async raiseIntent(intent, context, app) {
           if (typeof app == 'string') {
@@ -1557,7 +1620,7 @@
           if (response.error) {
               throw new Error(response.error);
           }
-          const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelFactory, response.intent, response.appMetadata);
+          const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelHandler, response.intent, response.appMetadata);
           return intentResolution;
       }
       async raiseIntentForContext(context, app) {
@@ -1573,7 +1636,7 @@
           if (response.error) {
               throw new Error(response.error);
           }
-          const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelFactory, response.intent, response.appMetadata);
+          const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelHandler, response.intent, response.appMetadata);
           return intentResolution;
       }
   }
@@ -1802,30 +1865,43 @@
    *
    */
   class ComposeUIDesktopAgent {
-      appChannels = [];
-      userChannels = [];
-      privateChannels = [];
       currentChannel;
       topLevelContextListeners = [];
       intentListeners = [];
-      channelFactory;
+      channelHandler;
       intentsClient;
       metadataClient;
       openClient;
       openedAppContext;
       openedAppContextHandled = false;
       //TODO: we should enable passing multiple channelId to the ctor.
-      constructor(messaging, channelFactory, intentsClient, metadataClient, openClient) {
+      constructor(messaging, channelHandler, intentsClient, metadataClient, openClient) {
           if (!window.composeui.fdc3.config || !window.composeui.fdc3.config.instanceId) {
               throw new Error(ComposeUIErrors.InstanceIdNotFound);
           }
           const jsonMessaging = new JsonMessaging(messaging);
           // TODO: inject this directly instead of the messageRouter
-          this.channelFactory = channelFactory ?? new MessagingChannelFactory(jsonMessaging, window.composeui.fdc3.config.instanceId);
-          this.intentsClient = intentsClient ?? new MessagingIntentsClient(jsonMessaging, this.channelFactory);
+          this.channelHandler = channelHandler ?? new MessagingChannelHandler(jsonMessaging, window.composeui.fdc3.config.instanceId);
+          this.intentsClient = intentsClient ?? new MessagingIntentsClient(jsonMessaging, this.channelHandler);
           this.metadataClient = metadataClient ?? new MessagingMetadataClient(jsonMessaging, window.composeui.fdc3.config);
           this.openClient = openClient ?? new MessagingOpenClient(window.composeui.fdc3.config.instanceId, jsonMessaging, window.composeui.fdc3.openAppIdentifier);
       }
+      async [Symbol.asyncDispose]() {
+          console.debug("Disposing ComposeUIDesktopAgent");
+          await this.channelHandler[Symbol.asyncDispose]();
+          for (const listener of this.intentListeners) {
+              await listener.unsubscribe();
+          }
+          this.intentListeners = [];
+          for (const listener of this.topLevelContextListeners) {
+              await listener.unsubscribe();
+          }
+          this.topLevelContextListeners = [];
+      }
+      // This regiters an endpoint to listen when an action was initiated from the UI to select a user channel to join to.
+      async init() {
+          await this.channelHandler.configureChannelSelectorFromUI();
+      }
       async open(app, context) {
           return await this.openClient.open(app, context);
       }
@@ -1851,7 +1927,7 @@
           return await this.intentsClient.raiseIntentForContext(context, app);
       }
       async addIntentListener(intent, handler) {
-          var listener = await this.channelFactory.getIntentListener(intent, handler);
+          var listener = await this.channelHandler.getIntentListener(intent, handler);
           this.intentListeners.push(listener);
           return listener;
       }
@@ -1872,7 +1948,7 @@
               //There is no context to handle -aka app was not opened via the fdc3.open
               this.openedAppContextHandled = true;
           }
-          const listener = await this.channelFactory.getContextListener(this.openedAppContextHandled, this.currentChannel, handler, contextType);
+          const listener = await this.channelHandler.getContextListener(this.openedAppContextHandled, this.currentChannel, handler, contextType);
           this.topLevelContextListeners.push(listener);
           if (!this.currentChannel) {
               return listener;
@@ -1884,20 +1960,18 @@
           });
       }
       async getUserChannels() {
-          return await this.channelFactory.getUserChannels();
+          return await this.channelHandler.getUserChannels();
       }
       async joinUserChannel(channelId) {
           if (this.currentChannel) {
               //DesktopAgnet clients can listen on only one channel
+              console.debug("Leaving current channel: ", this.currentChannel.id);
               await this.leaveCurrentChannel();
           }
-          let channel = this.userChannels.find(innerChannel => innerChannel.id == channelId);
+          let channel = await this.channelHandler.joinUserChannel(channelId);
+          console.debug("Joined to user channel: ", channelId);
           if (!channel) {
-              channel = await this.channelFactory.joinUserChannel(channelId);
-              if (!channel) {
-                  throw new Error(ChannelError.NoChannelFound);
-              }
-              this.addChannel(channel);
+              throw new Error(ChannelError.NoChannelFound);
           }
           this.currentChannel = channel;
           for (const listener of this.topLevelContextListeners) {
@@ -1908,26 +1982,25 @@
           }
       }
       async getOrCreateChannel(channelId) {
-          let appChannel = this.appChannels.find(channel => channel.id == channelId);
-          if (appChannel) {
-              return appChannel;
-          }
-          appChannel = await this.channelFactory.createAppChannel(channelId);
-          this.addChannel(appChannel);
+          let appChannel = await this.channelHandler.createAppChannel(channelId);
           return appChannel;
       }
       async createPrivateChannel() {
-          return await this.channelFactory.createPrivateChannel();
+          return await this.channelHandler.createPrivateChannel();
       }
       async getCurrentChannel() {
           return this.currentChannel ?? null;
       }
       async leaveCurrentChannel() {
           //The context listeners, that have been added through the `fdc3.addContextListener()` should unsubscribe
+          console.debug("Unsubscribing top level context listeners: ", this.topLevelContextListeners);
           for (const listener of this.topLevelContextListeners) {
               await listener.unsubscribe();
           }
-          this.currentChannel = undefined;
+          if (this.currentChannel) {
+              await this.channelHandler.leaveCurrentChannel();
+              this.currentChannel = undefined;
+          }
       }
       async getInfo() {
           return await this.metadataClient.getInfo();
@@ -1953,21 +2026,6 @@
               console.error("The opened app via fdc3.open() could not retrieve the context: ", err);
           }
       }
-      addChannel(channel) {
-          if (channel == null)
-              return;
-          switch (channel.type) {
-              case "app":
-                  this.appChannels.push(channel);
-                  break;
-              case "user":
-                  this.userChannels.push(channel);
-                  break;
-              case "private":
-                  this.privateChannels.push(channel);
-                  break;
-          }
-      }
       async callHandlerOnChannelsCurrentContext(listener) {
           const lastContext = await this.currentChannel.getCurrentContext(listener.contextType);
           if (lastContext) {
@@ -1994,6 +2052,30 @@
       const openAppIdentifier = window.composeui.fdc3.openAppIdentifier;
       const messaging = window.composeui.messaging.communicator;
       const fdc3 = new ComposeUIDesktopAgent(messaging);
+      await fdc3.init();
+      let _disposed = false;
+      const disposeAgent = () => {
+          if (_disposed) {
+              return;
+          }
+          _disposed = true;
+          try {
+              const agent = window.fdc3 || fdc3;
+              if (agent) {
+                  agent[Symbol.asyncDispose]();
+              }
+          }
+          catch (err) {
+              console.warn("Error disposing FDC3 agent", err);
+          }
+          finally {
+              // remove handlers after first run
+              window.removeEventListener("beforeunload", disposeAgent);
+              window.removeEventListener("unload", disposeAgent);
+          }
+      };
+      window.addEventListener("beforeunload", disposeAgent);
+      window.addEventListener("unload", disposeAgent);
       if (channelId) {
           await fdc3.joinUserChannel(channelId)
               .then(async () => {
@@ -2001,11 +2083,13 @@
                   await fdc3.getOpenedAppContext()
                       .then(() => {
                       window.fdc3 = fdc3;
+                      console.log("FDC3 initialized, handled initial context which initiates that the app was opened via `fdc3.open` and joined to channel: ", channelId, window.fdc3);
                       window.dispatchEvent(new Event("fdc3Ready"));
                   });
               }
               else {
                   window.fdc3 = fdc3;
+                  console.log("FDC3 initialized and joined to channel: ", channelId, window.fdc3);
                   window.dispatchEvent(new Event("fdc3Ready"));
               }
           });
@@ -2014,11 +2098,13 @@
           if (openAppIdentifier) {
               await fdc3.getOpenedAppContext().then(() => {
                   window.fdc3 = fdc3;
+                  console.log("FDC3 initialized, handled initial context which initiates that the app was opened via `fdc3.open`: ", window.fdc3);
                   window.dispatchEvent(new Event("fdc3Ready"));
               });
           }
           else {
               window.fdc3 = fdc3;
+              console.log("FDC3 initialized: ", window.fdc3);
               window.dispatchEvent(new Event("fdc3Ready"));
           }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morgan-stanley/composeui-fdc3",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.12",
   "private": false,
   "description": "FDC3 DesktopAgent implementation for Compose UI",
   "type": "module",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@finos/fdc3": "~2.0.3",
     "@morgan-stanley/composeui-messaging-abstractions": "*",
-    "rxjs": "^7.8.1"
+    "rxjs": "7.8.2"
   },
   "repository": {
     "type": "git",
@@ -30,16 +30,16 @@
     "provenance": true
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "28.0.6",
-    "@rollup/plugin-node-resolve": "16.0.1",
+    "@rollup/plugin-commonjs": "29.0.0",
+    "@rollup/plugin-node-resolve": "16.0.3",
     "@types/node": "^24.5.2",
-    "jsdom": "^26.0.0",
-    "rimraf": "6.0.1",
-    "rollup": "^4.12.1",
+    "jsdom": "^28.1.0",
+    "rimraf": "6.1.3",
+    "rollup": "4.59.0",
     "ts-node": "10.9.2",
-    "tslib": "^2.4.0",
-    "typescript": "^5.3.3",
-    "vitest": "^2.0.0"
+    "tslib": "2.8.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
   },
-  "gitHead": "85e43dfe80fbc27986266263d1959fcae91110ac"
+  "gitHead": "78d8bf3c57db6188e507391de8dfe1720985c315"
 }

package/src/ComposeUIContextListener.spec.ts

@@ -11,6 +11,7 @@
  *  
  */
 
+import { ContextHandler } from '@finos/fdc3';
 import { ComposeUIContextListener } from './infrastructure/ComposeUIContextListener';
 import { Fdc3AddContextListenerResponse } from './infrastructure/messages/Fdc3AddContextListenerResponse';
 import { IMessaging, JsonMessaging } from '@morgan-stanley/composeui-messaging-abstractions';
@@ -34,14 +35,20 @@ const wrongContext = {
     type: 'dummy'
 }
 
-const contextMessageHandlerMock = {
-  contextHandler: (_: unknown) => {}
-};
+export interface ContextHandlerMock {
+    contextHandler: ContextHandler;
+}
+
+let contextMessageHandlerMock : ContextHandlerMock;
 
 describe('Tests for ComposeUIContextListener implementation API', () => {
     
     beforeEach(async () => {
 
+        contextMessageHandlerMock = {
+            contextHandler: (_: unknown) => {}
+        };
+
         // @ts-ignore
         window.composeui = {
             fdc3: {

package/src/ComposeUIDesktopAgent.spec.ts

@@ -18,7 +18,7 @@ import { ComposeUIDesktopAgent } from './ComposeUIDesktopAgent';
 import { ComposeUITopic } from './infrastructure/ComposeUITopic';
 import { Channel, ChannelError, ContextHandler } from '@finos/fdc3';
 import { ComposeUIErrors } from './infrastructure/ComposeUIErrors';
-import { ChannelFactory } from './infrastructure/ChannelFactory';
+import { ChannelHandler } from './infrastructure/ChannelHandler';
 import { ComposeUIPrivateChannel } from './infrastructure/ComposeUIPrivateChannel';
 import { ChannelType } from './infrastructure/ChannelType';
 import { Fdc3GetOpenedAppContextResponse } from './infrastructure/messages/Fdc3GetOpenedAppContextResponse';
@@ -36,7 +36,7 @@ const testInstrument = {
 
 const contextMessageHandlerMock = vi.fn((_ctx) => 'dummy');
 
-const buildChannelFactory = (jm: JsonMessaging): ChannelFactory => ({
+const buildChannelFactory = (jm: JsonMessaging): ChannelHandler => ({
   createPrivateChannel: vi.fn(() =>
     Promise.resolve(new ComposeUIPrivateChannel('privateId', 'localInstance', jm, true))
   ),
@@ -51,7 +51,10 @@ const buildChannelFactory = (jm: JsonMessaging): ChannelFactory => ({
   getContextListener: vi.fn(
     (_openHandled: boolean, _channel: Channel, handler: ContextHandler, contextType?: string) =>
       Promise.resolve(new ComposeUIContextListener(true, jm, handler, contextType))
-  )
+  ),
+  leaveCurrentChannel: vi.fn(() => Promise.resolve()),
+  configureChannelSelectorFromUI: vi.fn(() => Promise.resolve()),
+  [Symbol.asyncDispose]: vi.fn(() => Promise.resolve())
 });
 
 describe('Tests for ComposeUIDesktopAgent implementation API', () => {

package/src/ComposeUIDesktopAgent.ts

@@ -29,8 +29,8 @@ import {
 import { IMessaging, JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
 import { ComposeUIContextListener } from './infrastructure/ComposeUIContextListener';
 import { ComposeUIErrors } from './infrastructure/ComposeUIErrors';
-import { ChannelFactory } from './infrastructure/ChannelFactory';
-import { MessagingChannelFactory } from './infrastructure/MessagingChannelFactory';
+import { ChannelHandler } from './infrastructure/ChannelHandler';
+import { MessagingChannelHandler } from './infrastructure/MessagingChannelHandler';
 import { MessagingIntentsClient } from './infrastructure/MessagingIntentsClient';
 import { IntentsClient } from './infrastructure/IntentsClient';
 import { MetadataClient } from './infrastructure/MetadataClient';
@@ -38,14 +38,11 @@ import { MessagingMetadataClient } from './infrastructure/MessagingMetadataClien
 import { OpenClient } from "./infrastructure/OpenClient";
 import { MessagingOpenClient } from "./infrastructure/MessagingOpenClient";
 
-export class ComposeUIDesktopAgent implements DesktopAgent {
-    private appChannels: Channel[] = [];
-    private userChannels: Channel[] = [];
-    private privateChannels: Channel[] = [];
+export class ComposeUIDesktopAgent implements DesktopAgent, AsyncDisposable {
     private currentChannel?: Channel;
     private topLevelContextListeners: ComposeUIContextListener[] = [];
     private intentListeners: Listener[] = [];
-    private channelFactory: ChannelFactory;
+    private channelHandler: ChannelHandler;
     private intentsClient: IntentsClient;
     private metadataClient: MetadataClient;
     private openClient: OpenClient;
@@ -55,7 +52,7 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
     //TODO: we should enable passing multiple channelId to the ctor.
     constructor(
         messaging: IMessaging, 
-        channelFactory?: ChannelFactory,
+        channelHandler?: ChannelHandler,
         intentsClient?: IntentsClient,
         metadataClient?: MetadataClient,
         openClient?: OpenClient) {
@@ -67,12 +64,35 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
         const jsonMessaging: JsonMessaging = new JsonMessaging(messaging);
 
         // TODO: inject this directly instead of the messageRouter
-        this.channelFactory = channelFactory ?? new MessagingChannelFactory(jsonMessaging, window.composeui.fdc3.config.instanceId);
-        this.intentsClient = intentsClient ?? new MessagingIntentsClient(jsonMessaging, this.channelFactory);
+        this.channelHandler = channelHandler ?? new MessagingChannelHandler(jsonMessaging, window.composeui.fdc3.config.instanceId);
+        this.intentsClient = intentsClient ?? new MessagingIntentsClient(jsonMessaging, this.channelHandler);
         this.metadataClient = metadataClient ?? new MessagingMetadataClient(jsonMessaging, window.composeui.fdc3.config);
         this.openClient = openClient ?? new MessagingOpenClient(window.composeui.fdc3.config.instanceId!, jsonMessaging, window.composeui.fdc3.openAppIdentifier);
     }
 
+    public async [Symbol.asyncDispose](): Promise<void> {
+        console.debug("Disposing ComposeUIDesktopAgent");
+        
+        await this.channelHandler[Symbol.asyncDispose]();
+
+        for (const listener of this.intentListeners) {
+            await listener.unsubscribe();
+        }
+
+        this.intentListeners = [];
+
+        for (const listener of this.topLevelContextListeners) {
+            await listener.unsubscribe();
+        }
+
+        this.topLevelContextListeners = [];
+    }
+
+    // This regiters an endpoint to listen when an action was initiated from the UI to select a user channel to join to.
+    public async init(): Promise<void> {
+        await this.channelHandler.configureChannelSelectorFromUI();
+    }
+
     public async open(app?: string | AppIdentifier, context?: Context): Promise<AppIdentifier> {
         return await this.openClient.open(app, context);
     }
@@ -106,7 +126,7 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
     }
 
     public async addIntentListener(intent: string, handler: IntentHandler): Promise<Listener> {
-        var listener = await this.channelFactory.getIntentListener(intent, handler);
+        var listener = await this.channelHandler.getIntentListener(intent, handler);
         this.intentListeners.push(listener);
         return listener;
     }
@@ -132,7 +152,7 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
             this.openedAppContextHandled = true;
         }
 
-        const listener = <ComposeUIContextListener>await this.channelFactory.getContextListener(this.openedAppContextHandled, this.currentChannel, handler, contextType);
+        const listener = <ComposeUIContextListener>await this.channelHandler.getContextListener(this.openedAppContextHandled, this.currentChannel, handler, contextType);
         this.topLevelContextListeners.push(listener);
 
         if (!this.currentChannel) {
@@ -147,24 +167,22 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
     }
 
     public async getUserChannels(): Promise<Array<Channel>> {
-        return await this.channelFactory.getUserChannels();
+        return await this.channelHandler.getUserChannels();
     }
 
     public async joinUserChannel(channelId: string): Promise<void> {
         if (this.currentChannel) {
             //DesktopAgnet clients can listen on only one channel
+            console.debug("Leaving current channel: ", this.currentChannel.id);
             await this.leaveCurrentChannel();
         }
 
-        let channel = this.userChannels.find(innerChannel => innerChannel.id == channelId);
+        let channel = await this.channelHandler.joinUserChannel(channelId);
+
+        console.debug("Joined to user channel: ", channelId);
+
         if (!channel) {
-            channel = await this.channelFactory.joinUserChannel(channelId);
-            
-            if (!channel) {
-                throw new Error(ChannelError.NoChannelFound);
-            }
-    
-            this.addChannel(channel);
+            throw new Error(ChannelError.NoChannelFound);
         }
 
         this.currentChannel = channel;
@@ -178,19 +196,12 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
     }
 
     public async getOrCreateChannel(channelId: string): Promise<Channel> {
-        let appChannel = this.appChannels.find(channel => channel.id == channelId);
-        if (appChannel) {
-            return appChannel;
-        }
-
-        appChannel = await this.channelFactory.createAppChannel(channelId);
-
-        this.addChannel(appChannel!);
+        let appChannel = await this.channelHandler.createAppChannel(channelId);
         return appChannel!;
     }
 
     public async createPrivateChannel(): Promise<PrivateChannel> {
-        return await this.channelFactory.createPrivateChannel();
+        return await this.channelHandler.createPrivateChannel();
     }
 
     public async getCurrentChannel(): Promise<Channel | null> {
@@ -199,11 +210,15 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
 
     public async leaveCurrentChannel(): Promise<void> {
         //The context listeners, that have been added through the `fdc3.addContextListener()` should unsubscribe
+        console.debug("Unsubscribing top level context listeners: ", this.topLevelContextListeners);
         for (const listener of this.topLevelContextListeners) {
             await listener.unsubscribe();
         }
         
-        this.currentChannel = undefined;
+        if (this.currentChannel) {
+            await this.channelHandler.leaveCurrentChannel();
+            this.currentChannel = undefined;
+        }
     }
 
     public async getInfo(): Promise<ImplementationMetadata> {
@@ -234,21 +249,6 @@ export class ComposeUIDesktopAgent implements DesktopAgent {
         }
     }
 
-    private addChannel(channel: Channel): void {
-        if (channel == null) return;
-        switch (channel.type) {
-            case "app":
-                this.appChannels.push(channel);
-                break;
-            case "user":
-                this.userChannels.push(channel);
-                break;
-            case "private":
-                this.privateChannels.push(channel);
-                break;
-        }
-    }
-
     private async callHandlerOnChannelsCurrentContext(listener: ComposeUIContextListener) : Promise<void> {
         const lastContext = await this.currentChannel!.getCurrentContext(listener.contextType);
 

package/src/{ComposeUIMessagingChannelFactory.spec.ts → ComposeUIMessagingChannelHandler.spec.ts}

@@ -12,7 +12,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { ChannelError } from '@finos/fdc3';
-import { MessagingChannelFactory } from './infrastructure/MessagingChannelFactory';
+import { MessagingChannelHandler } from './infrastructure/MessagingChannelHandler';
 import { Fdc3JoinUserChannelResponse } from './infrastructure/messages/Fdc3JoinUserChannelResponse';
 import { Fdc3GetUserChannelsResponse } from './infrastructure/messages/Fdc3GetUserChannelsResponse';
 import { ComposeUIChannel } from './infrastructure/ComposeUIChannel';
@@ -30,11 +30,11 @@ const baseMessagingMock = (): IMessaging => ({
   invokeService: vi.fn(() => Promise.resolve(null))
 });
 
-describe('MessagingChannelFactory tests', () => {
+describe('MessagingChannelHandler tests', () => {
   it('joinUserChannel rejects CreationFailed when no response', async () => {
     const messagingMock = baseMessagingMock();
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     await expect(factory.joinUserChannel('dummyId')).rejects.toThrow(ChannelError.CreationFailed);
     expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
   });
@@ -44,7 +44,7 @@ describe('MessagingChannelFactory tests', () => {
     const messagingMock = baseMessagingMock();
     messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     await expect(factory.joinUserChannel('dummyId')).rejects.toThrow('testError');
     expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
   });
@@ -57,7 +57,7 @@ describe('MessagingChannelFactory tests', () => {
     const messagingMock = baseMessagingMock();
     messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     await expect(factory.joinUserChannel('dummyId')).rejects.toThrow(ChannelError.CreationFailed);
     expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
   });
@@ -70,16 +70,16 @@ describe('MessagingChannelFactory tests', () => {
     const messagingMock = baseMessagingMock();
     messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     const result = await factory.joinUserChannel('dummyId');
     expect(result).toBeInstanceOf(ComposeUIChannel);
-    expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
+    expect(messagingMock.invokeService).toHaveBeenCalledTimes(2); //This will trigger the channel selector logic as well.
   });
 
   it('getUserChannels rejects NoChannelFound when no response', async () => {
     const messagingMock = baseMessagingMock();
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     await expect(factory.getUserChannels()).rejects.toThrow(ChannelError.NoChannelFound);
     expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
   });
@@ -89,7 +89,7 @@ describe('MessagingChannelFactory tests', () => {
     const messagingMock = baseMessagingMock();
     messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     await expect(factory.getUserChannels()).rejects.toThrow('testError');
     expect(messagingMock.invokeService).toHaveBeenCalledTimes(1);
   });
@@ -101,7 +101,7 @@ describe('MessagingChannelFactory tests', () => {
     const messagingMock = baseMessagingMock();
     messagingMock.invokeService = vi.fn(() => Promise.resolve(JSON.stringify(response)));
     const jsonMessaging = new JsonMessaging(messagingMock);
-    const factory = new MessagingChannelFactory(jsonMessaging, 'localInstance');
+    const factory = new MessagingChannelHandler(jsonMessaging, 'localInstance');
     const result = await factory.getUserChannels();
     expect(result).toBeDefined();
     expect(result.length).toBe(1);

package/src/index.ts

@@ -39,6 +39,33 @@ async function initialize(): Promise<void> {
     const openAppIdentifier: OpenAppIdentifier | undefined = window.composeui.fdc3.openAppIdentifier;
     const messaging = window.composeui.messaging.communicator as IMessaging;
     const fdc3 = new ComposeUIDesktopAgent(messaging);
+    await fdc3.init();
+
+    let _disposed = false;
+
+    const disposeAgent = () => {
+        if (_disposed) {
+            return;
+        }
+
+        _disposed = true;
+
+        try {
+            const agent: ComposeUIDesktopAgent = (window.fdc3 as ComposeUIDesktopAgent) || fdc3;
+            if (agent) {
+                agent[Symbol.asyncDispose]()
+            }
+        } catch (err) {
+            console.warn("Error disposing FDC3 agent", err);
+        } finally {
+            // remove handlers after first run
+            window.removeEventListener("beforeunload", disposeAgent);
+            window.removeEventListener("unload", disposeAgent);
+        }
+    };
+
+    window.addEventListener("beforeunload", disposeAgent);
+    window.addEventListener("unload", disposeAgent);
 
     if (channelId) {
         await fdc3.joinUserChannel(channelId)
@@ -47,10 +74,12 @@ async function initialize(): Promise<void> {
                     await fdc3.getOpenedAppContext()
                         .then(() => {
                             window.fdc3 = fdc3;
+                            console.log("FDC3 initialized, handled initial context which initiates that the app was opened via `fdc3.open` and joined to channel: ", channelId, window.fdc3);
                             window.dispatchEvent(new Event("fdc3Ready"));
                         })
                 } else {
                     window.fdc3 = fdc3;
+                    console.log("FDC3 initialized and joined to channel: ", channelId, window.fdc3);
                     window.dispatchEvent(new Event("fdc3Ready"));
                 }
             });
@@ -58,10 +87,12 @@ async function initialize(): Promise<void> {
         if (openAppIdentifier) {
             await fdc3.getOpenedAppContext().then(() => {
                 window.fdc3 = fdc3;
+                console.log("FDC3 initialized, handled initial context which initiates that the app was opened via `fdc3.open`: ", window.fdc3);
                 window.dispatchEvent(new Event("fdc3Ready"));
             })
         } else {
             window.fdc3 = fdc3;
+            console.log("FDC3 initialized: ", window.fdc3);
             window.dispatchEvent(new Event("fdc3Ready"));
         }
     }

package/src/infrastructure/{ChannelFactory.ts → ChannelHandler.ts}

@@ -14,12 +14,49 @@
 import { Channel, ContextHandler, IntentHandler, Listener, PrivateChannel } from "@finos/fdc3";
 import { ChannelType } from "./ChannelType";
 
-export interface ChannelFactory {
+export interface ChannelHandler extends AsyncDisposable {
+    /*
+    * Gets a channel by sending a request to the backend using its ID and type
+    */
     getChannel(channelId: string, channelType: ChannelType): Promise<Channel>;
+
+    /*
+    * Creates a private channel by sending a request to the backend
+    */
     createPrivateChannel(): Promise<PrivateChannel>;
+
+    /*
+    * Creates an app channel by sending a request to the backend using its ID
+    */
     createAppChannel(channelId: string): Promise<Channel>;
+
+    /*
+    * Joins a user channel by sending a request to the backend using its ID
+    */
     joinUserChannel(channelId: string): Promise<Channel>;
+
+    /*
+    * Gets all the user channels by sending a request to the backend
+    */
     getUserChannels(): Promise<Channel[]>;
+
+    /*
+    * Gets all the app channels by sending a request to the backend
+    */
     getIntentListener(intent: string, handler: IntentHandler): Promise<Listener>;
+
+    /*
+    * Gets a context listener by sending a request to the backend. This should reflect if the initial context sent by the fdc3.open call was handled or not.
+    */
     getContextListener(openHandled: boolean, channel?: Channel, handler?: ContextHandler, contextType?: string | null): Promise<Listener>;
+
+    /*
+    * Configures the channel selector to allow the user to select a channel from the UI, by registering an endpoint to listen to UI initiated actions.
+    */
+    configureChannelSelectorFromUI(): Promise<void>;
+
+    /*
+    * Leaves the current channel by sending a request to the backend using its ID
+    */
+    leaveCurrentChannel(): Promise<void>;
 }

package/src/infrastructure/ChannelItem.ts

@@ -13,6 +13,9 @@
 import { DisplayMetadata } from "@finos/fdc3";
 import { ChannelType } from "./ChannelType";
 
+/*
+* Represents a channel item containing its id, type and optional display metadata
+*/
 export interface ChannelItem {
     id: string;
     type: ChannelType;

package/src/infrastructure/ComposeUIChannel.ts

@@ -35,7 +35,7 @@ export class ComposeUIChannel implements Channel {
         this.displayMetadata = displayMetadata;
     }
 
-    //Broadcasting on the composeui/fdc3/v2.0/broadcast topic
+    //Broadcasting on the composeui/fdc3/v2.0/<channel>/broadcast topic
     public async broadcast(context: Context): Promise<void> {
         //Setting the last published context message.
         this.lastContexts.set(context.type, context);

package/src/infrastructure/ComposeUIContextListener.ts

@@ -42,6 +42,9 @@ export class ComposeUIContextListener implements Listener {
 
     public async subscribe(channelId: string, channelType: ChannelType): Promise<void> {
         await this.registerContextListener(channelId, channelType);
+
+        console.debug("Subscribed context listener with id: ", this.id, ", to channel: ", channelId, ", of type: ", channelType, ", for context type: ", this.contextType);
+
         const subscribeTopic = ComposeUITopic.broadcast(channelId, channelType);
 
         this.unsubscribable = await this.jsonMessaging.subscribeJson<Context>(subscribeTopic, async (context: Context) => {
@@ -54,6 +57,7 @@ export class ComposeUIContextListener implements Listener {
             }
         });
 
+        console.log("Registered context listener with id: ", this.id, ", to topic: ", subscribeTopic);
         this.isSubscribed = true;
     }
 
@@ -94,16 +98,18 @@ export class ComposeUIContextListener implements Listener {
 
     public async unsubscribe(): Promise<void> {
         if (!this.unsubscribable || !this.isSubscribed) {
+            console.debug("The current listener is not subscribed.");
             return;
         }
         
         try {
             await this.leaveChannel();
+            console.debug("Unsubscribed context listener with id: ", this.id);
         } catch(err) {
             console.log(err);
         }
 
-        this.unsubscribable.unsubscribe();
+        await this.unsubscribable.unsubscribe();
         this.isSubscribed = false;
 
         if (this.unsubscribeCallback) {
@@ -129,6 +135,7 @@ export class ComposeUIContextListener implements Listener {
     }
 
     private async leaveChannel() : Promise<void> {
+        console.debug("Removing context listener with id: ", this.id);
         const request = new Fdc3RemoveContextListenerRequest(window.composeui.fdc3.config?.instanceId!, this.id!, this.contextType);
         const response = await this.jsonMessaging.invokeJsonService<Fdc3RemoveContextListenerRequest, Fdc3RemoveContextListenerResponse>(ComposeUITopic.removeContextListener(), request);
         if (!response) {

package/src/infrastructure/ComposeUIIntentResolution.ts

@@ -12,7 +12,7 @@
  */
 import { AppMetadata, IntentResolution, IntentResult } from "@finos/fdc3";
 import { JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
-import { ChannelFactory } from "./ChannelFactory";
+import { ChannelHandler } from "./ChannelHandler";
 import { ComposeUIErrors } from "./ComposeUIErrors";
 import { ComposeUITopic } from "./ComposeUITopic";
 import { Fdc3GetIntentResultRequest } from "./messages/Fdc3GetIntentResultRequest";
@@ -20,18 +20,18 @@ import { Fdc3GetIntentResultResponse } from "./messages/Fdc3GetIntentResultRespo
 
 export class ComposeUIIntentResolution implements IntentResolution {
     private jsonMessaging: JsonMessaging;
-    private channelFactory: ChannelFactory;
+    private channelHandler: ChannelHandler;
     public source: AppMetadata;
     public intent: string
     public messageId: string;
 
 
-    constructor(messageId: string, jsonMessaging: JsonMessaging, channelFactory: ChannelFactory, intent: string, source: AppMetadata) {
+    constructor(messageId: string, jsonMessaging: JsonMessaging, channelHandler: ChannelHandler, intent: string, source: AppMetadata) {
         this.messageId = messageId;
         this.intent = intent;
         this.source = source;
         this.jsonMessaging = jsonMessaging;
-        this.channelFactory = channelFactory;
+        this.channelHandler = channelHandler;
     }
 
     async getResult(): Promise<IntentResult> {
@@ -47,7 +47,7 @@ export class ComposeUIIntentResolution implements IntentResolution {
         }
 
         if (result.channelId && result.channelType) {
-            const channel = this.channelFactory.getChannel(result.channelId, result.channelType)
+            const channel = this.channelHandler.getChannel(result.channelId, result.channelType)
             return channel;
         } else if (result.context) {
             return result.context;

package/src/infrastructure/ComposeUIPrivateChannel.ts

@@ -104,7 +104,7 @@ export class ComposeUIPrivateChannel extends ComposeUIChannel implements Private
         if (this.disconnected) {
             throw new Error("Channel disconnected");
         }
-
+        
         return super.broadcast(context)
     }
 

package/src/infrastructure/ComposeUITopic.ts

@@ -107,6 +107,14 @@ export class ComposeUITopic {
         return `${this.topicRoot}/${this.joinUserChannelSuffix}`;
     }
 
+    public static channelSelectorFromUI(instanceId: string): string {
+        return `${this.topicRoot}/channelSelector/UI/${instanceId}`;
+    }
+
+    public static channelSelectorFromAPI(instanceId: string): string {
+        return `${this.topicRoot}/channelSelector/API/${instanceId}`;
+    }
+
     public static getInfo(): string {
         return `${this.topicRoot}/${this.getInfoSuffix}`;
     }

package/src/infrastructure/{MessagingChannelFactory.ts → MessagingChannelHandler.ts}

@@ -14,7 +14,7 @@
 import { ChannelError, ContextHandler, IntentHandler, Listener, PrivateChannel } from "@finos/fdc3";
 import { JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
 import { Channel } from "@finos/fdc3";
-import { ChannelFactory } from "./ChannelFactory";
+import { ChannelHandler } from "./ChannelHandler";
 import { ComposeUIPrivateChannel } from "./ComposeUIPrivateChannel";
 import { Fdc3CreatePrivateChannelRequest } from "./messages/Fdc3CreatePrivateChannelRequest";
 import { Fdc3CreatePrivateChannelResponse } from "./messages/Fdc3CreatePrivateChannelResponse";
@@ -38,14 +38,26 @@ import { Fdc3JoinUserChannelResponse } from "./messages/Fdc3JoinUserChannelRespo
 import { ChannelItem } from "./ChannelItem";
 import { ComposeUIContextListener } from "./ComposeUIContextListener";
 
-export class MessagingChannelFactory implements ChannelFactory {
+export class MessagingChannelHandler implements ChannelHandler {
     private jsonMessaging: JsonMessaging;
     private fdc3instanceId: string;
+    private channelSelector: AsyncDisposable | undefined = undefined;
 
     constructor(jsonMessaging: JsonMessaging,fdc3instanceId: string) {
         this.jsonMessaging = jsonMessaging;
         this.fdc3instanceId = fdc3instanceId;
     }
+    
+    [Symbol.asyncDispose](): PromiseLike<void> {
+        return this.channelSelector 
+            ? this.channelSelector[Symbol.asyncDispose]() 
+            : Promise.resolve();
+    }
+
+    public async configureChannelSelectorFromUI(): Promise<void> {
+        this.channelSelector = await this.jsonMessaging.registerService(ComposeUITopic.channelSelectorFromUI(this.fdc3instanceId), this.selectUserChannelFromUIHandler);
+        console.debug("Configured channel selector for module: ", this.fdc3instanceId);
+    }
 
     public async getChannel(channelId: string, channelType: ChannelType): Promise<Channel> {
         const topic = ComposeUITopic.findChannel();
@@ -117,24 +129,43 @@ export class MessagingChannelFactory implements ChannelFactory {
     }
 
     public async joinUserChannel(channelId: string): Promise<Channel> {
-        const topic: string = ComposeUITopic.joinUserChannel();
-        const request: Fdc3JoinUserChannelRequest = new Fdc3JoinUserChannelRequest(channelId, this.fdc3instanceId);
-        const response = await this.jsonMessaging.invokeJsonService<Fdc3JoinUserChannelRequest, Fdc3JoinUserChannelResponse>(topic, request);
+        try {
+            const topic: string = ComposeUITopic.joinUserChannel();
+            const request: Fdc3JoinUserChannelRequest = new Fdc3JoinUserChannelRequest(channelId, this.fdc3instanceId);
+            const response = await this.jsonMessaging.invokeJsonService<Fdc3JoinUserChannelRequest, Fdc3JoinUserChannelResponse>(topic, request);
 
-        if (!response) {
-            throw new Error(ChannelError.CreationFailed);
-        }
+            console.debug("Received joinUserChannel response: ", response);
 
-        if (response.error) {
-            throw new Error(response.error);
-        }
+            if (!response) {
+                throw new Error(ChannelError.CreationFailed);
+            }
 
-        if (!response.success) {
-            throw new Error(ChannelError.CreationFailed);
+            if (response.error) {
+                throw new Error(response.error);
+            }
+
+            if (!response.success) {
+                throw new Error(ChannelError.CreationFailed);
+            }
+
+            var channel = new ComposeUIChannel(channelId, "user", this.jsonMessaging, response.displayMetadata);
+
+            this.triggerChannelJoinedEvent(channel.id);
+
+            return channel;
+        } catch (error) {
+            console.error("Error joining user channel: ", error);
+            throw error;
         }
+    }
 
-        var channel = new ComposeUIChannel(channelId, "user", this.jsonMessaging, response.displayMetadata);
-        return channel;
+    private async triggerChannelJoinedEvent(id: string | undefined) : Promise<void> {
+        try {
+            var result = await this.jsonMessaging.invokeService(ComposeUITopic.channelSelectorFromAPI(this.fdc3instanceId), id);
+            console.debug("Triggered channel selector of container: ", this.fdc3instanceId, ", with: ", id, ", and got result:", result);
+        } catch (error) {
+            console.error("Error triggering channel joined event for module: ", this.fdc3instanceId, ", with channel id: ", id, ", error: ", error);
+        }
     }
 
     public async getUserChannels(): Promise<Channel[]> {
@@ -193,4 +224,36 @@ export class MessagingChannelFactory implements ChannelFactory {
         const listener = new ComposeUIContextListener(openHandled, this.jsonMessaging, handler!, contextType ?? undefined);
         return listener;
     }
+
+    public async leaveCurrentChannel(): Promise<void> {
+        await this.triggerChannelJoinedEvent(undefined);
+    }
+
+    private async selectUserChannelFromUIHandler(request?: string | null | undefined): Promise<string | null> {
+        try {
+            if (!request) {
+                console.debug("Empty request received when the user channel selection was requested from UI.");
+                return null;
+            }
+
+            var objectRequest = JSON.parse(request);
+            var joinUserChannelRequest = objectRequest as Fdc3JoinUserChannelRequest;
+            console.debug("Parsed the request from the UI when user selected a user channel to join: ", joinUserChannelRequest);
+            
+            if (!joinUserChannelRequest || !joinUserChannelRequest.channelId) {
+                console.debug("Invalid request received when user selected a user channel to join to from the UI: ", request);
+                return null;
+            }
+
+            //We should join the channel requested by the user from the UI. -> this will trigger the handler of the module/container to show which channel the app is joined to.
+            await window.fdc3.joinUserChannel(joinUserChannelRequest.channelId);
+
+            return joinUserChannelRequest.channelId;
+
+        } catch (error) {
+            console.error("Error processing request when channel selector was invoked: ", request, ", error: ", error);
+            return null;
+        }
+    }
 }
+

package/src/infrastructure/MessagingIntentsClient.ts

@@ -13,7 +13,7 @@
 
 import { AppIdentifier, AppIntent, AppMetadata, Context, IntentResolution } from "@finos/fdc3";
 import { JsonMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
-import { ChannelFactory } from "./ChannelFactory";
+import { ChannelHandler } from "./ChannelHandler";
 import { ComposeUIErrors } from "./ComposeUIErrors";
 import { ComposeUIIntentResolution } from "./ComposeUIIntentResolution";
 import { ComposeUITopic } from "./ComposeUITopic";
@@ -27,15 +27,15 @@ import { Fdc3RaiseIntentResponse } from "./messages/Fdc3RaiseIntentResponse";
 import { Fdc3RaiseIntentForContextRequest } from "./messages/Fdc3RaiseIntentForContextRequest";
 
 export class MessagingIntentsClient implements IntentsClient {
-    private channelFactory: ChannelFactory;
+    private channelHandler: ChannelHandler;
     private jsonMessaging: JsonMessaging;
 
-    constructor( jsonMessaging: JsonMessaging, channelFactory: ChannelFactory, ) {
+    constructor( jsonMessaging: JsonMessaging, channelFactory: ChannelHandler, ) {
         if (!window.composeui.fdc3.config || !window.composeui.fdc3.config.instanceId) {
             throw new Error(ComposeUIErrors.InstanceIdNotFound);
         }
 
-        this.channelFactory = channelFactory;
+        this.channelHandler = channelFactory;
         this.jsonMessaging = jsonMessaging;
     }
 
@@ -69,7 +69,7 @@ export class MessagingIntentsClient implements IntentsClient {
     }
 
     public async getIntentResolution(messageId: string, intent: string, source: AppMetadata): Promise<IntentResolution> {
-        return new ComposeUIIntentResolution(messageId, this.jsonMessaging, this.channelFactory, intent, source);
+        return new ComposeUIIntentResolution(messageId, this.jsonMessaging, this.channelHandler, intent, source);
     }
 
     public async raiseIntent(intent: string, context: Context, app?: string | AppIdentifier): Promise<IntentResolution> {
@@ -88,7 +88,7 @@ export class MessagingIntentsClient implements IntentsClient {
             throw new Error(response.error);
         }
 
-        const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelFactory, response.intent!, response.appMetadata!);
+        const intentResolution = new ComposeUIIntentResolution(response.messageId, this.jsonMessaging, this.channelHandler, response.intent!, response.appMetadata!);
         return intentResolution;
     }
 
@@ -113,7 +113,7 @@ export class MessagingIntentsClient implements IntentsClient {
             throw new Error(response.error);
         }
         
-        const intentResolution = new ComposeUIIntentResolution(response.messageId!, this.jsonMessaging, this.channelFactory, response.intent!, response.appMetadata!);
+        const intentResolution = new ComposeUIIntentResolution(response.messageId!, this.jsonMessaging, this.channelHandler, response.intent!, response.appMetadata!);
         return intentResolution;
     }
 }