ultravisor 1.0.3 → 1.0.8

package/source/beacon/providers/Ultravisor-Beacon-Provider-Shell.cjs

@@ -0,0 +1,95 @@
+/**
+ * Ultravisor Beacon Provider — Shell
+ *
+ * Built-in provider that executes shell commands via child_process.exec().
+ *
+ * Capability: 'Shell'
+ * Actions:    'Execute' — run a shell command with optional parameters.
+ *
+ * Provider config:
+ *   MaxBufferBytes {number} — max stdout/stderr buffer (default: 10MB)
+ */
+
+const libChildProcess = require('child_process');
+
+const libBeaconCapabilityProvider = require('../Ultravisor-Beacon-CapabilityProvider.cjs');
+
+class UltravisorBeaconProviderShell extends libBeaconCapabilityProvider
+{
+	constructor(pProviderConfig)
+	{
+		super(pProviderConfig);
+
+		this.Name = 'Shell';
+		this.Capability = 'Shell';
+
+		this._MaxBufferBytes = this._ProviderConfig.MaxBufferBytes || 10485760;
+	}
+
+	get actions()
+	{
+		return {
+			'Execute':
+			{
+				Description: 'Execute a shell command.',
+				SettingsSchema:
+				[
+					{ Name: 'Command', DataType: 'String', Required: true, Description: 'The command to run' },
+					{ Name: 'Parameters', DataType: 'String', Required: false, Description: 'Command-line arguments' }
+				]
+			}
+		};
+	}
+
+	execute(pAction, pWorkItem, pContext, fCallback, fReportProgress)
+	{
+		let tmpSettings = pWorkItem.Settings || {};
+		let tmpCommand = tmpSettings.Command || '';
+		let tmpParameters = tmpSettings.Parameters || '';
+
+		if (!tmpCommand)
+		{
+			return fCallback(null, {
+				Outputs: { StdOut: 'No command specified.', ExitCode: -1, Result: '' },
+				Log: ['Shell Provider: no command specified.']
+			});
+		}
+
+		let tmpFullCommand = tmpParameters ? (tmpCommand + ' ' + tmpParameters) : tmpCommand;
+		let tmpTimeout = pWorkItem.TimeoutMs || 300000;
+
+		console.log(`  [Shell] Running: ${tmpFullCommand}`);
+
+		libChildProcess.exec(tmpFullCommand,
+			{
+				cwd: pContext.StagingPath || process.cwd(),
+				timeout: tmpTimeout,
+				maxBuffer: this._MaxBufferBytes
+			},
+			function (pError, pStdOut, pStdErr)
+			{
+				if (pError)
+				{
+					return fCallback(null, {
+						Outputs: {
+							StdOut: (pStdOut || '') + (pStdErr || ''),
+							ExitCode: pError.code || 1,
+							Result: ''
+						},
+						Log: [`Command failed: ${pError.message}`, pStdErr || ''].filter(Boolean)
+					});
+				}
+
+				return fCallback(null, {
+					Outputs: {
+						StdOut: pStdOut || '',
+						ExitCode: 0,
+						Result: pStdOut || ''
+					},
+					Log: [`Command executed: ${tmpFullCommand}`]
+				});
+			});
+	}
+}
+
+module.exports = UltravisorBeaconProviderShell;

package/source/cli/Ultravisor-CLIProgram.cjs

@@ -2,24 +2,26 @@ const libCLIProgram = require('pict-service-commandlineutility');
 const libFS = require('fs');
 const libPath = require('path');
 
-const libServiceHypervisor = require(`../services/Ultravisor-Hypervisor.cjs`);
-const libServiceHypervisorState = require(`../services/Ultravisor-Hypervisor-State.cjs`);
+const libServiceHypervisor = require('../services/Ultravisor-Hypervisor.cjs');
+const libServiceHypervisorState = require('../services/Ultravisor-Hypervisor-State.cjs');
 
-const libServiceHypervisorEventBase = require(`../services/Ultravisor-Hypervisor-Event-Base.cjs`);
-const libServiceHypervisorEventCron = require(`../services/events/Ultravisor-Hypervisor-Event-Cron.cjs`);
-const libServiceHypervisorEventSolver = require(`../services/events/Ultravisor-Hypervisor-Event-Solver.cjs`);
+const libServiceHypervisorEventBase = require('../services/Ultravisor-Hypervisor-Event-Base.cjs');
+const libServiceHypervisorEventCron = require('../services/events/Ultravisor-Hypervisor-Event-Cron.cjs');
 
-const libServiceOperation = require(`../services/Ultravisor-Operation.cjs`);
-const libServiceOperationManifest = require(`../services/Ultravisor-Operation-Manifest.cjs`);
+const libServiceSchedulePersistenceBase = require('../services/Ultravisor-Schedule-Persistence-Base.cjs');
+const libServiceSchedulePersistenceJSONFile = require('../services/persistence/Ultravisor-Schedule-Persistence-JSONFile.cjs');
 
-const libServiceTask = require(`../services/Ultravisor-Task.cjs`);
+const libServiceTaskTypeRegistry = require('../services/Ultravisor-TaskTypeRegistry.cjs');
+const libServiceStateManager = require('../services/Ultravisor-StateManager.cjs');
+const libServiceExecutionEngine = require('../services/Ultravisor-ExecutionEngine.cjs');
+const libServiceExecutionManifest = require('../services/Ultravisor-ExecutionManifest.cjs');
+const libServiceBeaconCoordinator = require('../services/Ultravisor-Beacon-Coordinator.cjs');
 
 // TODO: Remove this when Restify is fixed.
 process.removeAllListeners('warning')
 
-const libWebServerAPIServer = require(`../web_server/Ultravisor-API-Server.cjs`);
+const libWebServerAPIServer = require('../web_server/Ultravisor-API-Server.cjs');
 
-// TODO: Add a way to do this cleanly from the pict-service-commandlineutility package itself, maybe via a "pre-initialization" function or something like that?
 // Check for an optional --config / -c command line parameter to load a config file
 let _ConfigFileOverride = false;
 for (let i = 0; i < process.argv.length; i++)
@@ -59,7 +61,7 @@ let _Ultravisor_Pict = new libCLIProgram(
 
 		"Command": "ultravisor",
 
-		"DefaultProgramConfiguration": require(`../config/Ultravisor-Default-Command-Configuration.cjs`),
+		"DefaultProgramConfiguration": require('../config/Ultravisor-Default-Command-Configuration.cjs'),
 
 		"ProgramConfigurationFileName": ".ultravisor.json",
 
@@ -85,8 +87,6 @@ let _Ultravisor_Pict = new libCLIProgram(
 	]);
 
 // Register --config / -c as a known global option so Commander doesn't reject it.
-// The actual file loading happens in the pre-initialization block above; this just
-// prevents Commander from throwing "unknown option '--config'".
 _Ultravisor_Pict.CommandLineUtility.command.option('-c, --config <path>', 'Load configuration from a JSON file');
 
 // If a config file override was passed via --config / -c, apply it on top of the gathered config
@@ -100,18 +100,40 @@ _Ultravisor_Pict.instantiateServiceProvider('FilePersistence');
 // Instantiate the data generation service
 _Ultravisor_Pict.instantiateServiceProvider('DataGeneration');
 
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Hypervisor', libServiceHypervisor);
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Hypervisor-State', libServiceHypervisorState);
+// --- Core services ---
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorHypervisor', libServiceHypervisor);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorHypervisorState', libServiceHypervisorState);
 
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Hypervisor-Event-Base', libServiceHypervisorEventBase);
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Hypervisor-Event-Cron', libServiceHypervisorEventCron);
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Hypervisor-Event-Solver', libServiceHypervisorEventSolver);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorHypervisorEventBase', libServiceHypervisorEventBase);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorHypervisorEventCron', libServiceHypervisorEventCron);
 
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Operation', libServiceOperation);
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Operation-Manifest', libServiceOperationManifest);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorSchedulePersistenceBase', libServiceSchedulePersistenceBase);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorSchedulePersistence', libServiceSchedulePersistenceJSONFile);
 
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Task', libServiceTask);
+// --- New engine services ---
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorTaskTypeRegistry', libServiceTaskTypeRegistry);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorStateManager', libServiceStateManager);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorExecutionEngine', libServiceExecutionEngine);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorExecutionManifest', libServiceExecutionManifest);
 
-_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-API-Server', libWebServerAPIServer);
+// Register built-in task types
+let tmpRegistry = Object.values(_Ultravisor_Pict.fable.servicesMap['UltravisorTaskTypeRegistry'])[0];
+if (tmpRegistry)
+{
+	tmpRegistry.registerBuiltInTaskTypes();
+}
+
+// --- Beacon coordinator ---
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorBeaconCoordinator', libServiceBeaconCoordinator);
+
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('UltravisorAPIServer', libWebServerAPIServer);
+
+// ── Service name aliases ────────────────────────────────
+// Some CLI commands access services by hyphenated names via this.fable['Name'].
+// Bridge the camelCase registration to hyphenated access.
+let _Fable = _Ultravisor_Pict.fable;
+
+_Fable['Ultravisor-Hypervisor'] = Object.values(_Fable.servicesMap['UltravisorHypervisor'])[0];
+_Fable['Ultravisor-API-Server'] = Object.values(_Fable.servicesMap['UltravisorAPIServer'])[0];
 
 module.exports = _Ultravisor_Pict;

package/source/cli/commands/Ultravisor-Command-SingleOperation.cjs

@@ -9,19 +9,26 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 		this.options.CommandKeyword = 'singleoperation';
 		this.options.Description = 'Execute a single ultravisor operation immediately, no matter what.';
 
-		this.options.CommandArguments.push({ Name: '<operation>', Description: 'The operation(s) to run.' });
-		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the task.', Default: false });
+		this.options.CommandArguments.push({ Name: '<operation>', Description: 'The operation hash to run.' });
+		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the operation.', Default: false });
 
 		this.options.Aliases.push('operation');
 
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
-		let tmpOperationGUID = this.ArgumentString;
+		let tmpOperationHash = this.ArgumentString;
 
-		if (!tmpOperationGUID)
+		if (!tmpOperationHash)
 		{
 			console.log(`Error: operation argument is required.`);
 			return fCallback();
@@ -31,16 +38,16 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 
 		if (tmpDryRun)
 		{
-			console.log(`[DRY RUN] Would execute operation: ${tmpOperationGUID}`);
+			console.log(`[DRY RUN] Would execute operation: ${tmpOperationHash}`);
 			return fCallback();
 		}
 
-		console.log(`Executing operation: ${tmpOperationGUID}`);
+		console.log(`Executing operation: ${tmpOperationHash}`);
 
-		let tmpStateService = this.fable['Ultravisor-Hypervisor-State'];
-		let tmpOperationService = this.fable['Ultravisor-Operation'];
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		let tmpEngine = this._getService('UltravisorExecutionEngine');
 
-		tmpStateService.getOperation(tmpOperationGUID,
+		tmpStateService.getOperation(tmpOperationHash,
 			function (pError, pOperation)
 			{
 				if (pError)
@@ -49,8 +56,8 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 					return fCallback();
 				}
 
-				tmpOperationService.executeOperation(pOperation,
-					function (pExecError, pManifest)
+				tmpEngine.executeOperation(pOperation,
+					function (pExecError, pContext)
 					{
 						if (pExecError)
 						{
@@ -59,16 +66,20 @@ class UltravisorCommandSingleOperationRun extends libCommandLineCommand
 						}
 
 						console.log(`\nOperation Result:`);
-						console.log(`  Status: ${pManifest.Status}`);
-						console.log(`  Success: ${pManifest.Success}`);
-						console.log(`  Start: ${pManifest.StartTime}`);
-						console.log(`  Stop: ${pManifest.StopTime}`);
-						console.log(`  Tasks Executed: ${pManifest.TaskResults.length}`);
-						console.log(`  Summary: ${pManifest.Summary}`);
+						console.log(`  Status: ${pContext.Status}`);
+						console.log(`  Start: ${pContext.StartTime}`);
+						console.log(`  Stop: ${pContext.StopTime}`);
+						console.log(`  Elapsed: ${pContext.ElapsedMs}ms`);
+						let tmpTaskCount = pContext.TaskManifests ? Object.keys(pContext.TaskManifests).length : 0;
+						console.log(`  Tasks Executed: ${tmpTaskCount}`);
+						if (pContext.Errors && pContext.Errors.length > 0)
+						{
+							console.log(`  Errors: ${pContext.Errors.length}`);
+						}
 						return fCallback();
 					});
 			});
 	}
 }
 
-module.exports = UltravisorCommandSingleOperationRun;
+module.exports = UltravisorCommandSingleOperationRun;

package/source/cli/commands/Ultravisor-Command-SingleTask.cjs

@@ -9,8 +9,7 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 		this.options.CommandKeyword = 'singletask';
 		this.options.Description = 'Execute a single ultravisor task immediately, no matter what.';
 
-		this.options.CommandArguments.push({ Name: '<task>', Description: 'The task(s) to run.' });
-		this.options.CommandOptions.push({ Name: '-o, --operation [operation]', Description: 'The operation to scope the task(s) to.', Default: 'Default' });
+		this.options.CommandArguments.push({ Name: '<task>', Description: 'The task hash to run.' });
 		this.options.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the task.', Default: false });
 
 		this.options.Aliases.push('task');
@@ -18,11 +17,18 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
-		let tmpTaskGUID = this.ArgumentString;
+		let tmpTaskHash = this.ArgumentString;
 
-		if (!tmpTaskGUID)
+		if (!tmpTaskHash)
 		{
 			console.log(`Error: task argument is required.`);
 			return fCallback();
@@ -32,17 +38,17 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 
 		if (tmpDryRun)
 		{
-			console.log(`[DRY RUN] Would execute task: ${tmpTaskGUID}`);
+			console.log(`[DRY RUN] Would execute task: ${tmpTaskHash}`);
 			return fCallback();
 		}
 
-		console.log(`Executing task: ${tmpTaskGUID}`);
+		console.log(`Executing task: ${tmpTaskHash}`);
 
-		let tmpStateService = this.fable['Ultravisor-Hypervisor-State'];
-		let tmpTaskService = this.fable['Ultravisor-Task'];
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		let tmpEngine = this._getService('UltravisorExecutionEngine');
 
-		tmpStateService.getTask(tmpTaskGUID,
-			function (pError, pTask)
+		tmpStateService.getTaskDefinition(tmpTaskHash,
+			function (pError, pTaskDef)
 			{
 				if (pError)
 				{
@@ -50,8 +56,41 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 					return fCallback();
 				}
 
-				tmpTaskService.executeTask(pTask, {},
-					function (pExecError, pResult)
+				// Wrap single task in a minimal operation graph and execute
+				let tmpAdHocOperation = {
+					Hash: `ADHOC-${pTaskDef.Hash}`,
+					Name: `Ad-hoc: ${pTaskDef.Name || pTaskDef.Hash}`,
+					Graph:
+					{
+						Nodes:
+						[
+							{ Hash: 'start-node', Type: 'start', X: 0, Y: 100 },
+							{ Hash: pTaskDef.Hash, Type: pTaskDef.Type, DefinitionHash: pTaskDef.Type, Settings: pTaskDef.Settings || {}, X: 200, Y: 100 },
+							{ Hash: 'end-node', Type: 'end', X: 400, Y: 100 }
+						],
+						Connections:
+						[
+							{
+								SourceNodeHash: 'start-node',
+								SourcePortHash: 'start-node-eo-Start',
+								TargetNodeHash: pTaskDef.Hash,
+								TargetPortHash: pTaskDef.Hash + '-ei-Execute',
+								ConnectionType: 'Event'
+							},
+							{
+								SourceNodeHash: pTaskDef.Hash,
+								SourcePortHash: pTaskDef.Hash + '-eo-Complete',
+								TargetNodeHash: 'end-node',
+								TargetPortHash: 'end-node-ei-Finish',
+								ConnectionType: 'Event'
+							}
+						],
+						ViewState: {}
+					}
+				};
+
+				tmpEngine.executeOperation(tmpAdHocOperation,
+					function (pExecError, pContext)
 					{
 						if (pExecError)
 						{
@@ -60,13 +99,17 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 						}
 
 						console.log(`\nTask Result:`);
-						console.log(`  Status: ${pResult.Status}`);
-						console.log(`  Success: ${pResult.Success}`);
-						console.log(`  Start: ${pResult.StartTime}`);
-						console.log(`  Stop: ${pResult.StopTime}`);
-						if (pResult.Output)
+						console.log(`  Status: ${pContext.Status}`);
+						console.log(`  Start: ${pContext.StartTime}`);
+						console.log(`  Stop: ${pContext.StopTime}`);
+						console.log(`  Elapsed: ${pContext.ElapsedMs}ms`);
+						if (pContext.TaskOutputs && pContext.TaskOutputs[pTaskDef.Hash])
+						{
+							console.log(`  Output: ${JSON.stringify(pContext.TaskOutputs[pTaskDef.Hash]).substring(0, 1000)}`);
+						}
+						if (pContext.Errors && pContext.Errors.length > 0)
 						{
-							console.log(`  Output: ${pResult.Output.substring(0, 1000)}`);
+							console.log(`  Errors: ${pContext.Errors.length}`);
 						}
 						return fCallback();
 					});
@@ -74,4 +117,4 @@ class UltravisorCommandSingleTaskRun extends libCommandLineCommand
 	}
 }
 
-module.exports = UltravisorCommandSingleTaskRun;
+module.exports = UltravisorCommandSingleTaskRun;

package/source/cli/commands/Ultravisor-Command-UpdateTask.cjs

@@ -10,20 +10,25 @@ class UltravisorCommandAddTask extends libCommandLineCommand
 		super(pFable, pManifest, pServiceHash);
 
 		this.options.CommandKeyword = 'updatetask';
-		this.options.Description = 'Update (or add) a task to the available tasks.';
+		this.options.Description = 'Update (or add) a task definition.';
 
 		this.options.CommandOptions.push({ Name:'-f, --file [json_filepath]', Description:'JSON Task definition file path.', Default:false });
 
-		this.options.CommandOptions.push({ Name:'-g, --guid [task_guid]', Description:'The guid for the task.', Default:false });
-		this.options.CommandOptions.push({ Name:'-c, --code [task_code]', Description:'The code for the task.', Default:false });
+		this.options.CommandOptions.push({ Name:'-h, --hash [task_hash]', Description:'The hash for the task definition.', Default:false });
 		this.options.CommandOptions.push({ Name:'-n, --name [task_name]', Description:'The name of the task.', Default:false });
 
-		this.options.CommandOptions.push({ Name:'-t, --type [task_type]', Description:'The type of task.', Default:'CRON' });
-		this.options.CommandOptions.push({ Name:'-p, --parameters [task_parameters]', Description:'The parameters of the task.', Default:'0 0 * * * *' });
+		this.options.CommandOptions.push({ Name:'-t, --type [task_type]', Description:'The type of task (e.g. read-file, write-file, set-values).', Default:false });
 
 		this.addCommand();
 	}
 
+	_getService(pTypeName)
+	{
+		return this.fable.servicesMap[pTypeName]
+			? Object.values(this.fable.servicesMap[pTypeName])[0]
+			: null;
+	}
+
 	onRunAsync(fCallback)
 	{
 		const tmpOperationState = {};
@@ -64,28 +69,35 @@ class UltravisorCommandAddTask extends libCommandLineCommand
 
 		tmpOperationState.TaskDefinition_Parameterized = {};
 
-		tmpOperationState.TaskDefinition_Parameterized.GUIDTask = this.CommandOptions.guid;
-		tmpOperationState.TaskDefinition_Parameterized.Code = this.CommandOptions.code;
-		tmpOperationState.TaskDefinition_Parameterized.Name = this.CommandOptions.name;
-
-		tmpOperationState.TaskDefinition_Parameterized.Type = this.CommandOptions.type;
-		tmpOperationState.TaskDefinition_Parameterized.Parameters = this.CommandOptions.parameters;
+		if (this.CommandOptions.hash)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Hash = this.CommandOptions.hash;
+		}
+		if (this.CommandOptions.name)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Name = this.CommandOptions.name;
+		}
+		if (this.CommandOptions.type)
+		{
+			tmpOperationState.TaskDefinition_Parameterized.Type = this.CommandOptions.type;
+		}
 
 		tmpOperationState.TaskDefinition = Object.assign({}, tmpOperationState.TaskDefinition_Parameterized, tmpOperationState.JSONFile);
 
-		this.fable['Ultravisor-Hypervisor-State'].updateTask(tmpOperationState.TaskDefinition,
+		let tmpStateService = this._getService('UltravisorHypervisorState');
+		tmpStateService.updateTaskDefinition(tmpOperationState.TaskDefinition,
 			function (pError, pUpdatedTask)
 			{
 				if (pError)
 				{
-					return fCallback(new Error(`Could not update task: ${pError.message}`));
+					return fCallback(new Error(`Could not update task definition: ${pError.message}`));
 				}
 
-				console.log(`Task with GUID ${pUpdatedTask.GUIDTask} updated successfully.`);
+				console.log(`Task definition ${pUpdatedTask.Hash} updated successfully.`);
 
 				return fCallback();
 			}.bind(this));
 	}
 }
 
-module.exports = UltravisorCommandAddTask;
+module.exports = UltravisorCommandAddTask;

package/source/config/Ultravisor-Default-Command-Configuration.cjs

@@ -1,10 +1,19 @@
+let _ModuleRoot = require('path').resolve(__dirname, '..', '..');
+
 module.exports = (
 	{
 		"UltravisorAPIServerPort": 54321,
-		"UltravisorFileStorePath": `${process.cwd()}/dist/ultravisor_datastore`,
-		"UltravisorStagingRoot": `${process.cwd()}/dist/ultravisor_staging`,
+		"UltravisorFileStorePath": `${_ModuleRoot}/dist/ultravisor_datastore`,
+		"UltravisorStagingRoot": `${_ModuleRoot}/dist/ultravisor_staging`,
 		"UltravisorTickIntervalMilliseconds": 60000,
 		"UltravisorCommandTimeoutMilliseconds": 300000,
 		"UltravisorCommandMaxBufferBytes": 10485760,
-		"UltravisorWebInterfacePath": false
+		"UltravisorWebInterfacePath": `${_ModuleRoot}/webinterface/dist`,
+		"UltravisorOperationLibraryPath": `${_ModuleRoot}/operation-library`,
+
+		// Beacon worker configuration
+		"UltravisorBeaconHeartbeatTimeoutMs": 60000,
+		"UltravisorBeaconWorkItemTimeoutMs": 300000,
+		"UltravisorBeaconAffinityTTLMs": 3600000,
+		"UltravisorBeaconPollIntervalMs": 5000
 	});