@interopio/workspaces-api 3.0.1

package/src/communication/bridge.ts

@@ -0,0 +1,264 @@
+import { CallbackRegistry, UnsubscribeFunction } from "callback-registry";
+import { SubscriptionConfig, ActiveSubscription, WorkspaceEventType, WorkspaceEventAction, WorkspacePayload, WorkspaceEventScope, PendingSubscription } from "../types/subscription";
+import { ClientOperations, CLIENT_OPERATIONS, STREAMS } from "./constants";
+import { OPERATIONS } from "./constants";
+import { eventTypeDecoder, streamRequestArgumentsDecoder, workspaceEventActionDecoder } from "../shared/decoders";
+import { IOConnectWorkspaces } from "../../workspaces";
+import { InteropTransport } from "./interop-transport";
+import { PromiseWrapper } from "../shared/promiseWrapper";
+import { Instance } from "../types/glue";
+
+export class Bridge {
+
+    private readonly activeSubscriptions: ActiveSubscription[] = [];
+    private readonly pendingSubScriptions: PendingSubscription[] = [];
+
+    constructor(
+        private readonly transport: InteropTransport,
+        private readonly registry: CallbackRegistry
+    ) { }
+
+    public async createCoreEventSubscription(): Promise<void> {
+        await this.transport.coreSubscriptionReady(this.handleCoreEvent.bind(this));
+    }
+
+    public handleCoreSubscription(config: SubscriptionConfig): UnsubscribeFunction {
+        const registryKey = `${config.eventType}-${config.action}`;
+        const scope = config.scope;
+        const scopeId = config.scopeId;
+
+        return this.registry.add(registryKey, (args) => {
+            const scopeConfig = {
+                type: scope,
+                id: scopeId
+            };
+
+            const receivedIds = {
+                frame: args.frameSummary?.id || args.windowSummary?.config.frameId,
+                workspace: args.workspaceSummary?.id || args.windowSummary?.config.workspaceId,
+                container: args.containerSummary?.itemId,
+                window: args.windowSummary?.itemId
+            };
+
+            const shouldInvokeCallback = this.checkScopeMatch(scopeConfig, receivedIds);
+
+            if (!shouldInvokeCallback) {
+                return;
+            }
+
+            config.callback(args);
+        });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public async send<T>(operationName: string, operationArgs?: any): Promise<T> {
+
+        const operationDefinition = Object.values(OPERATIONS).find((operation) => operation.name === operationName);
+
+        if (!operationDefinition) {
+            throw new Error(`Cannot find definition for operation name: ${operationName}`);
+        }
+
+        if (operationDefinition.argsDecoder) {
+            try {
+                operationDefinition.argsDecoder.runWithException(operationArgs);
+            } catch (error) {
+                throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
+            }
+        }
+
+        try {
+            const operationResult = await this.transport.transmitControl(operationDefinition.name, operationArgs);
+
+            operationDefinition.resultDecoder.runWithException(operationResult);
+
+            return operationResult;
+        } catch (error) {
+            if (error.kind) {
+                throw new Error(`Unexpected internal incoming validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
+            }
+            throw new Error(error.message);
+        }
+    }
+
+    public async subscribe(config: SubscriptionConfig): Promise<IOConnectWorkspaces.Unsubscribe> {
+        const pendingSub = this.getPendingSubscription(config);
+        if (pendingSub) {
+            await pendingSub.promise;
+        }
+
+        let activeSub = this.getActiveSubscription(config);
+        const registryKey = this.getRegistryKey(config);
+
+        if (!activeSub) {
+            const pendingPromise = new PromiseWrapper<void>();
+            const pendingSubscription = {
+                streamType: config.eventType,
+                level: config.scope,
+                levelId: config.scopeId,
+                promise: pendingPromise.promise
+            };
+            this.pendingSubScriptions.push(pendingSubscription);
+            try {
+                const stream = STREAMS[config.eventType];
+                const gdSub = await this.transport.subscribe(stream.name, this.getBranchKey(config), config.eventType);
+
+                gdSub.onData((streamData) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const data = streamData.data as { action: string; payload: any };
+
+                    // important to decode without exception, because we do not want to throw an exception here
+                    const requestedArgumentsResult = streamRequestArgumentsDecoder.run(streamData.requestArguments);
+                    const actionResult = workspaceEventActionDecoder.run(data.action);
+
+                    if (!requestedArgumentsResult.ok || !actionResult.ok) {
+                        return;
+                    }
+
+                    const streamType = requestedArgumentsResult.result.type;
+                    const branch = requestedArgumentsResult.result.branch;
+
+                    const keyToExecute = `${streamType}-${branch}-${actionResult.result}`;
+                    const validatedPayload = STREAMS[streamType].payloadDecoder.run(data.payload);
+                    if (!validatedPayload.ok) {
+                        return;
+                    }
+
+                    this.registry.execute(keyToExecute, validatedPayload.result);
+                });
+
+                activeSub = {
+                    streamType: config.eventType,
+                    level: config.scope,
+                    levelId: config.scopeId,
+                    callbacksCount: 0,
+                    gdSub
+                };
+
+                this.activeSubscriptions.push(activeSub);
+
+                pendingPromise.resolve();
+            } catch (error) {
+                pendingPromise.reject(error);
+
+                throw error;
+            } finally {
+                this.removePendingSubscription(pendingSubscription);
+            }
+
+        }
+
+        const unsubscribe = this.registry.add(registryKey, config.callback);
+
+        ++activeSub.callbacksCount;
+
+        return (): void => {
+            unsubscribe();
+
+            --activeSub.callbacksCount;
+
+            if (activeSub.callbacksCount === 0) {
+                activeSub.gdSub.close();
+                this.activeSubscriptions.splice(this.activeSubscriptions.indexOf(activeSub), 1);
+            }
+        };
+    }
+
+    public onOperation(callback: (operation: ClientOperations, caller: Instance) => void) {
+
+        const wrappedCallback = (payload: ClientOperations, caller: Instance) => {
+            const operationName = payload.operation;
+            const operationArgs = payload.data;
+            const operationDefinition = Object.values(CLIENT_OPERATIONS).find((operation) => operation.name === operationName);
+
+            if (!operationDefinition) {
+                throw new Error(`Cannot find definition for operation name: ${operationName}`);
+            }
+
+            if (operationDefinition.argsDecoder) {
+                try {
+                    operationDefinition.argsDecoder.runWithException(operationArgs);
+                } catch (error) {
+                    throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
+                }
+            }
+
+            callback(payload, caller);
+        };
+
+        return this.transport.onInternalMethodInvoked("control", wrappedCallback);
+    }
+
+    private checkScopeMatch(scope: { type: WorkspaceEventScope; id?: string }, receivedIds: { frame: string; workspace: string; container: string; window: string }): boolean {
+
+        if (scope.type === "global") {
+            return true;
+        }
+
+        if (scope.type === "frame" && scope.id === receivedIds.frame) {
+            return true;
+        }
+
+        if (scope.type === "workspace" && scope.id === receivedIds.workspace) {
+            return true;
+        }
+
+        if (scope.type === "container" && scope.id === receivedIds.container) {
+            return true;
+        }
+
+        if (scope.type === "window" && scope.id === receivedIds.window) {
+            return true;
+        }
+
+        return false;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private handleCoreEvent(args: any): void {
+        const data = args.data;
+        try {
+            const verifiedAction: WorkspaceEventAction = workspaceEventActionDecoder.runWithException(data.action);
+            const verifiedType: WorkspaceEventType = eventTypeDecoder.runWithException(data.type);
+            const verifiedPayload: WorkspacePayload = STREAMS[verifiedType].payloadDecoder.runWithException(data.payload);
+
+            const registryKey = `${verifiedType}-${verifiedAction}`;
+
+            this.registry.execute(registryKey, verifiedPayload);
+        } catch (error) {
+            console.warn(`Cannot handle event with data ${JSON.stringify(data)}, because of validation error: ${error.message}`);
+        }
+    }
+
+    private getBranchKey(config: SubscriptionConfig): string {
+        return config.scope === "global" ? config.scope : `${config.scope}_${config.scopeId}`;
+    }
+
+    private getRegistryKey(config: SubscriptionConfig): string {
+        return `${config.eventType}-${this.getBranchKey(config)}-${config.action}`;
+    }
+
+    private getActiveSubscription(config: SubscriptionConfig): ActiveSubscription {
+        return this.activeSubscriptions
+            .find((activeSub) => activeSub.streamType === config.eventType &&
+                activeSub.level === config.scope &&
+                activeSub.levelId === config.scopeId
+            );
+    }
+
+    private getPendingSubscription(config: SubscriptionConfig): PendingSubscription {
+        return this.pendingSubScriptions
+            .find((activeSub) => activeSub.streamType === config.eventType &&
+                activeSub.level === config.scope &&
+                activeSub.levelId === config.scopeId
+            );
+    }
+
+    private removePendingSubscription(pendingSubscription: PendingSubscription): void {
+        const index = this.pendingSubScriptions.indexOf(pendingSubscription);
+
+        if (index >= 0) {
+            this.pendingSubScriptions.splice(index, 1);
+        }
+    }
+}

package/src/communication/constants.ts

@@ -0,0 +1,202 @@
+import {
+    isWindowInSwimlaneResultDecoder,
+    frameSummaryDecoder,
+    workspaceSnapshotResultDecoder,
+    frameSummariesResultDecoder,
+    workspaceCreateConfigDecoder,
+    getFrameSummaryConfigDecoder,
+    layoutSummariesDecoder,
+    openWorkspaceConfigDecoder,
+    workspaceSummariesResultDecoder,
+    voidResultDecoder,
+    exportedLayoutsResultDecoder,
+    workspaceLayoutDecoder,
+    deleteLayoutConfigDecoder,
+    simpleItemConfigDecoder,
+    resizeItemConfigDecoder,
+    moveFrameConfigDecoder,
+    frameSnapshotResultDecoder,
+    simpleWindowOperationSuccessResultDecoder,
+    setItemTitleConfigDecoder,
+    moveWindowConfigDecoder,
+    addWindowConfigDecoder,
+    addContainerConfigDecoder,
+    addItemResultDecoder,
+    bundleWorkspaceConfigDecoder,
+    workspaceStreamDataDecoder,
+    frameStreamDataDecoder,
+    containerStreamDataDecoder,
+    windowStreamDataDecoder,
+    workspaceLayoutSaveConfigDecoder,
+    pingResultDecoder,
+    frameStateConfigDecoder,
+    frameStateResultDecoder,
+    workspacesImportLayoutDecoder,
+    workspaceSelectorDecoder,
+    lockWorkspaceDecoder,
+    lockWindowDecoder,
+    lockContainerDecoder,
+    frameBoundsResultDecoder,
+    getWorkspaceIconResultDecoder,
+    pinWorkspaceDecoder,
+    setWorkspaceIconDecoder,
+    frameSummaryResultDecoder,
+    emptyFrameDefinitionDecoder,
+    frameInitProtocolConfigDecoder,
+    shortcutClickedDataDecoder,
+    shortcutConfigDecoder,
+    frameSnapshotConfigDecoder,
+    setMaximizationBoundaryConfigDecoder,
+    loadingAnimationConfigDecoder,
+    getPlatformFrameIdResultDecoder,
+    workspacesImportLayoutsDecoder,
+    bundleItemConfigDecoder,
+    operationCheckConfigDecoder,
+    operationCheckResultDecoder
+} from "../shared/decoders";
+import { ControlOperation, StreamOperation } from "../types/protocol";
+import { WorkspaceEventType } from "../types/subscription";
+
+type OperationsTypes = "isWindowInWorkspace" |
+    "createWorkspace" |
+    "getAllFramesSummaries" |
+    "getFrameSummary" |
+    "getAllWorkspacesSummaries" |
+    "getWorkspaceSnapshot" |
+    "getAllLayoutsSummaries" |
+    "openWorkspace" |
+    "deleteLayout" |
+    "saveLayout" |
+    "importLayout" |
+    "importLayouts" |
+    "exportAllLayouts" |
+    "restoreItem" |
+    "maximizeItem" |
+    "focusItem" |
+    "closeItem" |
+    "resizeItem" |
+    "setMaximizationBoundary" |
+    "moveFrame" |
+    "getFrameSnapshot" |
+    "forceLoadWindow" |
+    "ejectWindow" |
+    "setItemTitle" |
+    "moveWindowTo" |
+    "addWindow" |
+    "addContainer" |
+    "bundleWorkspace" |
+    "bundleItem" |
+    "ping" |
+    "changeFrameState" |
+    "getFrameState" |
+    "getFrameBounds" |
+    "hibernateWorkspace" |
+    "resumeWorkspace" |
+    "lockWorkspace" |
+    "lockWindow" |
+    "lockContainer" |
+    "pinWorkspace" |
+    "unpinWorkspace" |
+    "getWorkspaceIcon" |
+    "setWorkspaceIcon" |
+    "createFrame" |
+    "registerShortcut" |
+    "unregisterShortcut" |
+    "initFrame" |
+    "showLoadingAnimation" |
+    "hideLoadingAnimation" |
+    "getPlatformFrameId" |
+    "operationCheck";
+type OutgoingMethodTypes = "control" | "frameStream" | "workspaceStream" | "containerStream" | "windowStream";
+export type IncomingMethodTypes = "control";
+
+export const webPlatformMethodName = "T42.Web.Platform.Control";
+export const webPlatformWspStreamName = "T42.Web.Platform.WSP.Stream";
+
+export const OUTGOING_METHODS: { [key in OutgoingMethodTypes]: { name: string; isStream: boolean } } = {
+    control: { name: "T42.Workspaces.Control", isStream: false },
+    frameStream: { name: "T42.Workspaces.Stream.Frame", isStream: true },
+    workspaceStream: { name: "T42.Workspaces.Stream.Workspace", isStream: true },
+    containerStream: { name: "T42.Workspaces.Stream.Container", isStream: true },
+    windowStream: { name: "T42.Workspaces.Stream.Window", isStream: true }
+};
+
+export const INCOMING_METHODS: { [key in IncomingMethodTypes]: { name: string; isStream: boolean } } = {
+    control: { name: "T42.Workspaces.Client.Control", isStream: false },
+};
+
+export const STREAMS: { [key in WorkspaceEventType]: StreamOperation } = {
+    frame: { name: "T42.Workspaces.Stream.Frame", payloadDecoder: frameStreamDataDecoder },
+    workspace: { name: "T42.Workspaces.Stream.Workspace", payloadDecoder: workspaceStreamDataDecoder },
+    container: { name: "T42.Workspaces.Stream.Container", payloadDecoder: containerStreamDataDecoder },
+    window: { name: "T42.Workspaces.Stream.Window", payloadDecoder: windowStreamDataDecoder }
+};
+
+interface ShortcutClicked {
+    operation: "shortcutClicked",
+    data: {
+        shortcut: string;
+        frameId: string;
+    }
+}
+
+export type ClientOperations = ShortcutClicked;
+
+export type OnOperationsTypes = "shortcutClicked";
+
+export const CLIENT_OPERATIONS: { [key in OnOperationsTypes]: ControlOperation } = {
+    shortcutClicked: { name: "shortcutClicked", argsDecoder: shortcutClickedDataDecoder, resultDecoder: voidResultDecoder },
+};
+
+export const OPERATIONS: { [key in OperationsTypes]: ControlOperation } = {
+    ping: { name: "ping", resultDecoder: pingResultDecoder },
+    isWindowInWorkspace: { name: "isWindowInWorkspace", argsDecoder: simpleItemConfigDecoder, resultDecoder: isWindowInSwimlaneResultDecoder },
+    createWorkspace: { name: "createWorkspace", resultDecoder: workspaceSnapshotResultDecoder, argsDecoder: workspaceCreateConfigDecoder },
+    createFrame: { name: "createFrame", resultDecoder: frameSummaryResultDecoder, argsDecoder: emptyFrameDefinitionDecoder },
+    initFrame: { name: "initFrame", resultDecoder: voidResultDecoder, argsDecoder: frameInitProtocolConfigDecoder },
+    getAllFramesSummaries: { name: "getAllFramesSummaries", resultDecoder: frameSummariesResultDecoder },
+    getFrameSummary: { name: "getFrameSummary", resultDecoder: frameSummaryDecoder, argsDecoder: getFrameSummaryConfigDecoder },
+    getAllWorkspacesSummaries: { name: "getAllWorkspacesSummaries", resultDecoder: workspaceSummariesResultDecoder },
+    getWorkspaceSnapshot: { name: "getWorkspaceSnapshot", resultDecoder: workspaceSnapshotResultDecoder, argsDecoder: simpleItemConfigDecoder },
+    getAllLayoutsSummaries: { name: "getAllLayoutsSummaries", resultDecoder: layoutSummariesDecoder },
+    openWorkspace: { name: "openWorkspace", argsDecoder: openWorkspaceConfigDecoder, resultDecoder: workspaceSnapshotResultDecoder },
+    deleteLayout: { name: "deleteLayout", resultDecoder: voidResultDecoder, argsDecoder: deleteLayoutConfigDecoder },
+    saveLayout: { name: "saveLayout", resultDecoder: workspaceLayoutDecoder, argsDecoder: workspaceLayoutSaveConfigDecoder },
+    importLayout: { name: "importLayout", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutDecoder },
+    importLayouts: { name: "importLayouts", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutsDecoder },
+    exportAllLayouts: { name: "exportAllLayouts", resultDecoder: exportedLayoutsResultDecoder },
+    restoreItem: { name: "restoreItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
+    maximizeItem: { name: "maximizeItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
+    focusItem: { name: "focusItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
+    closeItem: { name: "closeItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
+    resizeItem: { name: "resizeItem", argsDecoder: resizeItemConfigDecoder, resultDecoder: voidResultDecoder },
+    setMaximizationBoundary: { name: "setMaximizationBoundary", argsDecoder: setMaximizationBoundaryConfigDecoder, resultDecoder: voidResultDecoder },
+    changeFrameState: { name: "changeFrameState", argsDecoder: frameStateConfigDecoder, resultDecoder: voidResultDecoder },
+    getFrameState: { name: "getFrameState", argsDecoder: simpleItemConfigDecoder, resultDecoder: frameStateResultDecoder },
+    getFrameBounds: { name: "getFrameBounds", argsDecoder: simpleItemConfigDecoder, resultDecoder: frameBoundsResultDecoder },
+    moveFrame: { name: "moveFrame", argsDecoder: moveFrameConfigDecoder, resultDecoder: voidResultDecoder },
+    getFrameSnapshot: { name: "getFrameSnapshot", argsDecoder: frameSnapshotConfigDecoder, resultDecoder: frameSnapshotResultDecoder },
+    forceLoadWindow: { name: "forceLoadWindow", argsDecoder: simpleItemConfigDecoder, resultDecoder: simpleWindowOperationSuccessResultDecoder },
+    ejectWindow: { name: "ejectWindow", argsDecoder: simpleItemConfigDecoder, resultDecoder: simpleWindowOperationSuccessResultDecoder },
+    setItemTitle: { name: "setItemTitle", argsDecoder: setItemTitleConfigDecoder, resultDecoder: voidResultDecoder },
+    moveWindowTo: { name: "moveWindowTo", argsDecoder: moveWindowConfigDecoder, resultDecoder: voidResultDecoder },
+    addWindow: { name: "addWindow", argsDecoder: addWindowConfigDecoder, resultDecoder: addItemResultDecoder },
+    addContainer: { name: "addContainer", argsDecoder: addContainerConfigDecoder, resultDecoder: addItemResultDecoder },
+    bundleWorkspace: { name: "bundleWorkspace", argsDecoder: bundleWorkspaceConfigDecoder, resultDecoder: voidResultDecoder },
+    bundleItem: { name: "bundleItem", argsDecoder: bundleItemConfigDecoder, resultDecoder: voidResultDecoder },
+    hibernateWorkspace: { name: "hibernateWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
+    resumeWorkspace: { name: "resumeWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
+    lockWorkspace: { name: "lockWorkspace", argsDecoder: lockWorkspaceDecoder, resultDecoder: voidResultDecoder },
+    lockWindow: { name: "lockWindow", argsDecoder: lockWindowDecoder, resultDecoder: voidResultDecoder },
+    lockContainer: { name: "lockContainer", argsDecoder: lockContainerDecoder, resultDecoder: voidResultDecoder },
+    pinWorkspace: { name: "pinWorkspace", argsDecoder: pinWorkspaceDecoder, resultDecoder: voidResultDecoder },
+    unpinWorkspace: { name: "unpinWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
+    getWorkspaceIcon: { name: "getWorkspaceIcon", argsDecoder: workspaceSelectorDecoder, resultDecoder: getWorkspaceIconResultDecoder },
+    setWorkspaceIcon: { name: "setWorkspaceIcon", argsDecoder: setWorkspaceIconDecoder, resultDecoder: voidResultDecoder },
+    registerShortcut: { name: "registerShortcut", argsDecoder: shortcutConfigDecoder, resultDecoder: voidResultDecoder },
+    unregisterShortcut: { name: "unregisterShortcut", argsDecoder: shortcutConfigDecoder, resultDecoder: voidResultDecoder },
+    showLoadingAnimation: { name: "showLoadingAnimation", argsDecoder: loadingAnimationConfigDecoder, resultDecoder: voidResultDecoder },
+    hideLoadingAnimation: { name: "hideLoadingAnimation", argsDecoder: loadingAnimationConfigDecoder, resultDecoder: voidResultDecoder },
+    getPlatformFrameId: { name: "getPlatformFrameId", resultDecoder: getPlatformFrameIdResultDecoder },
+    operationCheck: { name: "operationCheck", argsDecoder: operationCheckConfigDecoder, resultDecoder: operationCheckResultDecoder },
+};

package/src/communication/interop-transport.ts

@@ -0,0 +1,175 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ClientOperations, IncomingMethodTypes, INCOMING_METHODS, OUTGOING_METHODS, webPlatformMethodName, webPlatformWspStreamName } from "./constants";
+import { promisePlus } from "../shared/promisePlus";
+import { WorkspaceEventType } from "../types/subscription";
+import { InteropAPI, Subscription, InvocationResult, Instance } from "../types/glue";
+import { CallbackRegistry } from "callback-registry";
+
+export class InteropTransport {
+
+    private readonly defaultTransportTimeout: number = 30000;
+    private coreEventMethodInitiated = false;
+    private corePlatformSubPromise: Promise<Subscription>;
+
+    constructor(private readonly agm: InteropAPI,
+        private readonly registry: CallbackRegistry) { }
+
+    public async initiate(actualWindowId: string): Promise<void> {
+
+        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
+
+        if (desktopGlobal) {
+            await Promise.all(
+                Object.values(OUTGOING_METHODS).map((method) => {
+                    return this.verifyMethodLive(method.name);
+                })
+            );
+
+            await Promise.all(
+                Object.keys(INCOMING_METHODS).map((method: IncomingMethodTypes) => {
+                    return this.registerMethod(method);
+                })
+            );
+
+            return;
+        }
+
+        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
+
+        const systemId = browserGlobal.communicationId;
+
+        await Promise.all([
+            this.verifyMethodLive(webPlatformMethodName, systemId),
+            this.verifyMethodLive(webPlatformWspStreamName, systemId)
+        ]);
+
+        await this.transmitControl("frameHello", { windowId: actualWindowId });
+    }
+
+    public coreSubscriptionReady(eventCallback: (args?: any) => void): Promise<Subscription> {
+        if (!this.coreEventMethodInitiated) {
+            this.subscribePlatform(eventCallback);
+        }
+        return this.corePlatformSubPromise;
+    }
+
+    public subscribePlatform(eventCallback: (args?: any) => void): void {
+        this.coreEventMethodInitiated = true;
+
+        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
+
+        const systemId = browserGlobal.communicationId;
+
+        this.corePlatformSubPromise = this.agm.subscribe(webPlatformWspStreamName, systemId ? { target: { instance: systemId } } : undefined);
+
+        this.corePlatformSubPromise
+            .then((sub) => {
+                sub.onData((data) => eventCallback(data.data));
+            });
+    }
+
+    public async subscribe(streamName: string, streamBranch: string, streamType: WorkspaceEventType): Promise<Subscription> {
+
+        const subscriptionArgs = {
+            branch: streamBranch,
+            type: streamType
+        };
+
+        let subscription: Subscription;
+
+        try {
+            subscription = await this.agm.subscribe(streamName, { arguments: subscriptionArgs });
+        } catch (error) {
+            const message = `Internal subscription error! Error details: stream - ${streamName}, branch: ${streamBranch}. Internal message: ${error.message}`;
+            throw new Error(message);
+        }
+
+        return subscription;
+    }
+
+    public async transmitControl(operation: string, operationArguments: any): Promise<any> {
+
+        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
+        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
+        
+        const invocationArguments = desktopGlobal ? { operation, operationArguments } : { operation, domain: "workspaces", data: operationArguments };
+        const methodName = desktopGlobal ? OUTGOING_METHODS.control.name : webPlatformMethodName;
+
+        const platformTarget = desktopGlobal ? undefined : browserGlobal.communicationId;
+
+        let invocationResult: InvocationResult<any>;
+        const baseErrorMessage = `Internal Workspaces Communication Error. Attempted operation: ${JSON.stringify(invocationArguments)}. `;
+
+        // using the 0 index of the errors and values collections, because we expect only one server and
+        // this is to safeguard in case in future we decide to deprecate the default returned/message properties in favor of using only collections
+        try {
+            invocationResult = await this.agm.invoke(methodName, invocationArguments, platformTarget ? { instance: platformTarget } : "best", { methodResponseTimeoutMs: this.defaultTransportTimeout });
+
+            if (!invocationResult) {
+                throw new Error("Received unsupported result from GD - empty result");
+            }
+
+            if (!Array.isArray(invocationResult.all_return_values) || invocationResult.all_return_values.length === 0) {
+                throw new Error("Received unsupported result from GD - empty values collection");
+            }
+
+        } catch (error) {
+            if (error && error.all_errors && error.all_errors.length) {
+                // IMPORTANT: Do NOT change the `Inner message:` string, because it is used by other programs to extract the inner message of a communication error
+                const invocationErrorMessage = error.all_errors[0].message;
+                throw new Error(`${baseErrorMessage} -> Inner message: ${invocationErrorMessage}`);
+
+            }
+            // IMPORTANT: Do NOT change the `Inner message:` string, because it is used by other programs to extract the inner message of a communication error
+            throw new Error(`${baseErrorMessage} -> Inner message: ${error.message}`);
+        }
+
+        return invocationResult.all_return_values[0].returned;
+    }
+
+    public onInternalMethodInvoked(key: IncomingMethodTypes, callback: (operation: ClientOperations, caller: Instance) => void) {
+        return this.registry.add(key, callback);
+    }
+
+    private verifyMethodLive(name: string, systemId?: string): Promise<void> {
+        return promisePlus(() => {
+            return new Promise((resolve) => {
+                const hasMethod = this.agm.methods().some((method) => {
+                    const nameMatch = method.name === name;
+    
+                    const serverMatch = systemId ?
+                        method.getServers().some((server) => server.instance === systemId) :
+                        true;
+    
+                    return nameMatch && serverMatch;
+                });
+
+                if (hasMethod) {
+                    resolve();
+                    return;
+                }
+
+                const unSub = this.agm.serverMethodAdded((data) => {
+                    const method = data.method;
+                    const server = data.server;
+    
+                    const serverMatch = systemId ?
+                        server.instance === systemId :
+                        true;
+    
+                    if (method.name === name && serverMatch) {
+                        unSub();
+                        resolve();
+                    }
+                });
+            });
+        }, 15000, "Timeout waiting for the Workspaces communication channels");
+    }
+
+    private registerMethod(key: IncomingMethodTypes) {
+        const method = INCOMING_METHODS[key];
+        return this.agm.register(method.name, (args, caller) => {
+            this.registry.execute(key, args, caller);
+        });
+    }
+}