@nsshunt/stsrunnerframework 2.0.26 → 2.0.28

package/dist/index.mjs

@@ -7040,7 +7040,6 @@ var globalThisShim = (() => {
 	else return Function("return this")();
 })();
 var defaultBinaryType = "arraybuffer";
-function createCookieJar() {}
 //#endregion
 //#region node_modules/engine.io-client/build/esm/util.js
 function pick(obj, ...attr) {
@@ -7907,7 +7906,7 @@ var SocketWithoutUpgrade = class SocketWithoutUpgrade extends Emitter {
 				OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
 			}
 		}
-		if (this.opts.withCredentials) this._cookieJar = /* @__PURE__ */ createCookieJar();
+		if (this.opts.withCredentials) this._cookieJar = void 0;
 		this._open();
 	}
 	/**
@@ -10146,6 +10145,7 @@ var SocketIoClient = class extends import_tiny_emitter.TinyEmitter {
 };
 //#endregion
 //#region src/wsevents.ts
+var RUNNER_FRAMEWORK_GLOBAL_ROOM = "__sts_global_stsrunnerframework";
 var IEventReturnValueBaseType = /* @__PURE__ */ function(IEventReturnValueBaseType) {
 	IEventReturnValueBaseType["serviceDetails"] = "serviceDetails";
 	IEventReturnValueBaseType["workers"] = "workers";
@@ -10183,21 +10183,36 @@ var IEventRequestCommand = /* @__PURE__ */ function(IEventRequestCommand) {
 	return IEventRequestCommand;
 }({});
 //#endregion
-//#region src/workerManagerProxy.ts
-var WorkerManagerProxy = class extends SocketIoClient {
+//#region src/nodeAgent.ts
+chalk.level = 3;
+var NodeAgent = class extends SocketIoClient {
 	_options;
 	_id = globalThis.crypto.randomUUID();
 	_clientName = "";
 	_wm;
-	#debug = (message) => this._options.logger.debug(message);
-	#error = (error) => this._options.logger.error(error);
-	#info = (message) => this._options.logger.info(message);
+	_heartBeatTimeout = void 0;
+	_heartBeatInterval = 1e3;
+	_colIndex;
+	_GetColorFromIndex = () => {
+		switch (this._colIndex % 5) {
+			case 0: return chalk.rgb(10, 200, 50);
+			case 1: return chalk.rgb(62, 62, 97);
+			case 2: return chalk.rgb(214, 112, 168);
+			case 3: return chalk.rgb(118, 139, 22);
+			case 4: return chalk.rgb(165, 79, 199);
+		}
+		return chalk.yellow;
+	};
+	#debug = (message) => this._options.logger.debug(this._GetColorFromIndex()(`NodeAgent:${this._id}:${this._clientName}: ${message}`));
+	#error = (error) => this._options.logger.error(this._GetColorFromIndex()(`NodeAgent:${this._id}:${this._clientName}: ${error}`));
+	#info = (message) => this._options.logger.info(this._GetColorFromIndex()(`NodeAgent:${this._id}:${this._clientName}: ${message}`));
 	constructor(options) {
 		super(options.name);
 		this._options = options;
 		this._clientName = options.name;
+		this._colIndex = options.colIndex;
 		this._wm = this._options.CreateSTSWorkerManager();
-		this.#info(chalk.yellow(`Worker Manager ID: [${this._wm.id}]`));
+		this.#info(chalk.yellow(`constructor(): Worker Manager ID: [${this._wm.id}]`));
 		this._Start();
 	}
 	get workerManager() {
@@ -10212,7 +10227,7 @@ var WorkerManagerProxy = class extends SocketIoClient {
 		this._OnSocketConnected(socket, this.name, []);
 	}
 	SocketError(error) {
-		this.#error(`${this.name}: SetupClientSideSocket call back: [${error}]`);
+		this.#error(`SetupClientSideSocket call back: [${error}]`);
 	}
 	SetupSocketEvents(socket) {
 		this._RegisterSocketEvents(socket, this.name);
@@ -10229,18 +10244,43 @@ var WorkerManagerProxy = class extends SocketIoClient {
 	_LogPayloadEventRetVal = (retVal) => {
 		return retVal;
 	};
+	_HeartBeat = async () => {
+		const workers = [];
+		const workersCore = await this._GetWorkersCore({
+			useZip: false,
+			states: []
+		});
+		for (const [key, workerCoreData] of Object.entries(workersCore.workerCores)) workers.push({
+			workerId: workerCoreData.id,
+			runnerCount: Object.keys(workerCoreData.runners).length,
+			state: "unknown",
+			maxRunners: 5
+		});
+		const start = performance.now();
+		const payload = {
+			nodeId: this.id,
+			sentAt: Date.now(),
+			workers,
+			enabled: true,
+			labels: ["somelabel"]
+		};
+		this.socket?.emit("HeartBeat", payload, (data) => {
+			const end = performance.now();
+			const nextTimeoutInterval = this._heartBeatInterval - (end - start);
+			this._heartBeatTimeout = setTimeout(this._HeartBeat, nextTimeoutInterval);
+		});
+	};
 	_Start = async () => {
 		this._EmitEvent("Starting", {});
-		this.WithAddress(this._options.ststccendpoint).WithLogger(defaultLogger).WithSocketIoCustomPath("");
+		this.WithAddress(this._options.nodeAgentEndpoint).WithLogger(defaultLogger).WithSocketIoCustomPath(this._options.nodeAgentSocketIoCustomPath).WithAckTimeout(5e3);
 		if (this._options.agentManager) this.WithAgentManager(this._options.agentManager);
-		this.#info(chalk.yellow(`STS Test Runner Service Instance.`));
-		this.#info(chalk.yellow(`This service instance emulates instances of the ststestrunnernode service.`));
-		this.#info(chalk.yellow(`Service Instance ID: [${this._id}]`));
-		this.#info(chalk.yellow(`Service Instance Name: [${this._options.name}]`));
-		this.#info(chalk.yellow(`Options: [${JSON.stringify(this._options)}]`));
+		this.#info(chalk.yellow(`_Start():STS Test Runner Service Instance.`));
+		this.#info(chalk.yellow(`_Start():This service instance emulates instances of the ststestrunnernode service.`));
+		this.#info(chalk.yellow(`_Start():Service Instance ID: [${this._id}]`));
+		this.#info(chalk.yellow(`_Start():Service Instance Name: [${this._options.name}]`));
 		this.SetupSocket();
 		const start = async () => {
-			for (let i = 0; i < this._options.workers; i++) await this._AddWorker({
+			for (let i = 0; i < this._options.workers; i++) await this._AddWorker({ workerOptions: {
 				tags: [""],
 				userData: {},
 				mocked: false,
@@ -10248,42 +10288,38 @@ var WorkerManagerProxy = class extends SocketIoClient {
 				agentId: "agent01",
 				userAgent: globalThis.crypto.randomUUID(),
 				logLevel: 4
-			});
+			} });
 			this._EmitEvent("Started", {});
 		};
 		await start();
+		this._heartBeatTimeout = setTimeout(this._HeartBeat, this._heartBeatInterval);
 	};
 	Stop = async () => {
-		this._EmitEvent("Stopping ...", {});
-		this.#debug(chalk.magenta(`Stop(): Stopping Service.`));
+		this._EmitEvent("NodeAgent:Stop():Stopping ...", {});
+		if (this._heartBeatTimeout) clearTimeout(this._heartBeatTimeout);
+		this.#debug(chalk.magenta(`Stop(): Stopping Service...`));
 		await this._wm.TerminateWorkers([]);
-		this.#debug(`Stop(): Workers terminated`);
+		this.#debug(chalk.magenta(`Stop(): Workers terminated`));
 		if (this.socket) {
-			this.#debug(`Stop(): Going to disconnect socket ...`);
+			this.#debug(chalk.magenta(`Stop(): Going to disconnect socket ...`));
 			this.socket.disconnect();
-			this.#debug(`Stop(): Socket disconnected.`);
+			this.#debug(chalk.magenta(`Stop(): Socket disconnected.`));
 		}
-		this.#debug(`Stop(): Sleeping (500ms) ...`);
+		this.#debug(chalk.magenta(`Stop(): Sleeping (500ms) ...`));
 		await Sleep(500);
 		this.#debug(chalk.magenta(`Stop(): Service Stopped.`));
 		this._EmitEvent("Stopped", {});
 	};
-	_GetService = async () => {
+	_GetService = async (args) => {
 		const raw = this._EmitEvent("GetService", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.GetService, IEventReturnValueBaseType.serviceDetails),
 			serviceDetails: await this._options.GetServiceDetails()
 		}));
-		raw.serviceDetails = gzipSync(strToU8(JSON.stringify(raw.serviceDetails)));
+		if (args.useZip === true) raw.serviceDetails = gzipSync(strToU8(JSON.stringify(raw.serviceDetails)));
 		return raw;
 	};
-	_GetServiceNoZip = async () => {
-		return this._EmitEvent("GetService", this._LogPayloadEventRetVal({
-			...this._GetKeyPayloadData(IEventRequestCommand.GetService, IEventReturnValueBaseType.serviceDetails),
-			serviceDetails: await this._options.GetServiceDetails()
-		}));
-	};
 	_EmitStateChange = (runnerEx) => {
-		this.#debug(chalk.rgb(10, 50, 200)(`WorkerManagerProxy:_EmitStateChange():  ==>>  Runner State Change: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}] State: [${runnerEx.state}]`));
+		this.#debug(chalk.rgb(10, 50, 200)(`_EmitStateChange():  ==>>  Runner State Change: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}] State: [${runnerEx.state}]`));
 		const stateChangeRetVal = {
 			eventRequestCommand: "StateChange",
 			type: IEventReturnValueBaseType.runner,
@@ -10296,9 +10332,8 @@ var WorkerManagerProxy = class extends SocketIoClient {
 		this.socket?.emit("StateChange", stateChangeRetVal);
 	};
 	_EmitTelemetry = (runnerEx) => {
-		this.#debug(chalk.rgb(10, 50, 200)(`WorkerManagerProxy:_EmitTelemetry():  ==>>  WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}] State: [${runnerEx.state}]`));
 		const telemetryRetVal = {
-			eventRequestCommand: "StateChange",
+			eventRequestCommand: "Telemetry",
 			type: IEventReturnValueBaseType.runner,
 			workerManagerId: this._wm.id,
 			id: this._id,
@@ -10313,21 +10348,21 @@ var WorkerManagerProxy = class extends SocketIoClient {
 		runnerEx.on("Telemetry", this._EmitTelemetry);
 	};
 	_OnSocketConnected = (socket, clientName, joinRooms) => {
-		this.#debug(chalk.green(`${this._id} ${clientName}: --> connected`));
+		this.#debug(chalk.green(`_OnSocketConnected(): ${this._id} ${clientName}: --> connected`));
+		const rooms = [
+			RUNNER_FRAMEWORK_GLOBAL_ROOM,
+			`node_${this._id}`,
+			...joinRooms
+		];
 		this._EmitEvent("SocketConnected", {
 			id: this._id,
 			clientName,
-			joinRooms: [
-				...joinRooms,
-				"ststrnservices",
-				this._id
-			]
+			joinRooms: rooms
 		});
-		if (joinRooms.length > 0) socket.emit("__STSjoinRoom", joinRooms);
-		socket.emit("__STSjoinRoom", ["ststrnservices"]).emit("__STSjoinRoom", [this._id]);
+		socket.emit("__STSjoinRoom", rooms);
 	};
-	_AddWorker = async (options) => {
-		const workerEx = await this._wm.AddWorker(options);
+	_AddWorker = async (args) => {
+		const workerEx = await this._wm.AddWorker(args.workerOptions);
 		if (workerEx) return this._EmitEvent("AddWorker", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.AddWorker, IEventReturnValueBaseType.worker),
 			worker: workerEx.toWorker()
@@ -10337,151 +10372,133 @@ var WorkerManagerProxy = class extends SocketIoClient {
 			worker: {}
 		}));
 	};
-	_GetArchiveList = async (runnerSearchFilters) => {
+	_GetArchiveList = async (args) => {
 		const raw = this._EmitEvent("GetArchiveList", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.GetArchiveList, IEventReturnValueBaseType.archiveList),
-			archiveList: await this._wm.GetArchiveList(runnerSearchFilters)
+			archiveList: await this._wm.GetArchiveList(args.runnerSearchFilters)
 		}));
-		raw.archiveList = gzipSync(strToU8(JSON.stringify(raw.archiveList)));
+		if (args.useZip === true) raw.archiveList = gzipSync(strToU8(JSON.stringify(raw.archiveList)));
 		return raw;
 	};
-	_GetArchiveListNoZip = async (runnerSearchFilters) => {
-		return this._EmitEvent("GetArchiveList", this._LogPayloadEventRetVal({
-			...this._GetKeyPayloadData(IEventRequestCommand.GetArchiveList, IEventReturnValueBaseType.archiveList),
-			archiveList: await this._wm.GetArchiveList(runnerSearchFilters)
-		}));
-	};
-	_GetWorkers = async () => {
+	_GetWorkers = async (args) => {
 		const raw = this._EmitEvent("GetWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkers, IEventReturnValueBaseType.workers),
 			workers: await this._wm.GetWorkers()
 		}));
-		raw.workers = gzipSync(strToU8(JSON.stringify(raw.workers)));
+		if (args.useZip === true) raw.workers = gzipSync(strToU8(JSON.stringify(raw.workers)));
 		return raw;
 	};
-	_GetWorkersNoZip = async () => {
-		return this._EmitEvent("GetWorkers", this._LogPayloadEventRetVal({
-			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkers, IEventReturnValueBaseType.workers),
-			workers: await this._wm.GetWorkers()
-		}));
-	};
-	_GetWorkersCore = async (states) => {
+	_GetWorkersCore = async (args) => {
 		const raw = this._EmitEvent("GetWorkersCore", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkersCore, IEventReturnValueBaseType.workers),
-			workerCores: await this._wm.GetWorkersCore(states)
+			workerCores: await this._wm.GetWorkersCore(args.states)
 		}));
-		raw.workers = gzipSync(strToU8(JSON.stringify(raw.workers)));
+		if (args.useZip === true) raw.workerCores = gzipSync(strToU8(JSON.stringify(raw.workerCores)));
 		return raw;
 	};
-	_GetWorkersCoreNoZip = async (states) => {
-		return this._EmitEvent("GetWorkersCore", this._LogPayloadEventRetVal({
-			...this._GetKeyPayloadData(IEventRequestCommand.GetWorkersCore, IEventReturnValueBaseType.workers),
-			workerCores: await this._wm.GetWorkersCore(states)
-		}));
-	};
-	_StartWorkers = async (workerIds) => {
+	_StartWorkers = async (args) => {
 		return this._EmitEvent("StartWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.StartWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.StartWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.StartWorkers(args.workerIds)
 		}));
 	};
-	_StopWorkers = async (workerIds) => {
+	_StopWorkers = async (args) => {
 		return this._EmitEvent("StopWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.StopWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.StopWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.StopWorkers(args.workerIds)
 		}));
 	};
-	_PauseWorkers = async (workerIds) => {
+	_PauseWorkers = async (args) => {
 		return this._EmitEvent("PauseWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.PauseWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.PauseWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.PauseWorkers(args.workerIds)
 		}));
 	};
-	_ResumeWorkers = async (workerIds) => {
+	_ResumeWorkers = async (args) => {
 		return this._EmitEvent("ResumeWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ResumeWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.ResumeWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.ResumeWorkers(args.workerIds)
 		}));
 	};
-	_ExecuteWorkers = async (workerIds) => {
+	_ExecuteWorkers = async (args) => {
 		return this._EmitEvent("ExecuteWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ExecuteWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.ExecuteWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.ExecuteWorkers(args.workerIds)
 		}));
 	};
-	_ResetWorkers = async (workerIds) => {
+	_ResetWorkers = async (args) => {
 		return this._EmitEvent("ResetWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ResetWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.ResetWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.ResetWorkers(args.workerIds)
 		}));
 	};
-	_TerminateWorkers = async (workerIds) => {
+	_TerminateWorkers = async (args) => {
 		return this._EmitEvent("TerminateWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.TerminateWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.TerminateWorkers(workerIds)
+			executeWorkerActionResult: await this._wm.TerminateWorkers(args.workerIds)
 		}));
 	};
-	_UpdateWorkers = async (workerIds, options) => {
+	_UpdateWorkers = async (args) => {
 		return this._EmitEvent("UpdateWorkers", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.UpdateWorkers, IEventReturnValueBaseType.executeWorkerActionResult),
-			executeWorkerActionResult: await this._wm.UpdateWorkers(workerIds, options)
+			executeWorkerActionResult: await this._wm.UpdateWorkers(args.workerIds, args.runnerOptionsPartial)
 		}));
 	};
-	_StopRunners = async (workerId, runnerIds) => {
-		return this._EmitEvent("StopRunners", this._LogPayloadEventRetVal({
-			...this._GetKeyPayloadData(IEventRequestCommand.StopRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.StopRunners(workerId, runnerIds)
-		}));
-	};
-	_StartRunners = async (workerId, runnerIds) => {
+	_StartRunners = async (args) => {
 		return this._EmitEvent("StartRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.StartRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.StartRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.StartRunners(args.workerId, args.runnerIds)
+		}));
+	};
+	_StopRunners = async (args) => {
+		return this._EmitEvent("StopRunners", this._LogPayloadEventRetVal({
+			...this._GetKeyPayloadData(IEventRequestCommand.StopRunners, IEventReturnValueBaseType.executeRunnerActionResult),
+			executeRunnerActionResult: await this._wm.StopRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_PauseRunners = async (workerId, runnerIds) => {
+	_PauseRunners = async (args) => {
 		return this._EmitEvent("PauseRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.PauseRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.PauseRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.PauseRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_ResumeRunners = async (workerId, runnerIds) => {
+	_ResumeRunners = async (args) => {
 		return this._EmitEvent("ResumeRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ResumeRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.ResumeRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.ResumeRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_ExecuteRunners = async (workerId, runnerIds) => {
+	_ExecuteRunners = async (args) => {
 		return this._EmitEvent("ExecuteRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ExecuteRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.ExecuteRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.ExecuteRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_ResetRunners = async (workerId, runnerIds) => {
+	_ResetRunners = async (args) => {
 		return this._EmitEvent("ResetRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.ResetRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.ResetRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.ResetRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_TerminateRunners = async (workerId, runnerIds) => {
+	_TerminateRunners = async (args) => {
 		return this._EmitEvent("TerminateRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.TerminateRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.TerminateRunners(workerId, runnerIds)
+			executeRunnerActionResult: await this._wm.TerminateRunners(args.workerId, args.runnerIds)
 		}));
 	};
-	_UpdateRunners = async (workerId, runnerIds, options) => {
+	_UpdateRunners = async (args) => {
 		return this._EmitEvent("UpdateRunners", this._LogPayloadEventRetVal({
 			...this._GetKeyPayloadData(IEventRequestCommand.UpdateRunners, IEventReturnValueBaseType.executeRunnerActionResult),
-			executeRunnerActionResult: await this._wm.UpdateRunners(workerId, runnerIds, options)
+			executeRunnerActionResult: await this._wm.UpdateRunners(args.workerId, args.runnerIds, args.runnerOptionsPartial)
 		}));
 	};
-	_AddRunner = async (options) => {
-		this.#debug(chalk.yellow(`${this._id} ${this._clientName}:  --> AddRunner: [${JSON.stringify(options)}]`));
-		const runnerEx = await this._wm.AddRunner(options);
+	_AddRunner = async (args) => {
+		this.#debug(chalk.yellow(`_AddRunner(): ${this._id} ${this._clientName}:  --> AddRunner: [${JSON.stringify(args.runnerOptions)}]`));
+		const runnerEx = await this._wm.AddRunner(args.runnerOptions);
 		let runner = {};
 		if (runnerEx) {
 			this._SetupRunnerEventHandlers(runnerEx);
-			this.#debug(chalk.yellow(`${this._clientName}: AddRunner: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
+			this.#debug(chalk.yellow(`_AddRunner: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
 			runner = runnerEx.toRunner();
 		}
 		return this._EmitEvent(IEventRequestCommand.AddRunner, this._LogPayloadEventRetVal({
@@ -10489,13 +10506,13 @@ var WorkerManagerProxy = class extends SocketIoClient {
 			runner
 		}));
 	};
-	_AddRunnerToWorkerByWorkerId = async (workerId, options) => {
-		this.#debug(chalk.yellow(`${this._id} ${this._clientName}:  --> AddRunner: [${JSON.stringify(options)}]`));
-		const runnerEx = await this._wm.AddRunnerToWorkerByWorkerId(workerId, options);
+	_AddRunnerToWorkerByWorkerId = async (args) => {
+		this.#debug(chalk.yellow(`_AddRunnerToWorkerByWorkerId(): ${this._id} ${this._clientName}:  --> _AddRunnerToWorkerByWorkerId: workerId: [${args.workerId}], options: [${JSON.stringify(args.runnerOptions)}]`));
+		const runnerEx = await this._wm.AddRunnerToWorkerByWorkerId(args.workerId, args.runnerOptions);
 		let runner = {};
 		if (runnerEx) {
 			this._SetupRunnerEventHandlers(runnerEx);
-			this.#debug(chalk.yellow(`${this._clientName}: AddRunnerToWorker: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
+			this.#debug(chalk.yellow(`_AddRunnerToWorker: WorkerId: [${runnerEx.workerId}] RunnerId: [${runnerEx.id}]`));
 			runner = runnerEx.toRunner();
 		}
 		return this._EmitEvent(IEventRequestCommand.AddRunnerToWorker, this._LogPayloadEventRetVal({
@@ -10508,12 +10525,14 @@ var WorkerManagerProxy = class extends SocketIoClient {
 		const handlers = this._GetSocketEventHandlers(socket, clientName);
 		for (const [event, handler] of Object.entries(handlers)) {
 			const wrappedHandler = async (...args) => {
+				this.#debug(chalk.yellow(` --> ${event}: ${JSON.stringify(args, null, 2)}`));
 				return handler(...args);
 			};
 			socket.on(event, wrappedHandler);
 		}
 	};
 	_EmitEvent = (eventName, data) => {
+		data.eventRequestCommand;
 		this.emit(eventName, data);
 		return data;
 	};
@@ -10522,48 +10541,48 @@ var WorkerManagerProxy = class extends SocketIoClient {
 		return {
 			"disconnect": (reason) => {
 				this._EmitEvent("disconnect", reason);
-				this.#error(`#disconnect(): [${reason}]`);
+				this.#error(`_GetSocketEventHandlers:disconnect: [${reason}]`);
 			},
 			"connect_error": (error) => {
 				this._EmitEvent("connect_error", error);
-				if (!socket.active) this.#error(error.message);
+				if (!socket.active) this.#error(`_GetSocketEventHandlers:connect_error: [${error.message}]`);
 			},
 			"error": (error) => {
 				this._EmitEvent("error", error);
-				this.#error(`#GetSocketEventHandlers(): [${error}]`);
+				this.#error(`_GetSocketEventHandlers:error: [${error.message}]`);
 			},
 			"__STSdisconnect": (reason) => {
 				this._EmitEvent("__STSdisconnect", reason);
-				this.#debug(chalk.magenta(`${logPrefix}: [${socket.id}] [${reason}]`));
+				this.#debug(chalk.magenta(`_GetSocketEventHandlers:__STSdisconnect: ${logPrefix}: [${socket.id}] [${reason}]`));
 				this.Stop();
 			},
-			"GetService": async (cb) => cb(await this._GetService()),
-			"GetWorkers": async (cb) => cb(await this._GetWorkers()),
-			"GetWorkersCore": async (states, cb) => cb(await this._GetWorkersCore(states)),
-			"GetArchiveList": async (runnerSearchFilters, cb) => cb(await this._GetArchiveList(runnerSearchFilters)),
-			"AddRunner": async (options, cb) => cb(await this._AddRunner(options)),
-			"AddRunnerToWorkerByWorkerId": async (workerId, options, cb) => cb(await this._AddRunnerToWorkerByWorkerId(workerId, options)),
-			"AddWorker": async (options, cb) => cb(await this._AddWorker(options)),
-			"StartWorkers": async (workerIds, cb) => cb(await this._StartWorkers(workerIds)),
-			"StopWorkers": async (workerIds, cb) => cb(await this._StopWorkers(workerIds)),
-			"PauseWorkers": async (workerIds, cb) => cb(await this._PauseWorkers(workerIds)),
-			"ResumeWorkers": async (workerIds, cb) => cb(await this._ResumeWorkers(workerIds)),
-			"ExecuteWorkers": async (workerIds, cb) => cb(await this._ExecuteWorkers(workerIds)),
-			"ResetWorkers": async (workerIds, cb) => cb(await this._ResetWorkers(workerIds)),
-			"TerminateWorkers": async (workerIds, cb) => cb(await this._TerminateWorkers(workerIds)),
-			"UpdateWorkers": async (workerIds, options, cb) => cb(await this._UpdateWorkers(workerIds, options)),
-			"StartRunners": async (workerId, runnerIds, cb) => cb(await this._StartRunners(workerId, runnerIds)),
-			"StopRunners": async (workerId, runnerIds, cb) => cb(await this._StopRunners(workerId, runnerIds)),
-			"PauseRunners": async (workerId, runnerIds, cb) => cb(await this._PauseRunners(workerId, runnerIds)),
-			"ResumeRunners": async (workerId, runnerIds, cb) => cb(await this._ResumeRunners(workerId, runnerIds)),
-			"ExecuteRunners": async (workerId, runnerIds, cb) => cb(await this._ExecuteRunners(workerId, runnerIds)),
-			"ResetRunners": async (workerId, runnerIds, cb) => cb(await this._ResetRunners(workerId, runnerIds)),
-			"TerminateRunners": async (workerId, runnerIds, cb) => cb(await this._TerminateRunners(workerId, runnerIds)),
-			"UpdateRunners": async (workerId, runnerIds, options, cb) => cb(await this._UpdateRunners(workerId, runnerIds, options))
+			"GetService": async (args, cb) => cb(await this._GetService(args)),
+			"GetWorkers": async (args, cb) => cb(await this._GetWorkers(args)),
+			"GetWorkersCore": async (args, cb) => cb(await this._GetWorkersCore(args)),
+			"GetArchiveList": async (args, cb) => cb(await this._GetArchiveList(args)),
+			"AddRunner": async (args, cb) => cb(await this._AddRunner(args)),
+			"AddRunnerToWorkerByWorkerId": async (args, cb) => cb(await this._AddRunnerToWorkerByWorkerId(args)),
+			"AddWorker": async (args, cb) => cb(await this._AddWorker(args)),
+			"StartWorkers": async (args, cb) => cb(await this._StartWorkers(args)),
+			"StopWorkers": async (args, cb) => cb(await this._StopWorkers(args)),
+			"PauseWorkers": async (args, cb) => cb(await this._PauseWorkers(args)),
+			"ResumeWorkers": async (args, cb) => cb(await this._ResumeWorkers(args)),
+			"ExecuteWorkers": async (args, cb) => cb(await this._ExecuteWorkers(args)),
+			"ResetWorkers": async (args, cb) => cb(await this._ResetWorkers(args)),
+			"TerminateWorkers": async (args, cb) => cb(await this._TerminateWorkers(args)),
+			"UpdateWorkers": async (args, cb) => cb(await this._UpdateWorkers(args)),
+			"StartRunners": async (args, cb) => cb(await this._StartRunners(args)),
+			"StopRunners": async (args, cb) => cb(await this._StopRunners(args)),
+			"PauseRunners": async (args, cb) => cb(await this._PauseRunners(args)),
+			"ResumeRunners": async (args, cb) => cb(await this._ResumeRunners(args)),
+			"ExecuteRunners": async (args, cb) => cb(await this._ExecuteRunners(args)),
+			"ResetRunners": async (args, cb) => cb(await this._ResetRunners(args)),
+			"TerminateRunners": async (args, cb) => cb(await this._TerminateRunners(args)),
+			"UpdateRunners": async (args, cb) => cb(await this._UpdateRunners(args))
 		};
 	};
 };
 //#endregion
-export { AbstractRunnerExecutionWorker, IEventRequestCommand, IEventReturnValueBaseType, IRunnerState, IWorkerState, PublishMessageCommandsTestRunner, STSWorkerManager, WorkerManagerProxy, eIWMessageCommands };
+export { AbstractRunnerExecutionWorker, IEventRequestCommand, IEventReturnValueBaseType, IRunnerState, IWorkerState, NodeAgent, PublishMessageCommandsTestRunner, RUNNER_FRAMEWORK_GLOBAL_ROOM, STSWorkerManager, eIWMessageCommands };
 
 //# sourceMappingURL=index.mjs.map