ultravisor 1.0.3 → 1.0.8

package/source/services/tasks/data-transform/Ultravisor-TaskType-ReplaceString.cjs

@@ -0,0 +1,80 @@
+const libTaskTypeBase = require('../Ultravisor-TaskType-Base.cjs');
+
+/**
+ * ReplaceString Task Type
+ *
+ * Performs string find-and-replace on InputString.
+ * Replaces all occurrences of SearchString with ReplaceString.
+ */
+class UltravisorTaskTypeReplaceString extends libTaskTypeBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'UltravisorTaskTypeReplaceString';
+	}
+
+	get definition()
+	{
+		return require('./definitions/replace-string.json');
+	}
+
+	execute(pResolvedSettings, pExecutionContext, fCallback, fFireIntermediateEvent)
+	{
+		let tmpInputString = pResolvedSettings.InputString;
+		let tmpSearchString = pResolvedSettings.SearchString;
+		let tmpReplaceString = pResolvedSettings.ReplaceString || '';
+
+		if (typeof(tmpInputString) !== 'string')
+		{
+			return fCallback(null, {
+				EventToFire: 'Error',
+				Outputs: {},
+				Log: ['InputString is not a string.']
+			});
+		}
+
+		if (!tmpSearchString || typeof(tmpSearchString) !== 'string')
+		{
+			return fCallback(null, {
+				EventToFire: 'Error',
+				Outputs: {},
+				Log: ['SearchString is empty or not a string.']
+			});
+		}
+
+		let tmpUseRegex = pResolvedSettings.UseRegex;
+		let tmpCaseSensitive = pResolvedSettings.CaseSensitive !== false;
+		let tmpResult;
+		let tmpReplacementCount = 0;
+
+		if (tmpUseRegex)
+		{
+			let tmpFlags = 'g' + (tmpCaseSensitive ? '' : 'i');
+			let tmpRegex = new RegExp(tmpSearchString, tmpFlags);
+			tmpReplacementCount = (tmpInputString.match(tmpRegex) || []).length;
+			tmpResult = tmpInputString.replace(tmpRegex, tmpReplaceString);
+		}
+		else if (!tmpCaseSensitive)
+		{
+			let tmpEscaped = tmpSearchString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			let tmpRegex = new RegExp(tmpEscaped, 'gi');
+			tmpReplacementCount = (tmpInputString.match(tmpRegex) || []).length;
+			tmpResult = tmpInputString.replace(tmpRegex, tmpReplaceString);
+		}
+		else
+		{
+			tmpReplacementCount = tmpInputString.split(tmpSearchString).length - 1;
+			tmpResult = tmpInputString.split(tmpSearchString).join(tmpReplaceString);
+		}
+
+		return fCallback(null, {
+			EventToFire: 'ReplaceComplete',
+			Outputs: { ReplacedString: tmpResult, ReplacementCount: tmpReplacementCount },
+			Log: [`Replaced "${tmpSearchString}" with "${tmpReplaceString}" (${tmpReplacementCount} occurrences).`]
+		});
+	}
+}
+
+module.exports = UltravisorTaskTypeReplaceString;

package/source/services/tasks/data-transform/Ultravisor-TaskType-SetValues.cjs

@@ -0,0 +1,74 @@
+const libTaskTypeBase = require('../Ultravisor-TaskType-Base.cjs');
+
+/**
+ * SetValues Task Type
+ *
+ * Sets one or more values in state at specified addresses.
+ * Used for initializing state, transforming data between levels, or
+ * setting computed values.
+ *
+ * Settings.Mappings is an array of { Address, Value } objects.
+ * Each mapping sets the value at the given state address.
+ */
+class UltravisorTaskTypeSetValues extends libTaskTypeBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'UltravisorTaskTypeSetValues';
+	}
+
+	get definition()
+	{
+		return require('./definitions/set-values.json');
+	}
+
+	execute(pResolvedSettings, pExecutionContext, fCallback, fFireIntermediateEvent)
+	{
+		let tmpMappings = pResolvedSettings.Mappings;
+
+		if (!Array.isArray(tmpMappings))
+		{
+			if (tmpMappings !== undefined && tmpMappings !== null)
+			{
+				return fCallback(null, {
+					EventToFire: 'Error',
+					Outputs: {},
+					Log: ['Mappings is not an array.']
+				});
+			}
+			return fCallback(null, {
+				EventToFire: 'Complete',
+				Outputs: {},
+				Log: ['No mappings provided.']
+			});
+		}
+
+		let tmpStateWrites = {};
+		let tmpLog = [];
+
+		for (let i = 0; i < tmpMappings.length; i++)
+		{
+			let tmpMapping = tmpMappings[i];
+
+			if (!tmpMapping || !tmpMapping.Address)
+			{
+				tmpLog.push(`Mapping ${i}: skipped (no Address).`);
+				continue;
+			}
+
+			tmpStateWrites[tmpMapping.Address] = tmpMapping.Value;
+			tmpLog.push(`Set [${tmpMapping.Address}] = ${JSON.stringify(tmpMapping.Value)}`);
+		}
+
+		return fCallback(null, {
+			EventToFire: 'Complete',
+			Outputs: {},
+			StateWrites: tmpStateWrites,
+			Log: tmpLog
+		});
+	}
+}
+
+module.exports = UltravisorTaskTypeSetValues;

package/source/services/tasks/data-transform/Ultravisor-TaskType-StringAppender.cjs

@@ -0,0 +1,90 @@
+const libTaskTypeBase = require('../Ultravisor-TaskType-Base.cjs');
+
+/**
+ * StringAppender Task Type
+ *
+ * Appends InputString to the value at OutputAddress.
+ * If the target address is empty/undefined, sets it to InputString.
+ * Useful for accumulating results across loop iterations (e.g., split-execute).
+ */
+class UltravisorTaskTypeStringAppender extends libTaskTypeBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'UltravisorTaskTypeStringAppender';
+	}
+
+	get definition()
+	{
+		return require('./definitions/string-appender.json');
+	}
+
+	execute(pResolvedSettings, pExecutionContext, fCallback, fFireIntermediateEvent)
+	{
+		let tmpInputString = pResolvedSettings.InputString;
+		let tmpOutputAddress = pResolvedSettings.OutputAddress;
+
+		if (typeof(tmpInputString) !== 'string')
+		{
+			tmpInputString = String(tmpInputString !== undefined ? tmpInputString : '');
+		}
+
+		if (!tmpOutputAddress || typeof(tmpOutputAddress) !== 'string')
+		{
+			// No output address — just pass through as output
+			return fCallback(null, {
+				EventToFire: 'Completed',
+				Outputs: {
+					AppendedString: tmpInputString
+				},
+				Log: ['No OutputAddress specified, returning InputString as AppendedString.']
+			});
+		}
+
+		// Read the existing value at the output address
+		let tmpStateManager = pExecutionContext.StateManager;
+		let tmpExistingValue = '';
+
+		if (tmpStateManager)
+		{
+			let tmpResolved = tmpStateManager.resolveAddress(tmpOutputAddress, pExecutionContext, pExecutionContext.NodeHash);
+
+			if (tmpResolved !== undefined && tmpResolved !== null)
+			{
+				tmpExistingValue = String(tmpResolved);
+			}
+		}
+
+		let tmpAppendedValue;
+
+		if (pResolvedSettings.Separator)
+		{
+			tmpAppendedValue = tmpExistingValue + (tmpExistingValue.length > 0 ? pResolvedSettings.Separator : '') + tmpInputString;
+		}
+		else
+		{
+			if (pResolvedSettings.AppendNewline)
+			{
+				tmpInputString = tmpInputString + '\n';
+			}
+
+			tmpAppendedValue = tmpExistingValue + tmpInputString;
+		}
+
+		let tmpStateWrites = {};
+		tmpStateWrites[tmpOutputAddress] = tmpAppendedValue;
+
+		return fCallback(null, {
+			EventToFire: 'Completed',
+			Outputs: {
+				AppendedString: tmpAppendedValue
+			},
+			StateWrites: tmpStateWrites,
+			Log: [`Appended ${tmpInputString.length} chars to [${tmpOutputAddress}] (total: ${tmpAppendedValue.length}).`]
+		});
+	}
+}
+
+module.exports = UltravisorTaskTypeStringAppender;

package/source/services/tasks/data-transform/definitions/comprehension-intersect.json

@@ -0,0 +1,24 @@
+{
+	"Hash": "comprehension-intersect",
+	"Type": "comprehension-intersect",
+	"Name": "Comprehension Intersect",
+	"Description": "Intersects two arrays by matching a common field.",
+	"Category": "pipeline",
+	"Capability": "Data Transform",
+	"Action": "Intersect",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Execute" }],
+	"EventOutputs": [{ "Name": "Complete" }],
+	"SettingsInputs": [
+		{ "Name": "SourceAddressA", "DataType": "String", "Required": true, "Description": "State address of the first array" },
+		{ "Name": "SourceAddressB", "DataType": "String", "Required": true, "Description": "State address of the second array" },
+		{ "Name": "MatchField", "DataType": "String", "Required": false, "Description": "Field name to match records on" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store the result" },
+		{ "Name": "JoinType", "DataType": "String", "Required": false, "Description": "Join type: inner (default)" }
+	],
+	"StateOutputs": [
+		{ "Name": "Result", "DataType": "Array", "Description": "Intersected records" },
+		{ "Name": "MatchCount", "DataType": "Number", "Description": "Number of matched records" }
+	],
+	"DefaultSettings": { "SourceAddressA": "", "SourceAddressB": "", "MatchField": "", "Destination": "", "JoinType": "inner" }
+}

package/source/services/tasks/data-transform/definitions/csv-transform.json

@@ -0,0 +1,24 @@
+{
+	"Hash": "csv-transform",
+	"Type": "csv-transform",
+	"Name": "CSV Transform",
+	"Description": "Transforms parsed CSV records using a template per row.",
+	"Category": "pipeline",
+	"Capability": "Data Transform",
+	"Action": "TransformCSV",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Execute" }],
+	"EventOutputs": [{ "Name": "Complete" }],
+	"SettingsInputs": [
+		{ "Name": "SourceAddress", "DataType": "String", "Required": false, "Description": "State address of the records array" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store transformed records" },
+		{ "Name": "Delimiter", "DataType": "String", "Required": false, "Description": "Delimiter for re-serialization" },
+		{ "Name": "FieldMapping", "DataType": "String", "Required": false, "Description": "JSON array of field mappings [{From, To, Template}]" },
+		{ "Name": "FilterExpression", "DataType": "String", "Required": false, "Description": "Expression to filter rows" },
+		{ "Name": "OutputFields", "DataType": "String", "Required": false, "Description": "JSON array of field names to include in output" }
+	],
+	"StateOutputs": [
+		{ "Name": "Records", "DataType": "Array", "Description": "Transformed records" }
+	],
+	"DefaultSettings": { "SourceAddress": "", "Destination": "", "Delimiter": ",", "FieldMapping": "", "FilterExpression": "", "OutputFields": "" }
+}

package/source/services/tasks/data-transform/definitions/expression-solver.json

@@ -0,0 +1,20 @@
+{
+	"Hash": "expression-solver",
+	"Type": "expression-solver",
+	"Name": "Expression Solver",
+	"Description": "Evaluates an expression using Fable ExpressionParser.",
+	"Category": "core",
+	"Capability": "Data Transform",
+	"Action": "EvaluateExpression",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "In" }],
+	"EventOutputs": [{ "Name": "Complete" }, { "Name": "Error", "IsError": true }],
+	"SettingsInputs": [
+		{ "Name": "Expression", "DataType": "String", "Required": true, "Description": "Expression to evaluate" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store the result" }
+	],
+	"StateOutputs": [
+		{ "Name": "Result", "DataType": "String", "Description": "Evaluation result" }
+	],
+	"DefaultSettings": { "Expression": "", "Destination": "" }
+}

package/source/services/tasks/data-transform/definitions/histogram.json

@@ -0,0 +1,23 @@
+{
+	"Hash": "histogram",
+	"Type": "histogram",
+	"Name": "Histogram",
+	"Description": "Computes a frequency distribution over a field in a dataset.",
+	"Category": "pipeline",
+	"Capability": "Data Transform",
+	"Action": "Histogram",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Execute" }],
+	"EventOutputs": [{ "Name": "Complete" }],
+	"SettingsInputs": [
+		{ "Name": "SourceAddress", "DataType": "String", "Required": false, "Description": "State address of the data array" },
+		{ "Name": "Field", "DataType": "String", "Required": false, "Description": "Field name to analyze" },
+		{ "Name": "Bins", "DataType": "Number", "Required": false, "Description": "Number of bins for numeric data" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store stats" },
+		{ "Name": "SortBy", "DataType": "String", "Required": false, "Description": "Sort frequency results by \"count\" or \"key\"" }
+	],
+	"StateOutputs": [
+		{ "Name": "Stats", "DataType": "Object", "Description": "Histogram / frequency distribution" }
+	],
+	"DefaultSettings": { "SourceAddress": "", "Field": "score", "Bins": 5, "Destination": "", "SortBy": "" }
+}

package/source/services/tasks/data-transform/definitions/parse-csv.json

@@ -0,0 +1,27 @@
+{
+	"Hash": "parse-csv",
+	"Type": "parse-csv",
+	"Name": "Parse CSV",
+	"Description": "Parses CSV text into an array of records.",
+	"Category": "pipeline",
+	"Capability": "Data Transform",
+	"Action": "ParseCSV",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Execute" }],
+	"EventOutputs": [{ "Name": "Complete" }],
+	"SettingsInputs": [
+		{ "Name": "SourceAddress", "DataType": "String", "Required": false, "Description": "State address of the CSV text to parse" },
+		{ "Name": "Delimiter", "DataType": "String", "Required": false, "Description": "Column delimiter" },
+		{ "Name": "HasHeaders", "DataType": "Boolean", "Required": false, "Description": "When true, first row is used as field names" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store parsed records" },
+		{ "Name": "QuoteCharacter", "DataType": "String", "Required": false, "Description": "Character used to quote fields containing the delimiter" },
+		{ "Name": "TrimFields", "DataType": "Boolean", "Required": false, "Description": "Trim whitespace from field values" },
+		{ "Name": "SkipEmptyLines", "DataType": "Boolean", "Required": false, "Description": "Skip empty lines in the input" }
+	],
+	"StateOutputs": [
+		{ "Name": "Records", "DataType": "Array", "Description": "Parsed rows" },
+		{ "Name": "ColumnCount", "DataType": "Number", "Description": "Number of columns found" },
+		{ "Name": "Headers", "DataType": "Array", "Description": "Parsed header names" }
+	],
+	"DefaultSettings": { "SourceAddress": "", "Delimiter": ",", "HasHeaders": true, "Destination": "", "QuoteCharacter": "\"", "TrimFields": true, "SkipEmptyLines": true }
+}

package/source/services/tasks/data-transform/definitions/replace-string.json

@@ -0,0 +1,27 @@
+{
+	"Hash": "replace-string",
+	"Type": "replace-string",
+	"Name": "Replace String",
+	"Description": "Replaces all occurrences of a search string within the input.",
+	"Category": "data",
+	"Capability": "Data Transform",
+	"Action": "ReplaceString",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Replace" }],
+	"EventOutputs": [
+		{ "Name": "ReplaceComplete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "InputString", "DataType": "String", "Required": true },
+		{ "Name": "SearchString", "DataType": "String", "Required": true },
+		{ "Name": "ReplaceString", "DataType": "String", "Required": false },
+		{ "Name": "UseRegex", "DataType": "Boolean", "Required": false, "Description": "Treat SearchString as a regular expression" },
+		{ "Name": "CaseSensitive", "DataType": "Boolean", "Required": false, "Description": "Case-sensitive matching (default true)" }
+	],
+	"StateOutputs": [
+		{ "Name": "ReplacedString", "DataType": "String" },
+		{ "Name": "ReplacementCount", "DataType": "Number", "Description": "Number of replacements made" }
+	],
+	"DefaultSettings": { "InputString": "", "SearchString": "", "ReplaceString": "", "UseRegex": false, "CaseSensitive": true }
+}

package/source/services/tasks/data-transform/definitions/set-values.json

@@ -0,0 +1,17 @@
+{
+	"Hash": "set-values",
+	"Type": "set-values",
+	"Name": "Set Values",
+	"Description": "Sets one or more values in state at specified addresses.",
+	"Category": "data",
+	"Capability": "Data Transform",
+	"Action": "SetValues",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Execute" }],
+	"EventOutputs": [{ "Name": "Complete" }, { "Name": "Error", "IsError": true }],
+	"SettingsInputs": [
+		{ "Name": "Mappings", "DataType": "Array", "Required": true }
+	],
+	"StateOutputs": [],
+	"DefaultSettings": { "Mappings": [] }
+}

package/source/services/tasks/data-transform/definitions/string-appender.json

@@ -0,0 +1,22 @@
+{
+	"Hash": "string-appender",
+	"Type": "string-appender",
+	"Name": "String Appender",
+	"Description": "Appends a string to a value at a specified state address.",
+	"Category": "data",
+	"Capability": "Data Transform",
+	"Action": "AppendString",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Append" }],
+	"EventOutputs": [{ "Name": "Completed" }],
+	"SettingsInputs": [
+		{ "Name": "InputString", "DataType": "String", "Required": true },
+		{ "Name": "OutputAddress", "DataType": "String", "Required": true },
+		{ "Name": "AppendNewline", "DataType": "Boolean", "Required": false, "Description": "When true, append a newline after each InputString." },
+		{ "Name": "Separator", "DataType": "String", "Required": false, "Description": "String to insert between existing and new content. Overrides AppendNewline when set." }
+	],
+	"StateOutputs": [
+		{ "Name": "AppendedString", "DataType": "String" }
+	],
+	"DefaultSettings": { "InputString": "", "OutputAddress": "", "AppendNewline": false, "Separator": "" }
+}

package/source/services/tasks/data-transform/definitions/template-string.json

@@ -0,0 +1,20 @@
+{
+	"Hash": "template-string",
+	"Type": "template-string",
+	"Name": "Template String",
+	"Description": "Processes a Pict template string against the current state.",
+	"Category": "core",
+	"Capability": "Data Transform",
+	"Action": "Template",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "In" }],
+	"EventOutputs": [{ "Name": "Complete" }, { "Name": "Error", "IsError": true }],
+	"SettingsInputs": [
+		{ "Name": "Template", "DataType": "String", "Required": true, "Description": "Pict template string with {~D:...~} expressions" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store the result" }
+	],
+	"StateOutputs": [
+		{ "Name": "Result", "DataType": "String", "Description": "Rendered template output" }
+	],
+	"DefaultSettings": { "Template": "", "Destination": "" }
+}

package/source/services/tasks/extension/Ultravisor-TaskConfigs-Extension.cjs

@@ -0,0 +1,87 @@
+/**
+ * Task configurations for the "Extension" capability.
+ *
+ * Contains:
+ *   - beacon-dispatch   — Dispatches work to a remote Beacon worker node.
+ */
+
+
+/**
+ * Get a named service from the Fable services map.
+ */
+function _getService(pTask, pTypeName)
+{
+	return pTask.fable.servicesMap[pTypeName]
+		? Object.values(pTask.fable.servicesMap[pTypeName])[0]
+		: null;
+}
+
+
+module.exports =
+[
+	// ── beacon-dispatch ────────────────────────────────────────
+	{
+		Definition: require('./definitions/beacon-dispatch.json'),
+		Execute: function (pTask, pResolvedSettings, pExecutionContext, fCallback)
+		{
+			let tmpCoordinator = _getService(pTask, 'UltravisorBeaconCoordinator');
+
+			if (!tmpCoordinator)
+			{
+				return fCallback(null, {
+					EventToFire: 'Error',
+					Outputs: { StdOut: 'BeaconCoordinator service not available.', ExitCode: -1, Result: '', BeaconID: '' },
+					Log: ['Beacon Dispatch: BeaconCoordinator service not found.']
+				});
+			}
+
+			// Check if any Beacons are registered
+			let tmpBeacons = tmpCoordinator.listBeacons();
+			if (tmpBeacons.length === 0)
+			{
+				return fCallback(null, {
+					EventToFire: 'Error',
+					Outputs: { StdOut: 'No Beacon workers are registered.', ExitCode: -1, Result: '', BeaconID: '' },
+					Log: ['Beacon Dispatch: no Beacon workers registered. Cannot dispatch work.']
+				});
+			}
+
+			// Build work item from resolved settings
+			let tmpWorkItemInfo = {
+				RunHash: pExecutionContext.RunHash,
+				NodeHash: pExecutionContext.NodeHash,
+				OperationHash: pExecutionContext.OperationHash,
+				Capability: pResolvedSettings.RemoteCapability || 'Shell',
+				Action: pResolvedSettings.RemoteAction || 'Execute',
+				Settings: {
+					Command: pResolvedSettings.Command || '',
+					Parameters: pResolvedSettings.Parameters || '',
+					InputData: pResolvedSettings.InputData || ''
+				},
+				AffinityKey: pResolvedSettings.AffinityKey || '',
+				TimeoutMs: pResolvedSettings.TimeoutMs || 300000
+			};
+
+			// Enqueue the work item
+			let tmpWorkItem = tmpCoordinator.enqueueWorkItem(tmpWorkItemInfo);
+
+			pTask.log.info(`Beacon Dispatch: enqueued work item [${tmpWorkItem.WorkItemHash}] for capability [${tmpWorkItemInfo.Capability}/${tmpWorkItemInfo.Action}]` +
+				(tmpWorkItemInfo.AffinityKey ? ` with affinity [${tmpWorkItemInfo.AffinityKey}]` : ''));
+
+			// Pause execution — the BeaconCoordinator will call resumeOperation when the Beacon reports back
+			return fCallback(null, {
+				WaitingForInput: true,
+				ResumeEventName: 'Complete',
+				PromptMessage: `Waiting for Beacon worker (${tmpWorkItemInfo.Capability}/${tmpWorkItemInfo.Action})`,
+				OutputAddress: '',
+				Outputs: {},
+				Log: [
+					`Beacon Dispatch: dispatched to work queue as [${tmpWorkItem.WorkItemHash}].`,
+					`Capability: ${tmpWorkItemInfo.Capability}, Action: ${tmpWorkItemInfo.Action}`,
+					tmpWorkItemInfo.AffinityKey ? `Affinity: ${tmpWorkItemInfo.AffinityKey}` : 'No affinity key',
+					tmpWorkItemInfo.Settings.Command ? `Command: ${tmpWorkItemInfo.Settings.Command} ${tmpWorkItemInfo.Settings.Parameters}` : ''
+				].filter(Boolean)
+			});
+		}
+	}
+];

package/source/services/tasks/extension/definitions/beacon-dispatch.json

@@ -0,0 +1,32 @@
+{
+	"Hash": "beacon-dispatch",
+	"Type": "beacon-dispatch",
+	"Name": "Beacon Dispatch",
+	"Description": "Dispatches work to a remote Beacon worker node. The task pauses until the Beacon completes execution and reports results.",
+	"Category": "extension",
+	"Capability": "Extension",
+	"Action": "Dispatch",
+	"Tier": "Extension",
+	"EventInputs": [{ "Name": "Trigger" }],
+	"EventOutputs": [
+		{ "Name": "Complete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "RemoteCapability", "DataType": "String", "Required": true, "Description": "Required capability on the Beacon (e.g. Shell, FileSystem)" },
+		{ "Name": "RemoteAction", "DataType": "String", "Required": false, "Description": "Specific action within the capability (e.g. Execute, Read)" },
+		{ "Name": "Command", "DataType": "String", "Required": false, "Description": "Shell command to execute on the Beacon" },
+		{ "Name": "Parameters", "DataType": "String", "Required": false, "Description": "Command-line parameters" },
+		{ "Name": "AffinityKey", "DataType": "String", "Required": false, "Description": "Key for worker affinity routing (same key → same Beacon)" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Work item timeout in milliseconds (default: 300000)" },
+		{ "Name": "InputData", "DataType": "String", "Required": false, "Description": "JSON data to pass to the Beacon worker" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to write results on completion" }
+	],
+	"StateOutputs": [
+		{ "Name": "StdOut", "DataType": "String", "Description": "Standard output from the Beacon execution" },
+		{ "Name": "Result", "DataType": "String", "Description": "Result data from the Beacon" },
+		{ "Name": "ExitCode", "DataType": "Number", "Description": "Exit code of the remote command" },
+		{ "Name": "BeaconID", "DataType": "String", "Description": "ID of the Beacon that executed the work" }
+	],
+	"DefaultSettings": { "RemoteCapability": "Shell", "RemoteAction": "Execute", "TimeoutMs": 300000, "Destination": "" }
+}