orator-conversion 1.0.3 → 1.0.4

package/debug/Harness.js

@@ -1,10 +1,48 @@
 const libFable = require('fable');
+const libPath = require('path');
+
+// Parse command-line flags before creating Fable so LogStreams can be set
+let tmpUltravisorURL = null;
+let tmpLogFilePath = null;
+for (let i = 2; i < process.argv.length; i++)
+{
+	if ((process.argv[i] === '--ultravisor' || process.argv[i] === '-u'))
+	{
+		if (process.argv[i + 1] && !process.argv[i + 1].startsWith('-'))
+		{
+			tmpUltravisorURL = process.argv[++i];
+		}
+		else
+		{
+			tmpUltravisorURL = 'http://localhost:54321';
+		}
+	}
+	if (process.argv[i] === '--logfile' || process.argv[i] === '-l')
+	{
+		if (process.argv[i + 1] && !process.argv[i + 1].startsWith('-'))
+		{
+			tmpLogFilePath = libPath.resolve(process.argv[++i]);
+		}
+		else
+		{
+			tmpLogFilePath = libPath.resolve(`orator-conversion-${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+		}
+	}
+}
+
+let tmpLogStreams = [{ level: 'trace', streamtype: 'process.stdout' }];
+if (tmpLogFilePath)
+{
+	tmpLogStreams.push({ loggertype: 'simpleflatfile', level: 'trace', path: tmpLogFilePath });
+	console.log(`[Orator-Conversion] Logging to file: ${tmpLogFilePath}`);
+}
 
 const defaultFableSettings = (
 	{
 		Product: 'Orator-FileTranslation',
 		ProductVersion: '1.0.0',
-		APIServerPort: 8765
+		APIServerPort: 8765,
+		LogStreams: tmpLogStreams
 	});
 
 let _Fable = new libFable(defaultFableSettings);
@@ -32,6 +70,30 @@ tmpAnticipate.anticipate(
 
 tmpAnticipate.anticipate(_Orator.startService.bind(_Orator));
 
+// If an Ultravisor URL was provided, connect as a beacon
+if (tmpUltravisorURL)
+{
+	tmpAnticipate.anticipate(
+		(fNext) =>
+		{
+			_Fable.OratorFileTranslation.connectBeacon(
+				{
+					ServerURL: tmpUltravisorURL,
+					Name: 'orator-conversion',
+					BindAddresses: [{ IP: '127.0.0.1', Port: 8765, Protocol: 'http' }]
+				},
+				(pError) =>
+				{
+					if (pError)
+					{
+						_Fable.log.warn(`Beacon connection failed (server may not be running): ${pError.message}`);
+						_Fable.log.warn('HTTP endpoints are still available. Beacon will not be active.');
+					}
+					return fNext();
+				});
+		});
+}
+
 tmpAnticipate.wait(
 	(pError) =>
 	{
@@ -45,4 +107,27 @@ tmpAnticipate.wait(
 		_Fable.log.info('  POST http://127.0.0.1:8765/conversion/1.0/image/png-to-jpg');
 		_Fable.log.info('  POST http://127.0.0.1:8765/conversion/1.0/pdf-to-page-png/:Page');
 		_Fable.log.info('  POST http://127.0.0.1:8765/conversion/1.0/pdf-to-page-jpg/:Page');
+
+		if (tmpUltravisorURL)
+		{
+			_Fable.log.info('');
+			_Fable.log.info(`Beacon: connected to Ultravisor at ${tmpUltravisorURL}`);
+		}
 	});
+
+// Graceful shutdown
+process.on('SIGINT', () =>
+{
+	console.log('\n[Orator-Conversion] Shutting down...');
+	if (_Fable.OratorFileTranslation._BeaconService)
+	{
+		_Fable.OratorFileTranslation.disconnectBeacon(() =>
+		{
+			process.exit(0);
+		});
+	}
+	else
+	{
+		process.exit(0);
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "orator-conversion",
-	"version": "1.0.3",
+	"version": "1.0.4",
 	"description": "File format conversion endpoints for Orator service servers.",
 	"main": "source/Orator-File-Translation.js",
 	"scripts": {
@@ -42,7 +42,9 @@
 	"homepage": "https://github.com/stevenvelozo/orator-conversion#readme",
 	"dependencies": {
 		"fable-serviceproviderbase": "^3.0.19",
-		"sharp": "^0.34.5"
+		"sharp": "^0.34.5",
+		"ultravisor-beacon": "^0.0.3",
+		"ws": "^8.20.0"
 	},
 	"devDependencies": {
 		"fable": "^3.1.67",

package/source/Conversion-Core.js

@@ -94,9 +94,9 @@ class ConversionCore
 	}
 
 	/**
-	 * Resize an image buffer with Sharp.
+	 * Resize an image with Sharp.
 	 *
-	 * @param {Buffer} pInputBuffer - The image data (any format Sharp can read).
+	 * @param {Buffer|string} pInput - Image data (Buffer) or file path (string).
 	 * @param {object} pOptions - Resize options.
 	 * @param {number} [pOptions.Width] - Target width in pixels.
 	 * @param {number} [pOptions.Height] - Target height in pixels.
@@ -107,7 +107,7 @@ class ConversionCore
 	 * @param {string} [pOptions.Position] - Resize position/gravity: 'centre', 'north', 'south', etc.
 	 * @param {Function} fCallback - Called with (pError, pOutputBuffer, pContentType).
 	 */
-	imageResize(pInputBuffer, pOptions, fCallback)
+	imageResize(pInput, pOptions, fCallback)
 	{
 		let tmpOptions = pOptions || {};
 		let tmpFormat = (tmpOptions.Format || 'jpeg').toLowerCase();
@@ -132,7 +132,8 @@ class ConversionCore
 			tmpResizeConfig.position = tmpOptions.Position;
 		}
 
-		let tmpSharpInstance = libSharp(pInputBuffer);
+		// Accept file path or buffer; disable pixel limit for large scans
+		let tmpSharpInstance = libSharp(pInput, { limitInputPixels: false });
 
 		if (tmpAutoOrient)
 		{

package/source/Orator-Conversion-BeaconProvider.js

@@ -268,9 +268,33 @@ class OratorConversionBeaconProvider extends libBeaconCapabilityProvider
 	 */
 	execute(pAction, pWorkItem, pContext, fCallback, fReportProgress)
 	{
+		let tmpLog = pContext && pContext.log ? pContext.log : { info: console.log, warn: console.warn, error: console.error };
+		tmpLog.info(`[OratorConversion] execute: action="${pAction}" workItem=${pWorkItem.WorkItemHash || '?'} settings=${JSON.stringify(pWorkItem.Settings || {}).substring(0, 200)}`);
 		let tmpSettings = pWorkItem.Settings || {};
 		let tmpStagingPath = pContext.StagingPath || process.cwd();
 
+		// Coerce settings types from the action's schema.
+		// Template engines and JSON transport may deliver numbers as strings.
+		let tmpActionDef = this.actions[pAction];
+		if (tmpActionDef && tmpActionDef.SettingsSchema)
+		{
+			for (let i = 0; i < tmpActionDef.SettingsSchema.length; i++)
+			{
+				let tmpField = tmpActionDef.SettingsSchema[i];
+				let tmpVal = tmpSettings[tmpField.Name];
+				if (tmpVal === undefined || tmpVal === null || tmpVal === '') { continue; }
+				if (tmpField.DataType === 'Number' && typeof tmpVal === 'string')
+				{
+					let tmpNum = Number(tmpVal);
+					if (!isNaN(tmpNum)) { tmpSettings[tmpField.Name] = tmpNum; }
+				}
+				else if (tmpField.DataType === 'Boolean' && typeof tmpVal === 'string')
+				{
+					tmpSettings[tmpField.Name] = (tmpVal === 'true' || tmpVal === '1');
+				}
+			}
+		}
+
 		let tmpInputPath = this._resolvePath(tmpSettings.InputFile, tmpStagingPath);
 		let tmpOutputPath = this._resolvePath(tmpSettings.OutputFile, tmpStagingPath);
 
@@ -284,14 +308,17 @@ class OratorConversionBeaconProvider extends libBeaconCapabilityProvider
 
 		if (!libFS.existsSync(tmpInputPath))
 		{
+			tmpLog.warn(`[OratorConversion] Input file NOT FOUND: ${tmpInputPath} (settings.InputFile=${tmpSettings.InputFile})`);
 			return fCallback(null, {
 				Outputs: { StdOut: `Input file not found: ${tmpSettings.InputFile}`, ExitCode: -1, Result: '' },
 				Log: [`OratorConversion: input file not found: ${tmpInputPath}`]
 			});
 		}
 
-		// File-path actions (video, audio, probe) skip the buffer read
-		let tmpFilePathActions = { 'MediaProbe': true, 'VideoExtractFrame': true, 'VideoThumbnail': true, 'AudioExtractSegment': true, 'AudioWaveform': true };
+		tmpLog.info(`[OratorConversion] Input file OK: ${tmpInputPath} (${libFS.statSync(tmpInputPath).size} bytes)`);
+
+		// File-path actions skip the buffer read — Sharp and ffmpeg handle files directly
+		let tmpFilePathActions = { 'ImageResize': true, 'ImageConvert': true, 'MediaProbe': true, 'VideoExtractFrame': true, 'VideoThumbnail': true, 'AudioExtractSegment': true, 'AudioWaveform': true };
 		if (tmpFilePathActions[pAction])
 		{
 			return this._executeFilePathAction(pAction, tmpSettings, tmpInputPath, tmpOutputPath, fCallback, fReportProgress);
@@ -325,12 +352,15 @@ class OratorConversionBeaconProvider extends libBeaconCapabilityProvider
 		{
 			if (pError)
 			{
+				tmpLog.error(`[OratorConversion] ${pAction} FAILED: ${pError.message}`);
 				return fCallback(null, {
 					Outputs: { StdOut: `Conversion failed: ${pError.message}`, ExitCode: 1, Result: '' },
 					Log: [`OratorConversion ${pAction} error: ${pError.message}`]
 				});
 			}
 
+			tmpLog.info(`[OratorConversion] ${pAction} SUCCESS: ${pOutputBuffer.length} bytes → ${tmpOutputPath}`);
+
 			try
 			{
 				libFS.writeFileSync(tmpOutputPath, pOutputBuffer);
@@ -697,6 +727,102 @@ class OratorConversionBeaconProvider extends libBeaconCapabilityProvider
 				break;
 			}
 
+			case 'ImageResize':
+			{
+				if (fReportProgress) fReportProgress({ Percent: 10, Message: 'Resizing image...' });
+				this._Core.imageResize(pInputPath,
+					{
+						Width: pSettings.Width,
+						Height: pSettings.Height,
+						Format: pSettings.Format,
+						Quality: pSettings.Quality,
+						AutoOrient: pSettings.AutoOrient,
+						Fit: pSettings.Fit,
+						Position: pSettings.Position
+					},
+					(pError, pOutputBuffer, pContentType) =>
+					{
+						if (pError)
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: `Resize failed: ${pError.message}`, ExitCode: 1, Result: '' },
+								Log: [`OratorConversion ImageResize error: ${pError.message}`]
+							});
+						}
+
+						try
+						{
+							libFS.writeFileSync(pOutputPath, pOutputBuffer);
+						}
+						catch (pWriteError)
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: `Write failed: ${pWriteError.message}`, ExitCode: 1, Result: '' },
+								Log: [`OratorConversion ImageResize write error: ${pWriteError.message}`]
+							});
+						}
+
+						return fCallback(null, {
+							Outputs:
+							{
+								StdOut: `Resized ${pSettings.InputFile} → ${pSettings.OutputFile}`,
+								ExitCode: 0,
+								Result: pOutputPath,
+								ContentType: pContentType || '',
+								OutputSize: pOutputBuffer.length
+							},
+							Log: [`OratorConversion ImageResize: ${pSettings.InputFile} → ${pSettings.OutputFile} (${pOutputBuffer.length} bytes)`]
+						});
+					});
+				break;
+			}
+
+			case 'ImageConvert':
+			{
+				if (fReportProgress) fReportProgress({ Percent: 10, Message: 'Converting image...' });
+				this._Core.imageResize(pInputPath,
+					{
+						Format: pSettings.Format,
+						Quality: pSettings.Quality,
+						AutoOrient: pSettings.AutoOrient
+					},
+					(pError, pOutputBuffer, pContentType) =>
+					{
+						if (pError)
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: `Convert failed: ${pError.message}`, ExitCode: 1, Result: '' },
+								Log: [`OratorConversion ImageConvert error: ${pError.message}`]
+							});
+						}
+
+						try
+						{
+							libFS.writeFileSync(pOutputPath, pOutputBuffer);
+						}
+						catch (pWriteError)
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: `Write failed: ${pWriteError.message}`, ExitCode: 1, Result: '' },
+								Log: [`OratorConversion ImageConvert write error: ${pWriteError.message}`]
+							});
+						}
+
+						return fCallback(null, {
+							Outputs:
+							{
+								StdOut: `Converted ${pSettings.InputFile} → ${pSettings.OutputFile}`,
+								ExitCode: 0,
+								Result: pOutputPath,
+								ContentType: pContentType || '',
+								OutputSize: pOutputBuffer.length
+							},
+							Log: [`OratorConversion ImageConvert: ${pSettings.InputFile} → ${pSettings.OutputFile} (${pOutputBuffer.length} bytes)`]
+						});
+					});
+				break;
+			}
+
 			default:
 				return fCallback(null, {
 					Outputs: { StdOut: `Unknown file-path action: ${pAction}`, ExitCode: -1, Result: '' },

package/source/Orator-File-Translation.js

@@ -6,6 +6,9 @@ const libFS = require('fs');
 const libPath = require('path');
 const libOS = require('os');
 
+const libBeaconService = require('ultravisor-beacon');
+const libOratorConversionBeaconProvider = require('./Orator-Conversion-BeaconProvider.js');
+
 const libEndpointImageJpgToPng = require('./endpoints/Endpoint-Image-JpgToPng.js');
 const libEndpointImagePngToJpg = require('./endpoints/Endpoint-Image-PngToJpg.js');
 const libEndpointImageResize = require('./endpoints/Endpoint-Image-Resize.js');
@@ -78,6 +81,9 @@ class OratorFileTranslation extends libFableServiceProviderBase
 		// Array of instantiated endpoint services
 		this._endpointServices = [];
 
+		// Beacon service reference (created on connectBeacon)
+		this._BeaconService = null;
+
 		// Initialize the built-in converters
 		this.initializeDefaultConverters();
 	}
@@ -508,6 +514,145 @@ class OratorFileTranslation extends libFableServiceProviderBase
 
 		return true;
 	}
+
+	/**
+	 * Connect to an Ultravisor coordinator as a beacon, exposing the same
+	 * MediaConversion capabilities available through the HTTP endpoints.
+	 *
+	 * This makes the running orator-conversion server discoverable by
+	 * Ultravisor and allows it to receive work items from the mesh.
+	 *
+	 * @param {object} pBeaconConfig Beacon configuration:
+	 *   - ServerURL {string} Ultravisor server URL (required)
+	 *   - Name {string} Beacon name (default: 'orator-conversion')
+	 *   - Password {string} Auth password (default: '')
+	 *   - MaxConcurrent {number} Max concurrent work items (default: 2)
+	 *   - StagingPath {string} Local staging directory (default: cwd)
+	 *   - Tags {object} Beacon tags (default: {})
+	 * @param {Function} fCallback Called with (pError, pBeaconInfo)
+	 */
+	connectBeacon(pBeaconConfig, fCallback)
+	{
+		if (!pBeaconConfig || !pBeaconConfig.ServerURL)
+		{
+			return fCallback(new Error('connectBeacon requires a ServerURL in the config.'));
+		}
+
+		if (this._BeaconService && this._BeaconService.isEnabled())
+		{
+			this.log.warn('OratorFileTranslation: beacon already connected.');
+			return fCallback(null);
+		}
+
+		// Register the beacon service type with fable if not already present
+		this.fable.addServiceTypeIfNotExists('UltravisorBeacon', libBeaconService);
+
+		// Default staging path to dist/orator-conversion-staging
+		let tmpStagingPath = pBeaconConfig.StagingPath || require('path').resolve(__dirname, '..', 'dist', 'orator-conversion-staging');
+
+		// Ensure staging directory exists
+		try
+		{
+			require('fs').mkdirSync(tmpStagingPath, { recursive: true });
+		}
+		catch (pMkdirError)
+		{
+			// Already exists — fine
+		}
+
+		// Instantiate the beacon service with the provided config
+		this._BeaconService = this.fable.instantiateServiceProviderWithoutRegistration('UltravisorBeacon',
+			{
+				ServerURL: pBeaconConfig.ServerURL,
+				Name: pBeaconConfig.Name || 'orator-conversion',
+				Password: pBeaconConfig.Password || '',
+				MaxConcurrent: pBeaconConfig.MaxConcurrent || 2,
+				StagingPath: tmpStagingPath,
+				Tags: pBeaconConfig.Tags || {},
+				BindAddresses: pBeaconConfig.BindAddresses || []
+			});
+
+		// Create the MediaConversion capability provider and register it
+		let tmpProvider = new libOratorConversionBeaconProvider(
+			{
+				PdftkPath: this.PdftkPath,
+				PdftoppmPath: this.PdftoppmPath,
+				FfmpegPath: pBeaconConfig.FfmpegPath || 'ffmpeg',
+				FfprobePath: pBeaconConfig.FfprobePath || 'ffprobe',
+				MaxFileSizeBytes: this.MaxFileSize,
+				LogLevel: this.LogLevel
+			});
+
+		// Initialize the provider (checks tool availability), then register and enable
+		tmpProvider.initialize(
+			(pInitError) =>
+			{
+				if (pInitError)
+				{
+					this.log.error(`OratorFileTranslation: beacon provider init failed: ${pInitError.message}`);
+					this._BeaconService = null;
+					return fCallback(pInitError);
+				}
+
+				// Register the capability with the beacon service
+				this._BeaconService.registerCapability(
+					{
+						Capability: tmpProvider.Capability,
+						Name: tmpProvider.Name,
+						actions: tmpProvider.actions,
+						execute: tmpProvider.execute.bind(tmpProvider),
+						initialize: (fCb) => { return fCb(null); },  // Already initialized above
+						shutdown: (fCb) => { return fCb(null); }
+					});
+
+				// Enable the beacon — authenticate, register, begin polling
+				this._BeaconService.enable(
+					(pEnableError, pBeaconInfo) =>
+					{
+						if (pEnableError)
+						{
+							this.log.error(`OratorFileTranslation: beacon enable failed: ${pEnableError.message}`);
+							this._BeaconService = null;
+							return fCallback(pEnableError);
+						}
+
+						this.log.info(`OratorFileTranslation: beacon connected as ${pBeaconInfo.BeaconID}`);
+						return fCallback(null, pBeaconInfo);
+					});
+			});
+	}
+
+	/**
+	 * Disconnect the beacon from the Ultravisor coordinator.
+	 *
+	 * @param {Function} fCallback Called with (pError)
+	 */
+	disconnectBeacon(fCallback)
+	{
+		if (!this._BeaconService || !this._BeaconService.isEnabled())
+		{
+			if (this.log)
+			{
+				this.log.info('OratorFileTranslation: beacon not connected, nothing to disconnect.');
+			}
+			return fCallback(null);
+		}
+
+		this._BeaconService.disable(
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.log.warn(`OratorFileTranslation: beacon disconnect warning: ${pError.message}`);
+				}
+				else
+				{
+					this.log.info('OratorFileTranslation: beacon disconnected.');
+				}
+				this._BeaconService = null;
+				return fCallback(pError || null);
+			});
+	}
 }
 
 module.exports = OratorFileTranslation;