ultravisor 1.0.0

package/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Debug Harness",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"program": "${workspaceFolder}/debug/Harness.js",
+            "cwd": "${workspaceFolder}/debug"
+		}
+	]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Steven Velozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# Ultravisor
+
+Like a supervisor, only instead of super it's ULTRA.  The hidden sixth hero of
+Voltron.  This tool allows you to run commands on schedule and process output
+with llm models, providing user-friendly summaries and links back to the full
+complete output from command running.
+
+## Use Cases
+
+* Periodic data pull from a REST API with localized storage
+* Data integrations between one system and another
+* Automatic execution of image generation models with randomized word choices
+* Parsing of massive sets of files for meaning leveraging ai
+
+## Primary Concepts
+
+Ultravisor operates on a few key concepts:
+
+* operation - one or many tasks that run in sequence and/or parallel
+* task - this is the verb... "what to do"
+* node - a specific executing ultravisor (often just one, but can be a cluster)
+* global state - data shared across all tasks
+* node state - data accessible locally only (when running with node affinity)
+* metaoutput - the output from tasks and operations
+* operation staging - temporary data from an operation
+* output file store - final file output from an operation
+* output data store - flexible database of final outputs from operations
+
+### Operations
+
+An operation is, generally speaking, a set of tasks.  Tasks can be composed to
+react to certain data/state situations.  With clever use of global state, they
+can even perform complicated series of actions across operations.
+
+For instance, I could have one operation that runs a number of tasks on a
+schedule to pull temperature from various locations in my house.  Each task
+can store the values in some kind of API, and, keep track of the latest value
+as well as timestamp in global state.  These tasks might run every 5-10 seconds
+or so; where they store the data may be 
+
+Then, a second operation could be running every minute that inspects the global
+state and adjusts a localized thermostat based on the current temperatures.
+
+Or maybe I have a NAS full of video files that I would like to run a series of
+machine learning algorithms on, to generate metadata on when scene cuts were
+made in each film.  I could setup an operation with a task to watch the cpu,
+iops and memory load of a machine and run parallel tasks that saturate the
+iops/cpu on the machine.  This would be a scheduled, parameterized parallel set
+of tasks.
+
+### Tasks
+
+Tasks can be really any program that is executable from a local shell, or,
+within a browser environment.  The browser part is especially interesting
+since you can basically script sets of actions within web pages (e.g.
+downloading all the files listed on a page... and/or enumerating all the pages
+and running the recursive download task for each page).
+
+Tasks can be executed based on a number of scenarios:
+
+* On a schedule (5pm every day, every 5 minutes, up to 5 times a minute)
+* After a condition is met (a condition in a browser, a disk drops below 5g)
+* After another task is completed (ffmpeg returns successfully transcoding)
+
+### Nodes
+
+Any execution of Ultravisor.  Can be distributed across multiple machines.
+
+When run with multiple nodes, there is a star topology with the capability for
+nodes to self promote to be the central node if the central node goes away.
+
+### Global State
+
+Global state is simple/plain JSON object that's synchronized across nodes.  It
+is meant to be used to store small facts and not process management state (e.g.
+it isn't an appropriate storage location for a mutex lock but is great for the
+most recent temperature readings from a set of sensors).
+
+### Node State
+
+Node state is similar to global state, but is only accessible to the local node
+the task is running on.  This is useful for storing configuration, paths or
+other node-specific information.
+
+### Metaoutput
+
+Metaoutput is the output from running tasks and operations.  It is stored in a
+simple JSON manifest including consistent fields for understanding:
+
+* Summary of Output
+* Start Time, Stop Time, Status, Success/Failure for the Operation
+* Start Time, Stop Time, Status, Success/Failure for each Task
+* Output Data (text, json, binary, files, etc.)
+* Run Log(s) for Tasks
+* Links to Output
+* Anything Else the Task/Operation Wants to Report
+
+### Operation Staging
+
+Operation staging is temporary storage for data during the execution of an
+operation.  This is useful for storing intermediate files, logs, or other data
+that is not needed after the operation completes.
+
+Operations can be flagged to have node affinity, or not.  If affinity is set,
+all tasks for the operation will run on the same node, allowing for enormous
+local file stores for the operation itself.  This is great for Machine Learning
+operations that need to store large source files, intermediate learning data
+and final output files.
+
+### Output File Store
+
+The centralized location for all final output files from operations.  This is
+meant to be a persistent storage location that is accessible across nodes.
+
+### Output Data Store
+
+The output data store is a flexible database for storing final output data from
+operations.  This can be used to store structured data, metadata, or any other
+information that needs to be queried or analyzed later.

package/debug/Harness.js

@@ -0,0 +1,4 @@
+let libUltravisor = require(`../source/cli/Ultravisor-CLIProgram.cjs`);
+
+//libUltravisor.run(['node', 'Harness.js', 'explain-config']);
+libUltravisor.run(['node', 'Harness.js', 'start']);

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "ultravisor",
+    "version": "1.0.0",
+    "description": "Cyclic process execution with ai integration.",
+    "main": "source/Ultravisor.js",
+    "bin": {
+        "ultravisor": "./source/cli/Ultravisor-Run.cjs"
+    },
+    "scripts": {
+        "start": "node source/cli/Ultravisor-Run.cjs",
+        "test": "npx mocha -u tdd -R spec",
+        "tests": "npx mocha -u tdd --exit -R spec --grep",
+        "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec",
+        "build": "npx quack build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/stevenvelozo/ultravisor.git"
+    },
+    "author": "steven@velozo.com",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/ultravisor/issues"
+    },
+    "homepage": "https://github.com/stevenvelozo/ultravisor#readme",
+    "dependencies": {
+        "orator": "^5.0.1",
+        "orator-serviceserver-restify": "^2.0.5",
+        "pict": "^1.0.343",
+        "pict-service-commandlineutility": "^1.0.17",
+        "pict-serviceproviderbase": "^1.0.0"
+    },
+    "mocha": {
+        "diff": true,
+        "extension": [
+            "js"
+        ],
+        "package": "./package.json",
+        "reporter": "spec",
+        "slow": "75",
+        "timeout": "5000",
+        "ui": "tdd",
+        "watch-files": [
+            "source/**/*.js",
+            "test/**/*.js"
+        ],
+        "watch-ignore": [
+            "lib/vendor"
+        ]
+    }
+}

package/source/Ultravisor.cjs

@@ -0,0 +1,5 @@
+module.exports = (
+	{
+		Operation: requestAnimationFrame(`./services/Ultravisor-Operation.cjs`),
+		Task: requestAnimationFrame(`./services/Ultravisor-Task.cjs`),
+	});

package/source/cli/Ultravisor-CLIProgram.cjs

@@ -0,0 +1,79 @@
+const libCLIProgram = require('pict-service-commandlineutility');
+
+const libServiceHypervisor = require(`../services/Ultravisor-Hypervisor.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 libServiceOperation = require(`../services/Ultravisor-Operation.cjs`);
+const libServiceOperationManifest = require(`../services/Ultravisor-Operation-Manifest.cjs`);
+
+const libServiceTask = require(`../services/Ultravisor-Task.cjs`);
+
+// TODO: Remove this when Restify is fixed.
+process.removeAllListeners('warning')
+
+const libWebServerAPIServer = require(`../web_server/Ultravisor-API-Server.cjs`);
+
+let _Ultravisor_Pict = new libCLIProgram(
+	{
+		"Product": "Ultravisor-CLI",
+		"Version": require('../../package.json').version,
+		"Description": require('../../package.json').description,
+
+		"Package": require('../../package.json'),
+
+		"LogStreams":
+			[
+				{
+					"level": "trace",
+					"streamtype": "process.stdout"
+				}
+			],
+
+		"Command": "ultravisor",
+
+		"DefaultProgramConfiguration": require(`../config/Ultravisor-Default-Command-Configuration.cjs`),
+
+		"ProgramConfigurationFileName": ".ultravisor.json",
+
+		"AutoGatherProgramConfiguration": true,
+		"AutoAddConfigurationExplanationCommand": true
+	},
+	[
+		// Display the current ultravisor schedule
+		require('./commands/Ultravisor-Command-ScheduleView.cjs'),
+
+		// Add a task or operation to the current ultravisor schedule
+		require('./commands/Ultravisor-Command-ScheduleOperation.cjs'),
+		require('./commands/Ultravisor-Command-ScheduleTask.cjs'),
+
+		// Execute a single operation or task immediately, no matter what
+		require('./commands/Ultravisor-Command-SingleOperation.cjs'),
+		require('./commands/Ultravisor-Command-SingleTask.cjs'),
+
+		// Start and/or stop the hypervisor, API and web server
+		require('./commands/Ultravisor-Command-Start.cjs'),
+		require('./commands/Ultravisor-Command-Stop.cjs')
+	]);
+
+// Instantiate the file persistence service
+_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-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('Ultravisor-Operation', libServiceOperation);
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Operation-Manifest', libServiceOperationManifest);
+
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-Task', libServiceTask);
+
+_Ultravisor_Pict.fable.addAndInstantiateServiceTypeIfNotExists('Ultravisor-API-Server', libWebServerAPIServer);
+
+module.exports = _Ultravisor_Pict;

package/source/cli/Ultravisor-Run.cjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+let libQuackage = require('./Ultravisor-CLIProgram.cjs');
+libQuackage.run();

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

@@ -0,0 +1,28 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandScheduleOperation extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'schedule_operation';
+		this.options.Description = 'Add an operation to the schedule.';
+
+		this.options.CommandArguments.push({ Name: '<operation>', Description: 'The operation to add to the schedule.' });
+
+		this.options.CommandOptions.push({ Name: '-t, --type [event_schedule_type]', Description: 'The event schedule type (cron, daily, hourly, solver).', Default: 'cron' });
+		this.options.CommandOptions.push({ Name: '-p, --parameters [event_schedule_parameters]', Description: 'The parameters for the schedule (e.g. the crontab entry or solver string).', Default: '' });
+
+		this.options.Aliases.push('so');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandScheduleOperation;

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

@@ -0,0 +1,28 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandScheduleTask extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'schedule_task';
+		this.options.Description = 'Add a task to the schedule.';
+
+		this.options.CommandArguments.push({ Name: '<task>', Description: 'The task to add to the schedule.' });
+
+		this.options.CommandOptions.push({ Name: '-t, --type [event_schedule_type]', Description: 'The event schedule type (cron, daily, hourly, solver).', Default: 'cron' });
+		this.options.CommandOptions.push({ Name: '-p, --parameters [event_schedule_parameters]', Description: 'The parameters for the schedule (e.g. the crontab entry or solver string).', Default: '' });
+
+		this.options.Aliases.push('st');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandScheduleTask;

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

@@ -0,0 +1,25 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandScheduleView extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'schedule';
+		this.options.Description = 'View the schedule.';
+
+		this.options.CommandOptions.push({ Name: '-f, --format [schedule_format]', Description: 'The visualization format (day, week, month) to output.', Default: 'day' });
+
+		this.options.Aliases.push('cal');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandScheduleView;

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

@@ -0,0 +1,26 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandSingleOperationRun extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		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.Aliases.push('operation');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandSingleOperationRun;

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

@@ -0,0 +1,27 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandSingleTaskRun extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		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.CommandOptions.push({ Name: '-d, --dry_run', Description: 'Dry run the task.', Default: false });
+
+		this.options.Aliases.push('task');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandSingleTaskRun;

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

@@ -0,0 +1,25 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandStartService extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'start';
+		this.options.Description = 'Start the Ultravisor service.';
+
+		this.options.CommandOptions.push({ Name: '-v, --verbose', Description: 'Provide verbose console output.', Default: false });
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		// TODO: What to do with verbose!
+		console.log(`Starting Ultravisor API Server...`);
+		return this.fable['Ultravisor-API-Server'].start(fCallback);
+	}
+}
+
+module.exports = UltravisorCommandStartService;

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

@@ -0,0 +1,21 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+class UltravisorCommandStopService extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'stop';
+		this.options.Description = 'Stop the Ultravisor service.';
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		return fCallback();
+	}
+}
+
+module.exports = UltravisorCommandStopService;

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

@@ -0,0 +1,5 @@
+module.exports = (
+	{
+		"UltravisorAPIServerPort": 54321,
+		"UltravisorFileStorePath": `${process.cwd()}/dist/ultravisor_datastore`
+	});

package/source/services/Ultravisor-Hypervisor-Event-Base.cjs

@@ -0,0 +1,11 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+class UltravisorEventBase extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorEventBase;

package/source/services/Ultravisor-Hypervisor.cjs

@@ -0,0 +1,11 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+class UltravisorHypervisor extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorHypervisor;

package/source/services/Ultravisor-Operation-Manifest.cjs

@@ -0,0 +1,11 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+class UltravisorOperationManifest extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorOperationManifest;

package/source/services/Ultravisor-Operation.cjs

@@ -0,0 +1,11 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+class UltravisorOperation extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorOperation;

package/source/services/Ultravisor-Task.cjs

@@ -0,0 +1,11 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+class UltravisorTask extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorTask;

package/source/services/events/Ultravisor-Hypervisor-Event-Cron.cjs

@@ -0,0 +1,11 @@
+const libUltravisorEventBase = require(`../Ultravisor-Hypervisor-Event-Base.cjs`);
+
+class UltravisorEventCron extends libUltravisorEventBase
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorEventCron;

package/source/services/events/Ultravisor-Hypervisor-Event-Solver.cjs

@@ -0,0 +1,11 @@
+const libUltravisorEventBase = require(`../Ultravisor-Hypervisor-Event-Base.cjs`);
+
+class UltravisorEventSolver extends libUltravisorEventBase
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+	}
+}
+
+module.exports = UltravisorEventSolver;

package/source/web_server/Ultravisor-API-Server.cjs

@@ -0,0 +1,119 @@
+const libPictService = require(`pict-serviceproviderbase`);
+
+const libOrator = require('orator');
+const libOratorServiceServerRestify = require(`orator-serviceserver-restify`);
+
+class UltravisorAPIServer extends libPictService
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+
+		// Add Restify as the default service server type
+		this.fable.addServiceTypeIfNotExists('OratorServiceServer', libOratorServiceServerRestify);
+		this._OratorServer = this.fable.instantiateServiceProvider('OratorServiceServer', {});
+
+		// Add Orator as a service
+		this.fable.addServiceTypeIfNotExists('Orator', libOrator);
+	}
+
+	wireEndpoints(fCallback)
+	{
+		if (!this._Orator)
+		{
+			return fCallback(new Error(`Ultravisor API Server: Cannot wire endpoints; Orator service is not initialized.`));
+		}
+
+		this._OratorServer.get
+			(
+				'/package',
+				(pRequest, pResponse, fNext) =>
+				{
+					// Send back the request parameters
+					pResponse.send(this.pict.settings.Package);
+					return fNext();
+				}
+			);
+
+		return fCallback();
+	}
+
+	start(fCallback)
+	{
+		const tmpAnticipate = this.fable.newAnticipate();
+
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				// Initialize the Orator service
+				if (!this.fable.settings.APIServerPort)
+				{
+					if (this.fable?.ProgramConfiguration?.UltravisorAPIServerPort)
+					{
+						this.fable.settings.APIServerPort = this.fable.ProgramConfiguration.UltravisorAPIServerPort;
+					}
+					else
+					{
+						this.fable.settings.APIServerPort = 55555;
+					}
+				}
+				return fNext();
+			}.bind(this));
+
+		this._Orator = this.fable.instantiateServiceProvider('Orator', {});
+
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.log.info(`Initializing Ultravisor Orator API Server on port ${this.fable.settings.APIServerPort}`);
+				this._Orator.initialize(
+					function (pError)
+					{
+						if (pError)
+						{
+							this.log.info(`Error initializing Orator for Ultravisor ${pError}`, pError);
+							return fCallback(pError);
+						}
+						this.log.info(`Orator initialized for Ultravisor API Server on port ${this.fable.settings.APIServerPort}`);
+						return fNext();
+					}.bind(this));
+			}.bind(this));
+
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.wireEndpoints(
+					function (pError)
+					{
+						if (pError)
+						{
+							this.log.info(`Error wiring Ultravisor API Server endpoints: ${pError}`, pError);
+							return fCallback(pError);
+						}
+						this.log.info(`Ultravisor API Server endpoints wired successfully.`);
+						return fNext();
+					}.bind(this));
+			}.bind(this));
+
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.log.info(`Starting Ultravisor Orator API Server on port ${this.fable.settings.APIServerPort}`);
+				this._Orator.startService(fNext);
+			}.bind(this));
+
+		tmpAnticipate.wait(
+			function (pError)
+			{
+				if (pError)
+				{
+					this.log.info(`Error starting Ultravisor API Server: ${pError}`, pError);
+					return fCallback(pError);
+				}
+				this.log.info(`Ultravisor Orator API Server started successfully.`);
+				return fCallback();
+			}.bind(this));
+	}
+}
+
+module.exports = UltravisorAPIServer;

package/test/Ultravisor_tests.js

@@ -0,0 +1,34 @@
+/**
+* Unit tests for Ultravisor
+*/
+
+var libUltravisor = require('../source/cli/Ultravisor-CLIProgram.cjs');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'Ultravisor',
+	function()
+	{
+		setup ( () => {} );
+
+		suite
+		(
+			'Execution Sanity',
+			function()
+			{
+				test
+				(
+					'Ultravisor should load up okay.',
+					function()
+					{
+						let testUltravisor = libUltravisor;
+						Expect(testUltravisor.settings.Product).to.equal('Ultravisor-CLI');
+					}
+				);
+			}
+		);
+	}
+);