retold-remote 0.0.17 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "retold-remote",
-    "version": "0.0.17",
+    "version": "0.0.18",
     "description": "Retold Remote - NAS media browser with gallery views and keyboard navigation",
     "main": "source/Pict-RetoldRemote-Bundle.js",
     "bin": {
@@ -40,7 +40,7 @@
         "orator": "^6.0.4",
         "orator-serviceserver-restify": "^2.0.9",
         "parime": "^1.0.3",
-        "pdf-parse": "^1.1.1",
+        "pdf-parse": "^2.4.5",
         "pict": "^1.0.359",
         "pict-application": "^1.0.33",
         "pict-docuserve": "^0.0.32",
@@ -50,14 +50,15 @@
         "pict-service-commandlineutility": "^1.0.19",
         "pict-view": "^1.0.67",
         "retold-content-system": "^1.0.12",
-        "yauzl": "^3.2.0"
+        "ultravisor-beacon": "^0.0.4",
+        "yauzl": "^3.2.1"
     },
     "optionalDependencies": {
         "@img/sharp-wasm32": "^0.34.5",
         "sharp": "^0.34.5"
     },
     "devDependencies": {
-        "puppeteer": "^24.0.0",
+        "puppeteer": "^24.40.0",
         "quackage": "^1.0.65"
     },
     "copyFilesSettings": {

package/source/Pict-Application-RetoldRemote.js

@@ -721,12 +721,15 @@ class RetoldRemoteApplication extends libContentEditorApplication
 	 */
 	_executeRoute(pRoute, pPath)
 	{
+		let tmpRemote = this.pict.AppData.RetoldRemote;
+		let tmpActiveMode = tmpRemote.ActiveMode || 'gallery';
+
 		switch (pRoute)
 		{
 			case 'browse':
 			{
 				let tmpCurrentPath = (this.pict.AppData.PictFileBrowser && this.pict.AppData.PictFileBrowser.CurrentLocation) || '';
-				if (pPath !== tmpCurrentPath)
+				if (pPath !== tmpCurrentPath || tmpActiveMode !== 'gallery')
 				{
 					this.loadFileList(pPath);
 				}
@@ -735,7 +738,7 @@ class RetoldRemoteApplication extends libContentEditorApplication
 			case 'view':
 			case 'edit':
 			{
-				if (this.pict.AppData.ContentEditor.CurrentFile !== pPath)
+				if (this.pict.AppData.ContentEditor.CurrentFile !== pPath || tmpActiveMode === 'gallery')
 				{
 					this.navigateToFile(pPath);
 				}

package/source/cli/RetoldRemote-Server-Setup.js

@@ -49,6 +49,7 @@ const libRetoldRemoteFileOperationService = require('../server/RetoldRemote-File
 const libRetoldRemoteAISortService = require('../server/RetoldRemote-AISortService.js');
 const libRetoldRemoteImageService = require('../server/RetoldRemote-ImageService.js');
 const libRetoldRemoteUltravisorDispatcher = require('../server/RetoldRemote-UltravisorDispatcher.js');
+const libRetoldRemoteUltravisorBeacon = require('../server/RetoldRemote-UltravisorBeacon.js');
 const libUrl = require('url');
 
 function setupRetoldRemoteServer(pOptions, fCallback)
@@ -88,6 +89,13 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 	if (pOptions.UltravisorURL)
 	{
 		tmpSettings.UltravisorURL = pOptions.UltravisorURL;
+
+		// Auto-construct ContentAPIURL from the server's own port so beacons
+		// know where to download source files from retold-remote.
+		if (!pOptions.ContentAPIURL)
+		{
+			tmpSettings.ContentAPIURL = 'http://localhost:' + pOptions.Port;
+		}
 	}
 	if (pOptions.ContentAPIURL)
 	{
@@ -215,6 +223,9 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 			// Set up the Ultravisor dispatcher for offloading heavy processing
 			let tmpDispatcher = new libRetoldRemoteUltravisorDispatcher(tmpFable, {});
 
+			// Set up the Ultravisor beacon for mesh registration
+			let tmpBeacon = new libRetoldRemoteUltravisorBeacon(tmpFable, {});
+
 			// Wire the dispatcher to services that can offload processing
 			tmpMediaService.setDispatcher(tmpDispatcher);
 			tmpVideoFrameService.setDispatcher(tmpDispatcher);
@@ -2127,7 +2138,7 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 			tmpOrator.startService(
 				function ()
 				{
-					return fCallback(null,
+					let tmpServerInfo =
 					{
 						Fable: tmpFable,
 						Orator: tmpOrator,
@@ -2140,8 +2151,41 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 						MetadataCache: tmpMetadataCache,
 						FileOperationService: tmpFileOperationService,
 						UltravisorDispatcher: tmpDispatcher,
+						UltravisorBeacon: tmpBeacon,
 						Port: tmpPort
-					});
+					};
+
+					// If Ultravisor URL is configured, connect as a beacon
+					if (pOptions.UltravisorURL)
+					{
+						let tmpContentAPIBase = tmpFable.settings.ContentAPIURL || ('http://localhost:' + tmpPort);
+						let tmpContentBaseURL = tmpContentAPIBase + '/content/';
+
+						tmpBeacon.connectBeacon(
+							{
+								ServerURL: pOptions.UltravisorURL,
+								Name: 'retold-remote',
+								ContentPath: tmpContentPath,
+								ContentBaseURL: tmpContentBaseURL,
+								CacheRoot: tmpCacheRoot,
+								StagingPath: tmpCacheRoot || process.cwd(),
+								BindAddresses: [{ IP: '127.0.0.1', Port: tmpPort, Protocol: 'http' }]
+							},
+							(pBeaconError) =>
+							{
+								if (pBeaconError)
+								{
+									tmpFable.log.warn(`Ultravisor Beacon: registration failed (server may not be running): ${pBeaconError.message}`);
+									tmpFable.log.warn('Ultravisor Beacon: server is still running. Beacon will not be active.');
+								}
+								// Non-fatal — return server info regardless
+								return fCallback(null, tmpServerInfo);
+							});
+					}
+					else
+					{
+						return fCallback(null, tmpServerInfo);
+					}
 				});
 		});
 	});

package/source/cli/commands/RetoldRemote-Command-Serve.js

@@ -26,11 +26,37 @@ class RetoldRemoteCommandServe extends libCommandLineCommand
 		this.options.CommandOptions.push(
 			{ Name: '--cache-server [url]', Description: 'URL of a remote parime cache server (e.g. http://host:9999).', Default: '' });
 
+		this.options.CommandOptions.push(
+			{ Name: '-u, --ultravisor [url]', Description: 'Connect to Ultravisor mesh. URL defaults to http://localhost:54321 if omitted.', Default: '' });
+
+		this.options.CommandOptions.push(
+			{ Name: '-l, --logfile [path]', Description: 'Write logs to a file (auto-generates timestamped name if path omitted).', Default: '' });
+
 		this.addCommand();
 	}
 
 	onRunAsync(fCallback)
 	{
+		// Set up file logging if -l was provided
+		let tmpLogfileOpt = this.CommandOptions.logfile;
+		if (tmpLogfileOpt)
+		{
+			let tmpLogfilePath;
+			if (typeof tmpLogfileOpt === 'string' && tmpLogfileOpt.length > 0)
+			{
+				tmpLogfilePath = libPath.resolve(tmpLogfileOpt);
+			}
+			else
+			{
+				tmpLogfilePath = libPath.resolve(`retold-remote-${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+			}
+			let tmpStreamDef = { loggertype: 'simpleflatfile', level: 'info', path: tmpLogfilePath, outputloglinestoconsole: false, outputobjectstoconsole: false };
+			let tmpFileLogger = new this.fable.log._Providers.simpleflatfile(tmpStreamDef, this.fable.log);
+			tmpFileLogger.initialize();
+			this.fable.log.addLogger(tmpFileLogger, 'info');
+			this.log.info(`Logging to file: ${tmpLogfilePath}`);
+		}
+
 		let tmpContentPath = libPath.resolve(this.ArgumentString || process.cwd());
 
 		let tmpDistPath = libPath.resolve(__dirname, '..', '..', '..', 'web-application');
@@ -60,6 +86,17 @@ class RetoldRemoteCommandServe extends libCommandLineCommand
 			? libPath.resolve(this.CommandOptions.cachePath)
 			: null;
 		let tmpCacheServer = this.CommandOptions.cacheServer || null;
+		// -u with no URL → true (Commander behavior for [optional]), default to localhost
+		let tmpUltravisorOpt = this.CommandOptions.ultravisor;
+		let tmpUltravisorURL = null;
+		if (tmpUltravisorOpt === true)
+		{
+			tmpUltravisorURL = 'http://localhost:54321';
+		}
+		else if (typeof tmpUltravisorOpt === 'string' && tmpUltravisorOpt.length > 0)
+		{
+			tmpUltravisorURL = tmpUltravisorOpt;
+		}
 
 		tmpSetupServer(
 			{
@@ -68,7 +105,8 @@ class RetoldRemoteCommandServe extends libCommandLineCommand
 				Port: tmpPort,
 				HashedFilenames: tmpHashedFilenames,
 				CacheRoot: tmpCacheRoot,
-				CacheServer: tmpCacheServer
+				CacheServer: tmpCacheServer,
+				UltravisorURL: tmpUltravisorURL
 			},
 			function (pError, pServerInfo)
 			{
@@ -85,11 +123,37 @@ class RetoldRemoteCommandServe extends libCommandLineCommand
 				tmpSelf.log.info(`  Content: ${tmpContentPath}`);
 				tmpSelf.log.info(`  Assets:  ${tmpDistPath}`);
 				tmpSelf.log.info(`  Browse:  http://localhost:${pServerInfo.Port}/`);
+				if (pServerInfo.UltravisorBeacon && pServerInfo.UltravisorBeacon.isEnabled())
+				{
+					tmpSelf.log.info(`  Beacon:  registered with Ultravisor at ${tmpUltravisorURL}`);
+				}
+				else if (tmpUltravisorURL)
+				{
+					tmpSelf.log.info(`  Beacon:  not connected (Ultravisor may be unreachable)`);
+				}
 				tmpSelf.log.info('==========================================================');
 				tmpSelf.log.info('');
 				tmpSelf.log.info('  Press Ctrl+C to stop.');
 				tmpSelf.log.info('');
 
+				// Graceful shutdown: disconnect beacon before exit
+				process.on('SIGINT', () =>
+				{
+					tmpSelf.log.info('');
+					tmpSelf.log.info('Shutting down...');
+					if (pServerInfo.UltravisorBeacon && pServerInfo.UltravisorBeacon.isEnabled())
+					{
+						pServerInfo.UltravisorBeacon.disconnectBeacon(() =>
+						{
+							process.exit(0);
+						});
+					}
+					else
+					{
+						process.exit(0);
+					}
+				});
+
 				// Intentionally do NOT call fCallback() here.
 				// The server should keep running.
 			});

package/source/server/RetoldRemote-AudioWaveformService.js

@@ -136,7 +136,7 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 	{
 		let tmpSelf = this;
 
-		// Try Ultravisor dispatch first
+		// Try Ultravisor operation trigger first
 		if (this._dispatcher && this._dispatcher.isAvailable())
 		{
 			let tmpRelPath;
@@ -151,25 +151,24 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 
 			if (tmpRelPath && !tmpRelPath.startsWith('..'))
 			{
-				let tmpCommand = `ffprobe -v quiet -print_format json -show_format -show_streams "{SourcePath}"`;
-
-				this._dispatcher.dispatchMediaCommand(
+				this._dispatcher.triggerOperation('rr-media-probe',
 				{
-					Command: tmpCommand,
-					InputPath: tmpRelPath,
-					AffinityKey: tmpRelPath,
-					TimeoutMs: 30000
+					MediaAddress: '>retold-remote/File/' + tmpRelPath
 				},
-				(pDispatchError, pResult) =>
+				(pTriggerError, pResult) =>
 				{
-					if (!pDispatchError && pResult && pResult.Outputs && pResult.Outputs.StdOut)
+					if (!pTriggerError && pResult && pResult.TaskOutputs)
 					{
 						try
 						{
-							let tmpData = JSON.parse(pResult.Outputs.StdOut);
-							let tmpParsed = tmpSelf._parseAudioProbeData(tmpData);
-							tmpSelf.fable.log.info(`ffprobe (audio) via Ultravisor for ${tmpRelPath}`);
-							return fCallback(null, tmpParsed);
+							let tmpProcessOutput = pResult.TaskOutputs['rr-media-probe-process'];
+							if (tmpProcessOutput && tmpProcessOutput.Result)
+							{
+								let tmpData = JSON.parse(tmpProcessOutput.Result);
+								let tmpParsed = tmpSelf._parseAudioProbeData(tmpData);
+								tmpSelf.fable.log.info(`ffprobe (audio) via operation trigger for ${tmpRelPath}`);
+								return fCallback(null, tmpParsed);
+							}
 						}
 						catch (pParseError)
 						{

package/source/server/RetoldRemote-EbookService.js

@@ -192,7 +192,7 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 			return fCallback(null, tmpResult);
 		};
 
-		// Try Ultravisor dispatch first
+		// Try Ultravisor operation trigger first
 		if (this._dispatcher && this._dispatcher.isAvailable())
 		{
 			let tmpRelPath;
@@ -207,24 +207,18 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 
 			if (tmpRelPath && !tmpRelPath.startsWith('..'))
 			{
-				let tmpCommand = `ebook-convert "{SourcePath}" "{OutputPath}"`;
-
-				this._dispatcher.dispatchMediaCommand(
+				this._dispatcher.triggerOperation('rr-ebook-convert',
 				{
-					Command: tmpCommand,
-					InputPath: tmpRelPath,
-					OutputFilename: tmpOutputFilename,
-					AffinityKey: tmpRelPath,
-					TimeoutMs: 180000
+					EbookAddress: '>retold-remote/File/' + tmpRelPath
 				},
-				(pDispatchError, pResult) =>
+				(pTriggerError, pResult) =>
 				{
-					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					if (!pTriggerError && pResult && pResult.OutputBuffer)
 					{
 						try
 						{
 							libFs.writeFileSync(tmpOutputPath, pResult.OutputBuffer);
-							tmpSelf.fable.log.info(`Ebook converted via Ultravisor for ${tmpRelPath}`);
+							tmpSelf.fable.log.info(`Ebook converted via operation trigger for ${tmpRelPath}`);
 							return _finishConversion(tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath);
 						}
 						catch (pWriteError)
@@ -234,7 +228,7 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 					}
 
 					// Fall through to local processing
-					tmpSelf.fable.log.info(`Ultravisor dispatch failed for ebook conversion, falling back to local: ${pDispatchError ? pDispatchError.message : 'no output'}`);
+					tmpSelf.fable.log.info(`Operation trigger failed for ebook conversion, falling back to local: ${pTriggerError ? pTriggerError.message : 'no output'}`);
 					tmpSelf._convertToEpubLocal(pAbsPath, tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, fCallback);
 				});
 				return;

package/source/server/RetoldRemote-ImageService.js

@@ -361,7 +361,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 	{
 		let tmpSelf = this;
 
-		// Try Ultravisor dispatch first
+		// Try Ultravisor operation trigger first
 		if (this._dispatcher && this._dispatcher.isAvailable())
 		{
 			let tmpRelPath;
@@ -376,21 +376,15 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 			if (tmpRelPath && !tmpRelPath.startsWith('..'))
 			{
-				let tmpHalfFlag = pFullResolution ? '' : ' -h';
-				let tmpOutputFilename = libPath.basename(pOutputPath);
-				let tmpCommand = `dcraw -c -w${tmpHalfFlag} "{SourcePath}" | convert ppm:- jpeg:"{OutputPath}"`;
-
-				this._dispatcher.dispatchMediaCommand(
+				this._dispatcher.triggerOperation('rr-image-convert',
 				{
-					Command: tmpCommand,
-					InputPath: tmpRelPath,
-					OutputFilename: tmpOutputFilename,
-					AffinityKey: tmpRelPath,
-					TimeoutMs: 180000
+					ImageAddress: '>retold-remote/File/' + tmpRelPath,
+					Format: 'jpeg',
+					Quality: 92
 				},
-				(pDispatchError, pResult) =>
+				(pTriggerError, pResult) =>
 				{
-					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					if (!pTriggerError && pResult && pResult.OutputBuffer)
 					{
 						try
 						{
@@ -400,7 +394,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 								libFs.mkdirSync(tmpDir, { recursive: true });
 							}
 							libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
-							tmpSelf.fable.log.info(`Raw conversion via Ultravisor (dcraw) for ${tmpRelPath}`);
+							tmpSelf.fable.log.info(`Raw conversion via operation trigger (dcraw) for ${tmpRelPath}`);
 							return fCallback(null);
 						}
 						catch (pWriteError)
@@ -503,7 +497,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 	{
 		let tmpSelf = this;
 
-		// Try Ultravisor dispatch first
+		// Try Ultravisor operation trigger first
 		if (this._dispatcher && this._dispatcher.isAvailable())
 		{
 			let tmpRelPath;
@@ -518,20 +512,15 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 			if (tmpRelPath && !tmpRelPath.startsWith('..'))
 			{
-				let tmpOutputFilename = libPath.basename(pOutputPath);
-				let tmpCommand = `convert "{SourcePath}" -auto-orient -quality 92 "{OutputPath}"`;
-
-				this._dispatcher.dispatchMediaCommand(
+				this._dispatcher.triggerOperation('rr-image-convert',
 				{
-					Command: tmpCommand,
-					InputPath: tmpRelPath,
-					OutputFilename: tmpOutputFilename,
-					AffinityKey: tmpRelPath,
-					TimeoutMs: 180000
+					ImageAddress: '>retold-remote/File/' + tmpRelPath,
+					Format: 'jpeg',
+					Quality: 92
 				},
-				(pDispatchError, pResult) =>
+				(pTriggerError, pResult) =>
 				{
-					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					if (!pTriggerError && pResult && pResult.OutputBuffer)
 					{
 						try
 						{
@@ -541,7 +530,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 								libFs.mkdirSync(tmpDir, { recursive: true });
 							}
 							libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
-							tmpSelf.fable.log.info(`Raw conversion via Ultravisor (ImageMagick) for ${tmpRelPath}`);
+							tmpSelf.fable.log.info(`Raw conversion via operation trigger (ImageMagick) for ${tmpRelPath}`);
 							return fCallback(null);
 						}
 						catch (pWriteError)
@@ -826,19 +815,40 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 				}
 			});
 		}
-		else if (this._sharp)
+		else if (this._dispatcher && this._dispatcher.isAvailable())
 		{
-			this._doGeneratePreview(pAbsPath, pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, false, fCallback);
+			// Prefer Ultravisor dispatch when a beacon is available
+			this._doGeneratePreviewWithDispatcher(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, tmpIsRaw,
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult)
+					{
+						return fCallback(null, pResult);
+					}
+					// Dispatch failed — fall through to local tools
+					tmpSelf.fable.log.info(`Ultravisor dispatch failed for preview, falling back to local: ${pDispatchError ? pDispatchError.message : 'no result'}`);
+					tmpSelf._generatePreviewLocal(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, fCallback);
+				});
 		}
-		else if (this._capabilities.imagemagick)
+		else
 		{
-			// No Sharp available — use ImageMagick for standard images too
-			this._doGeneratePreviewWithImageMagick(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpManifestPath, tmpOutputPath, tmpStat, false, fCallback);
+			this._generatePreviewLocal(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, fCallback);
 		}
-		else if (this._dispatcher && this._dispatcher.isAvailable())
+	}
+
+	/**
+	 * Generate a preview using local tools (Sharp or ImageMagick).
+	 * Called when Ultravisor dispatch is unavailable or fails.
+	 */
+	_generatePreviewLocal(pAbsPath, pRelPath, pMaxDim, pCacheKey, pOutputFilename, pCacheDir, pManifestPath, pOutputPath, pStat, fCallback)
+	{
+		if (this._sharp)
+		{
+			this._doGeneratePreview(pAbsPath, pAbsPath, pRelPath, pMaxDim, pCacheKey, pOutputFilename, pCacheDir, pManifestPath, pOutputPath, pStat, false, fCallback);
+		}
+		else if (this._capabilities.imagemagick)
 		{
-			// No local tools available — dispatch to Ultravisor beacon
-			this._doGeneratePreviewWithDispatcher(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, tmpIsRaw, fCallback);
+			this._doGeneratePreviewWithImageMagick(pAbsPath, pRelPath, pMaxDim, pCacheKey, pOutputFilename, pManifestPath, pOutputPath, pStat, false, fCallback);
 		}
 		else
 		{
@@ -1136,24 +1146,19 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 			return fCallback(new Error('File is outside content root.'));
 		}
 
-		this._dispatcher.dispatchConversion(
+		this._dispatcher.triggerOperation('rr-image-thumbnail',
 		{
-			Action: 'ImageResize',
-			InputPath: tmpRelPath,
-			OutputFilename: pOutputFilename,
+			ImageAddress: '>retold-remote/File/' + tmpRelPath,
 			Width: pMaxDim,
 			Height: pMaxDim,
 			Format: 'jpeg',
-			Quality: this.options.PreviewQuality || 85,
-			AffinityKey: tmpRelPath,
-			TimeoutMs: 120000,
-			FallbackCommand: `convert "{SourcePath}"[0] -auto-orient -resize ${pMaxDim}x${pMaxDim} -quality ${this.options.PreviewQuality || 85} "{OutputPath}"`
+			Quality: this.options.PreviewQuality || 85
 		},
-		(pDispatchError, pResult) =>
+		(pTriggerError, pResult) =>
 		{
-			if (pDispatchError || !pResult || !pResult.OutputBuffer)
+			if (pTriggerError || !pResult || !pResult.OutputBuffer)
 			{
-				return fCallback(new Error('Ultravisor preview generation failed: ' + (pDispatchError ? pDispatchError.message : 'no output')));
+				return fCallback(new Error('Operation trigger preview generation failed: ' + (pTriggerError ? pTriggerError.message : 'no output')));
 			}
 
 			try
@@ -1190,7 +1195,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 				tmpSelf.fable.log.warn(`Could not write preview manifest: ${pWriteError.message}`);
 			}
 
-			tmpSelf.fable.log.info(`Generated image preview (Ultravisor): ${pRelPath}`);
+			tmpSelf.fable.log.info(`Generated image preview (operation trigger): ${pRelPath}`);
 			return fCallback(null, tmpResult);
 		});
 	}