@nsshunt/stsappframework 3.1.160 → 3.1.161

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nsshunt/stsappframework",
-  "version": "3.1.160",
+  "version": "3.1.161",
   "description": "",
   "main": "dist/index.js",
   "types": "./types/index.d.ts",

package/src/testertesting/app.ts

@@ -0,0 +1,238 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import cluster from 'cluster';
+import { Worker, MessageChannel } from 'worker_threads';
+
+import { IWorkerFactory, IWorkerOptions, IPrimaryWorker, IRunnerOptions } from './stsTestWorkerDefinitions'
+
+import { WorkerPrimaryTestRunner01 } from './workerPrimaryTestRunner01'
+import { STSWorkerManager } from './workerManager';
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+import { IContextBase, AgentInstrumentController, IPublishInstrumentControllerOptions, Gauge, GaugeTypes, 
+    InstrumentDefinitions, InstrumentLogOptions, InstrumentGaugeOptions, PublishTransportRESTServer, 
+    TransportType, IPublishTransportRESTServerOptions } from '@nsshunt/stsobservability'
+
+import { ModelDelimeter, type ISTSLogger, defaultLogger } from '@nsshunt/stsutils'
+
+import { v4 as uuidv4 } from 'uuid';
+
+import { goptions } from '@nsshunt/stsconfig'
+
+declare  interface IAsyncRunnerContext extends IContextBase {
+    id: string;
+    hostName: string;
+    agentName: string;
+    threadId: string;
+    asyncRunnerId: number;
+}
+
+const LogInfoMessage = (message: any) => console.log(chalk.grey(message))
+const LogErrorMessage = (message: any) => console.error(chalk.red(message))
+
+if (cluster.isPrimary) {
+
+    //new MasterProcessBase(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
+
+    LogInfoMessage(`Primary ${process.pid} is running`);
+  
+    // Fork workers.
+    cluster.fork();
+  
+    cluster.on('exit', (worker, code, signal) => {
+        LogInfoMessage(`worker ${worker.process.pid} died`);
+    });
+
+
+    /*
+    const fileName ='./dist/webworkertesting/worker.js';
+    
+    const publishCollectorWebWorker = new Worker(fileName);
+    publishCollectorWebWorker.unref();
+
+    publishCollectorWebWorker.postMessage({cmd: 'text', message: 'Hello World'});
+
+    publishCollectorWebWorker.on('message', (data) => {
+        LogInfoMessage(`cluster.primary (${process.pid}): message from worker = [${JSON.stringify(data)}]`);
+    });
+
+    const { port1, port2 } = new MessageChannel();
+
+    publishCollectorWebWorker.postMessage({cmd: 'portmessage', port: port2}, [ port2 ]);
+    port1.postMessage('sending to port1');
+    port1.on('message', (data) => {
+        LogInfoMessage(`cluster.primary (${process.pid}): message from message port = [${data}]`);
+    });
+    */
+
+    LogInfoMessage(`cluster primary completed ...`);
+
+
+} else {
+
+
+    LogInfoMessage(`Worker ${process.pid} started`);
+
+    //const worker = new WorkerProcessBase(ServiceConfigOptions(true, cluster.isPrimary));
+    //worker.SetupServer();
+
+    const hostName = 'host01';
+    const agentId = 'agent01';
+    const userAgent = 'userAgent01'
+
+    const asyncRunnerContext: IAsyncRunnerContext = {
+        nid: `\
+    ${hostName}${ModelDelimeter.COMPONENT_SEPERATOR}${agentId}-${userAgent}\
+    ${ModelDelimeter.NID_SEPERATOR}\
+    MainProcess\
+    ${ModelDelimeter.SEPERATOR}\
+    0`,
+        id: uuidv4(),
+        // id: `${applicationStore.applicationConfig.HOST}${ModelDelimeter.COMPONENT_SEPERATOR}${applicationStore.applicationConfig.AGENT_ID}-${applicationStore.applicationConfig.USER_AGENT}`,
+        hostName: (hostName ? hostName : 'host01'),
+        agentName: `${agentId}-${userAgent}`,
+        threadId: 'MainProcess',
+        asyncRunnerId: 0
+    }
+
+    const url = `https://stscore.stsmda.org:3001/stsinstrumentmanager/v1/publishmessage`;
+
+    const publishTransportOptions: IPublishTransportRESTServerOptions = {
+        transportType: TransportType.RESTAPI,
+        //url: `${goptions.imendpoint}:${goptions.import}${goptions.imapiroot}/publishmessage`,
+        url,
+        logger: defaultLogger,
+        agentOptions: {
+            keepAlive: goptions.keepAlive,
+            maxSockets: goptions.maxSockets,
+            maxTotalSockets: goptions.maxTotalSockets,
+            maxFreeSockets: goptions.maxFreeSockets,
+            timeout: 30000, //@@ config
+            rejectUnauthorized: goptions.isProduction // Allows self signed certs in non production mode(s)
+        },
+        showPublishPayload: false
+    };
+
+    LogInfoMessage(`publishTransportOptions: [${publishTransportOptions.url}]`);
+    
+    const standardInstruments: InstrumentDefinitions = [
+        [ Gauge.TIMER_GAUGE, GaugeTypes.INSTRUMENT_TIMER ],
+        [ Gauge.LOGGER, GaugeTypes.INSTRUMENT_LOG, {
+            consoleLogging: process.env.consoleLogging,
+            instrumentLogging: process.env.instrumentLogging } as InstrumentLogOptions],
+        [ Gauge.NETWORK_RX_GAUGE , GaugeTypes.INSTRUMENT_VELOCITY ],
+        [ Gauge.NETWORK_TX_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ]
+    ];
+    
+    const agentInstruments: InstrumentDefinitions = [
+        [ Gauge.REQUEST_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of requests serviced
+        [ Gauge.ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
+        [ Gauge.RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ],
+        [ Gauge.AUTHENTICATION_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests
+        [ Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests errors
+        [ Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Total number of new token requests retries
+        [ Gauge.ACTIVE_REQUEST_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, { // Total number of runners (in-flight) requests
+            interval: process.env.instrumentationObservationInterval, 
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.DURATION_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, { // Duration of latest http(s) request.
+            interval: process.env.instrumentationObservationInterval,
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.DURATION_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
+        [ Gauge.VELOCITY_GAUGE, GaugeTypes.INSTRUMENT_VELOCITY ], // Requests per second
+        [ Gauge.CORE_COUNT_GAUGE, GaugeTypes.INSTRUMENT_GAUGE ], // Thread count (for http agents)
+        [ Gauge.LATENCY_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
+            interval: process.env.instrumentationObservationInterval,
+            sampleSize: process.env.instrumentationTimeWindow } as InstrumentGaugeOptions],
+        [ Gauge.LATENCY_HISTOGRAM_GAUGE, GaugeTypes.INSTRUMENT_HISTOGRAM ],
+        [ Gauge.CHILD_COUNT, GaugeTypes.INSTRUMENT_GAUGE ] // Number of async runners idle or running
+    ]
+    
+    const instrumentControllerOptions: IPublishInstrumentControllerOptions = {
+        processContext: asyncRunnerContext,
+        instrumentationObservationInterval: 1000, //@@
+        instrumentationTimeWindow: 600, //@@
+        publisherTransport: new PublishTransportRESTServer(publishTransportOptions),
+        logger: defaultLogger,
+        publishInterval: 1000, //@@
+        //instrumentDefinitions: GetInstruments('agent')
+        instrumentDefinitions: [
+            ...standardInstruments,
+            ...agentInstruments
+        ]
+    }
+
+    const agentInstrumentController = new AgentInstrumentController(instrumentControllerOptions);
+    agentInstrumentController.StartPublish();
+
+    const workerFactory: IWorkerFactory = {
+     
+        createPrimaryThreadWorker: (app: any, options: IWorkerOptions): IPrimaryWorker => {
+            return new WorkerPrimaryTestRunner01(app, options);
+        },
+        createWorkerThreadWorker: (): Worker => {
+
+            LogInfoMessage(`createWorkerThreadWorker`);
+
+            const fileName ='./dist/testertesting/workerWorkerTestRunner01.js';
+
+            const publishCollectorWebWorker = new Worker(fileName);
+            publishCollectorWebWorker.unref();
+
+            return publishCollectorWebWorker;
+        },
+        get workerThreadWorkerOptions(): IWorkerOptions {
+            return {
+                agentId,
+                hostName,
+                userAgent,
+                workdata: 'worker - hello world'
+            } as IWorkerOptions;
+        },
+        get primaryThreadWorkerOptions(): IWorkerOptions {
+            return {
+                agentId,
+                hostName,
+                userAgent,
+                primaryoptions: 'primary - hello world'
+            } as IWorkerOptions;
+        }
+    }
+
+    const xx = async () => {
+        const wm = new STSWorkerManager(null, { 
+            workerFactory,
+            publishInstrumentController: agentInstrumentController
+        });
+        const worker = await wm.AddWorker();
+
+        const runnerOptions: IRunnerOptions = {
+            iterations: 100000,
+            sleepDuration: 250,
+            messageMod: 1,
+            logMessageMod: 1
+        } as IRunnerOptions;
+
+        const runner = wm.AddRunnerToWorker(worker, runnerOptions);
+
+    };
+    xx();
+    
+
+    /*
+    const fileName ='./dist/webworkertesting/worker.js';
+
+    const clusterWorker = new Worker(fileName);
+    clusterWorker.unref();
+
+    clusterWorker.postMessage({cmd: 'text', message: 'Hello World'});
+
+    clusterWorker.on('message', (data: any) => {
+        LogInfoMessage(`cluster.worker (${process.pid}): message from worker = [${JSON.stringify(data)}]`);
+    });
+    */
+
+    LogInfoMessage(`cluster work completed ...`);
+
+}

package/src/testertesting/commonTypes.ts

@@ -0,0 +1,50 @@
+import { IContextBase } from '@nsshunt/stsobservability'
+
+export const URI_BASE_VUEUTILS: string = '/';
+
+export interface IAsyncRunnerContext extends IContextBase {
+	id: string
+	hostName: string
+	agentName: string
+	threadId: string
+	asyncRunnerId: number
+}
+
+/**
+ * Inter-Worker (IW) Payload context base.
+ */
+export interface IIWMessagePayloadContentBase {
+    messageId?: string
+}
+
+/**
+ * Inter-Worker (IW) message commands.
+ */
+export enum eIWMessageCommands {
+	InstrumentTelemetry ='__STS__InstrumentTelemetry', // Used to send instrument telemetry
+	MessagePort = '__STS__MessagePort',
+	MessagePortResponse = '__STS__MessagePortResponse',
+	AddAsyncRunner = '__STS__AddAsyncRunner',
+	StopAllAsyncRunners = '__STS__StopAllAsyncRunners',
+}
+
+/**
+ * Inter-Worker (IW) message command.
+ */
+export type IIWMessageCommand = eIWMessageCommands
+
+/**
+ * Inter-Worker (IW) message payload.
+ */
+export interface IIWMessagePayload {
+    command: IIWMessageCommand
+    payload: IIWMessagePayloadContentBase
+}
+
+export interface IObservabilitySubscriberManagerOptions {
+    modelId: string
+    consumeInstrumentationMode: string
+    instrumentManagerEndpoint: string
+    instrumentManagerPort: string
+    instrumentManagerAPIRoot: string
+}

package/src/testertesting/requestResponseHelper.ts

@@ -0,0 +1,95 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { MessagePort } from 'worker_threads';
+
+import type { IIWMessagePayload } from './commonTypes'
+
+import { defaultLogger } from '@nsshunt/stsutils'
+
+declare interface RequestResponseMessage {
+	publishMessagePayload: IIWMessagePayload
+	publishMessagePayloadResponse?: IIWMessagePayload
+	cb: () => void,
+	timeout: NodeJS.Timeout
+}
+
+declare type RequestResponseMessages = Record<string, RequestResponseMessage>;
+
+//@@ this should become a low level stsutils type helper
+export class RequestResponseHelper
+{
+    #requestResponseMessages: RequestResponseMessages = { }
+    #requestResponseMessageTimeout = 10000; //@@ config
+    #port: MessagePort
+
+    constructor(port: MessagePort) {
+        this.#port = port
+        this.#SetupListener();
+    }
+
+     
+    #debug = (message: any) => {
+        defaultLogger.debug(message);
+    }
+
+    PostMessage = (message: IIWMessagePayload): Promise<IIWMessagePayload> => {
+        return new Promise((resolve, reject) => {
+            const { messageId } = message.payload;
+            if (messageId) {
+                if (this.#requestResponseMessages[messageId]) {
+                    reject(`RequestResponseHelper: Message with id: [${messageId}] already exists within the Request/Response record structure`);
+                } else {
+                    this.#requestResponseMessages[messageId] = {
+                        publishMessagePayload: { ...message },
+                        cb: () => {
+                            const detail = this.#requestResponseMessages[messageId].publishMessagePayloadResponse;
+                            clearTimeout(this.#requestResponseMessages[messageId].timeout);
+                            setTimeout(() => {
+                                delete this.#requestResponseMessages[messageId];
+                            }, 0);
+                            if (detail) {
+                                this.#debug(`RequestResponseHelper: Resolving response message with id: [${messageId}] from target worker port. Details: [${JSON.stringify(detail)}]`);
+                                resolve(detail);
+                            } else {
+                                const msg = `Could not get detail from this.#requestResponseMessages[messageId].publishMessagePayloadResponse`;
+                                this.#debug(msg);
+                                reject(msg);
+                            }
+                        },
+                        timeout: setTimeout(() => {
+                            setTimeout(() => {
+                                delete this.#requestResponseMessages[messageId];
+                            }, 0);
+                            this.#debug(`RequestResponseHelper: Timeout has occurred after: [${this.#requestResponseMessageTimeout}]ms with message id: [${messageId}]. Details: [${JSON.stringify(this.#requestResponseMessages[messageId].publishMessagePayload)}]`);
+                            reject('RequestResponseHelper: Did not receive response form parent process.');
+                        }, this.#requestResponseMessageTimeout) // max message timeout allowed
+                    };
+                    //debug(`RequestResponseHelper: Sending message with id: [${messageId}] to target worker port. Details: [${JSON.stringify(this.#requestResponseMessages[messageId].publishMessagePayload)}]`);
+                    this.#port.postMessage(message);
+                }
+            } else {
+                const msg = `RequestResponseHelper: Response did not include a message id`;
+                this.#debug(msg);
+                reject(msg);
+            }
+        });
+    }
+
+    #SetupListener = () => {
+        //this.#port.onmessage = async (msg: MessageEvent) => {
+        this.#port.on('message', (msg: any) => {
+            const publishMessagePayload: IIWMessagePayload = msg.data as IIWMessagePayload;
+            if (publishMessagePayload.payload.messageId) {
+                const messageId = publishMessagePayload.payload.messageId;
+                if (messageId && messageId !== '') {
+                    if (this.#requestResponseMessages[messageId]) {
+                        const requestResponseMessage: RequestResponseMessage = this.#requestResponseMessages[messageId];
+                        requestResponseMessage.publishMessagePayloadResponse = { ...publishMessagePayload };
+                        requestResponseMessage.cb();
+                    } else {
+                        throw new Error(`RequestResponseHelper: Could not find Request/Response message with id: [${messageId}]`);
+                    }
+                }
+            }
+        });
+    }
+}

package/src/testertesting/stsTestWorkerDefinitions.ts

@@ -0,0 +1,150 @@
+import { Worker, MessagePort } from 'worker_threads';
+
+import { PublishInstrumentController } from '@nsshunt/stsobservability'
+
+import { IAsyncRunnerContext } from './commonTypes'
+	
+export interface ISTSAgentWorkerMessagePort extends IIWMessagePayloadContentBase {
+    port: MessagePort
+    options: IWorkerOptions
+}
+
+export enum IRunnerState {
+	created = 'created',
+	running = 'running',
+	stopped = 'stopped',
+	paused = 'paused',
+	error = 'error',
+}
+
+export interface IRunnerTelemetry {
+	requestCount: number // requestCount
+	errorCount: number
+	retryCount: number
+	authenticationCount: number
+	authenticationErrorCount: number
+	authenticationRetryCount: number
+	velocity: number
+	coreCount: number
+	timer: number
+	duration: number
+	latency: number
+	activeRequestCount: number
+	message: string[]
+	childCount: number
+	rx: number
+	tx: number
+}
+
+export interface IRunner {
+	id: number
+	asyncRunnerContext: IAsyncRunnerContext
+	options: IRunnerOptions
+	state: IRunnerState
+	instrumentData: IRunnerTelemetry
+}
+
+export interface IRunnerEx extends IRunner {
+    publishInstrumentController: PublishInstrumentController
+    Stop: () => Promise<boolean>
+}
+
+export enum IWorkerState {
+	starting = 'starting',
+	started = 'started',
+	stopped = 'stopped'
+}
+
+ 
+export interface IWorkerOptions {
+    hostName: string
+    agentId: string
+    userAgent: string
+}
+
+export type Runners = Record<string, IRunner>
+
+export interface IWorker {
+	id: number
+	state: IWorkerState
+    primaryThreadWorkerOptions: IWorkerOptions
+	workerThreadWorkerOptions: IWorkerOptions
+	runners?: Runners // Will be created by utility helper
+}
+
+export type Workers = Record<string, IWorker>
+
+export interface IPrimaryWorker {
+    ProcessMessageFromWorker(workerPort: MessagePort, publishMessagePayload: IIWMessagePayload): Promise<void>
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface IRunnerOptions {
+
+}
+
+export interface IWorkerEx extends IWorker {
+	worker: Worker
+    primaryWorker: IPrimaryWorker
+	runnersEx: Record<string, IRunnerEx>
+	AddRunner: (runnerOptions: IRunnerOptions) => IRunnerEx
+	StopRunner: (runner: IRunnerEx) => Promise<boolean>
+	Stop: () => Promise<boolean>
+}
+
+export interface ISTSTestWorkerOptions {
+    messageMod: number
+    iterations: number
+}
+
+export interface ITelemetryStore {
+	workers: Workers
+}
+
+export interface ITestRunnerTelemetryPayload extends IIWMessagePayloadContentBase {
+	runner: IRunner
+}
+
+export interface IWorkerFactory {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createPrimaryThreadWorker: (app: any, options: IWorkerOptions) => IPrimaryWorker
+	createWorkerThreadWorker: () => Worker // | wt.Worker
+    get workerThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
+    get primaryThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
+}
+
+export interface IWorkerManagerOptions {
+    workerFactory: IWorkerFactory
+	publishInstrumentController: PublishInstrumentController
+}
+
+export enum eIWMessageCommands {
+    InstrumentTelemetry = "__STS__InstrumentTelemetry",// Used to send instrument telemetry
+    MessagePort = "__STS__MessagePort",
+    MessagePortResponse = "__STS__MessagePortResponse",
+    AddAsyncRunner = "__STS__AddAsyncRunner",
+    StopAllAsyncRunners = "__STS__StopAllAsyncRunners"
+}
+
+export const PublishMessageCommandsTestRunner = {
+    ...eIWMessageCommands,
+    GetAccessToken: '__GetAccessToken',
+    GetAccessTokenResponse: '__GetAccessTokenResponse',
+    GetDataFromPrimary: '__GetDataFromPrimary',
+    ExecuteRefreshToken: '__ExecuteRefreshToken',
+    ExecuteRefreshTokenResponse: '__ExecuteRefreshTokenResponse'
+} as const
+
+export type PublishMessageCommandsTestRunner = typeof PublishMessageCommandsTestRunner[keyof typeof PublishMessageCommandsTestRunner];
+
+export type IIWMessageCommand = eIWMessageCommands;
+
+export interface IIWMessagePayloadContentBase {
+    messageId?: string;
+}
+
+export interface IIWMessagePayload {
+    command: IIWMessageCommand;
+    payload: IIWMessagePayloadContentBase;
+}
+

package/src/testertesting/workerInstance.ts

@@ -0,0 +1,154 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { MessagePort } from 'worker_threads';
+
+import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase } from './commonTypes'
+
+import type { ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload } from './stsTestWorkerDefinitions'
+import { IRunnerState } from './stsTestWorkerDefinitions'
+
+import { RequestResponseHelper } from './requestResponseHelper'
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface IWorkerInstanceOptions {
+
+}
+
+export abstract class WorkerInstance {
+    #collectorCollectorPort: MessagePort | null = null;
+    #requestResponseHelper: RequestResponseHelper | null = null;
+    #runners: Record<string, IRunner> = { };
+    #options: IWorkerInstanceOptions | null = null;
+
+    #debug = (message: string) => {
+        console.log(chalk.green(`pid: [${process.pid}] WorkerInstance::${message}`));
+    }
+
+
+    constructor() {
+        this.#debug(`constructor`)
+    }
+
+    GetRandomInt = (max: number) => {
+        this.#debug(`GetRandomInt`)
+        return Math.floor(Math.random() * Math.floor(max));
+    };
+
+     
+    StartWork = async (runner: IRunner): Promise<void> => {
+        this.#debug(`StartWork`)
+        return;
+    }
+
+    PostTelemetry = (runner: IRunner) => {
+        //debug(`WorkerInstance::PostTelemetry`)
+        if (this.#collectorCollectorPort) {
+            const message: IIWMessagePayload = {
+                command: eIWMessageCommands.InstrumentTelemetry,
+                payload: {
+                    runner
+                } as ITestRunnerTelemetryPayload
+            }
+            this.#collectorCollectorPort.postMessage(message);
+        }
+    }
+
+    get RequestResponseHelper(): RequestResponseHelper | null {
+        return this.#requestResponseHelper;
+    }
+
+    get CollectorCollectorPort(): MessagePort | null {
+        return this.#collectorCollectorPort;
+    }
+
+    get Options(): IWorkerInstanceOptions | null {
+        return this.#options;
+    }
+
+    #SetMessagePort = (workerMessagePort: ISTSAgentWorkerMessagePort) => {
+        this.#debug(`SetMessagePort`)
+        this.#collectorCollectorPort = workerMessagePort.port as MessagePort;
+
+        // NodeJS version
+        this.#collectorCollectorPort.on('message', (data: any) => {
+            this.#debug(`collectorCollectorPort onmessage: ${data.data}`);
+        });
+
+        // Browser Version
+        /*
+        this.#collectorCollectorPort.onmessage = function(data: MessageEvent) {
+            console.log(`collectorCollectorPort onmessage: ${data.data}`);
+        }
+        */
+
+        this.#requestResponseHelper = new RequestResponseHelper(this.#collectorCollectorPort);
+
+        const response: IIWMessagePayload = {
+            command: eIWMessageCommands.MessagePortResponse,
+            payload: { } as IIWMessagePayloadContentBase
+        }
+
+        this.#collectorCollectorPort.postMessage(response);
+    }
+
+    StartRunner = async (runner: IRunner) => {
+        this.#debug(`StartRunner`)
+        this.#debug(`StartTests: [${JSON.stringify(runner)}]`);
+        runner.state = IRunnerState.running;
+        this.StartWork(runner);
+    }
+
+    #AddAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`AddAsyncRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id] = runner;
+        this.StartRunner(runner);
+    }
+
+    #StopRunners = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StopRunners`)
+        if (testRunnerTelemetryPayload === null) {
+            for (const [, testRunner] of Object.entries(this.#runners)) {
+                testRunner.state = IRunnerState.stopped;
+            }
+        } else {
+            const runner: IRunner = this.#runners[testRunnerTelemetryPayload.runner.id];
+            if (runner) {
+                runner.state = IRunnerState.stopped;
+            }
+        }
+    }
+
+    // ProcessMessage = async(data: MessageEvent) => { // Browser version
+    ProcessMessage = async(data: any) => {
+        this.#debug(`ProcessMessage: data: [${JSON.stringify(data)}]`)
+        try {
+            // const payloadMessage: IIWMessagePayload = data.data as IIWMessagePayload; // browser version
+            const payloadMessage: IIWMessagePayload = data as IIWMessagePayload;
+            switch (payloadMessage.command) {
+            case eIWMessageCommands.MessagePort :
+                this.#debug(`ProcessMessage::MessagePort`)
+                this.#SetMessagePort(payloadMessage.payload as ISTSAgentWorkerMessagePort);
+                this.#options = (payloadMessage.payload as ISTSAgentWorkerMessagePort).options;
+                this.#debug(`ProcessMessage::#options: [${JSON.stringify(this.#options)}]`)
+                break;
+            case eIWMessageCommands.AddAsyncRunner :
+                this.#debug(`ProcessMessage::AddAsyncRunner`)
+                this.#AddAsyncRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            case eIWMessageCommands.StopAllAsyncRunners :
+                this.#debug(`ProcessMessage::StopAllAsyncRunners`)
+                this.#StopRunners(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            default :
+                this.#debug(`ProcessMessage::default`)
+                this.#debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
+            }
+        } catch (error) {
+            console.log(error);
+        }
+    }
+}