retold-remote 0.0.5 → 0.0.7

package/source/server/RetoldRemote-EbookService.js

@@ -18,8 +18,7 @@ const libChildProcess = require('child_process');
 
 const _DefaultServiceConfiguration =
 {
-	"ContentPath": ".",
-	"CachePath": null
+	"ContentPath": "."
 };
 
 // Extensions that can be converted to EPUB by ebook-convert
@@ -60,16 +59,7 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
-		this.cachePath = this.options.CachePath
-			|| libPath.join(process.cwd(), 'dist', 'retold-cache', 'ebook-conversions');
-
-		// Ensure cache directory exists
-		if (!libFs.existsSync(this.cachePath))
-		{
-			libFs.mkdirSync(this.cachePath, { recursive: true });
-		}
-
-		this.fable.log.info(`Ebook Service: cache at ${this.cachePath}`);
+		this.fable.log.info('Ebook Service: using ParimeBinaryStorage (category: ebook-cache)');
 	}
 
 	/**
@@ -96,7 +86,7 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 	{
 		let tmpInput = `${pAbsPath}:${pMtimeMs}`;
 		let tmpHash = libCrypto.createHash('sha256').update(tmpInput).digest('hex').substring(0, 16);
-		return libPath.join(this.cachePath, tmpHash);
+		return this.fable.ParimeBinaryStorage.resolvePath('ebook-cache', tmpHash);
 	}
 
 	/**
@@ -221,11 +211,12 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 			return null;
 		}
 
-		let tmpPath = libPath.join(this.cachePath, pCacheKey, pFilename);
+		let tmpCacheDir = this.fable.ParimeBinaryStorage.resolvePath('ebook-cache', pCacheKey);
+		let tmpPath = libPath.join(tmpCacheDir, pFilename);
 
-		// Double-check it's under our cache dir
+		// Double-check it's under the storage root
 		let tmpResolved = libPath.resolve(tmpPath);
-		if (!tmpResolved.startsWith(this.cachePath))
+		if (!tmpResolved.startsWith(this.fable.ParimeBinaryStorage.storageRoot))
 		{
 			return null;
 		}

package/source/server/RetoldRemote-FileOperationService.js

@@ -0,0 +1,560 @@
+/**
+ * Retold Remote -- File Operation Service
+ *
+ * Provides safe file move, directory creation, and undo capabilities.
+ * All paths are sanitized and resolved within the content root to
+ * prevent directory traversal attacks.
+ *
+ * Batch moves are recorded in Bibliograph for undo support.
+ *
+ * API:
+ *   POST /api/files/mkdir       - Create directory recursively
+ *   POST /api/files/move        - Move a single file
+ *   POST /api/files/move-batch  - Move multiple files atomically
+ *   POST /api/files/undo-batch  - Reverse a completed batch
+ *
+ * @license MIT
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+const libFs = require('fs');
+const libPath = require('path');
+
+const SOURCE_NAME = 'retold-remote-file-ops';
+
+const _DefaultServiceConfiguration =
+{
+	"ContentPath": ".",
+	"MaxBatchSize": 1000
+};
+
+class RetoldRemoteFileOperationService extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'RetoldRemoteFileOperationService';
+
+		// Merge with defaults
+		for (let tmpKey in _DefaultServiceConfiguration)
+		{
+			if (!(tmpKey in this.options))
+			{
+				this.options[tmpKey] = _DefaultServiceConfiguration[tmpKey];
+			}
+		}
+
+		this.contentPath = libPath.resolve(this.options.ContentPath);
+
+		this.fable.log.info('File Operation Service: initialized');
+		this.fable.log.info(`  Content root: ${this.contentPath}`);
+		this.fable.log.info(`  Max batch size: ${this.options.MaxBatchSize}`);
+	}
+
+	/**
+	 * Sanitize a path to prevent directory traversal.
+	 * Returns null if invalid.
+	 *
+	 * @param {string} pPath
+	 * @returns {string|null}
+	 */
+	_sanitizePath(pPath)
+	{
+		if (!pPath || typeof (pPath) !== 'string')
+		{
+			return null;
+		}
+
+		let tmpPath = decodeURIComponent(pPath).replace(/^\/+/, '');
+
+		if (tmpPath.includes('..') || libPath.isAbsolute(tmpPath))
+		{
+			return null;
+		}
+
+		// Resolve and verify it stays within content root
+		let tmpAbsPath = libPath.join(this.contentPath, tmpPath);
+		if (!tmpAbsPath.startsWith(this.contentPath))
+		{
+			return null;
+		}
+
+		return tmpPath;
+	}
+
+	/**
+	 * Move a single file from source to destination within the content root.
+	 * Creates parent directories as needed.
+	 *
+	 * @param {string} pSource - Relative source path
+	 * @param {string} pDestination - Relative destination path
+	 * @param {function} fCallback - Callback(pError, { Source, Destination })
+	 */
+	moveFile(pSource, pDestination, fCallback)
+	{
+		try
+		{
+			let tmpSourceRel = this._sanitizePath(pSource);
+			let tmpDestRel = this._sanitizePath(pDestination);
+
+			if (!tmpSourceRel)
+			{
+				return fCallback(new Error('Invalid source path.'));
+			}
+			if (!tmpDestRel)
+			{
+				return fCallback(new Error('Invalid destination path.'));
+			}
+
+			let tmpSourceAbs = libPath.join(this.contentPath, tmpSourceRel);
+			let tmpDestAbs = libPath.join(this.contentPath, tmpDestRel);
+
+			if (!libFs.existsSync(tmpSourceAbs))
+			{
+				return fCallback(new Error('Source file not found: ' + tmpSourceRel));
+			}
+
+			// Don't overwrite existing files
+			if (libFs.existsSync(tmpDestAbs))
+			{
+				return fCallback(new Error('Destination already exists: ' + tmpDestRel));
+			}
+
+			// Create parent directory if needed
+			let tmpDestDir = libPath.dirname(tmpDestAbs);
+			if (!libFs.existsSync(tmpDestDir))
+			{
+				libFs.mkdirSync(tmpDestDir, { recursive: true });
+			}
+
+			// Try rename first (fast, same filesystem)
+			try
+			{
+				libFs.renameSync(tmpSourceAbs, tmpDestAbs);
+			}
+			catch (pRenameError)
+			{
+				// EXDEV = cross-device link; fall back to copy+unlink
+				if (pRenameError.code === 'EXDEV')
+				{
+					libFs.copyFileSync(tmpSourceAbs, tmpDestAbs);
+					libFs.unlinkSync(tmpSourceAbs);
+				}
+				else
+				{
+					throw pRenameError;
+				}
+			}
+
+			return fCallback(null, { Source: tmpSourceRel, Destination: tmpDestRel });
+		}
+		catch (pError)
+		{
+			return fCallback(pError);
+		}
+	}
+
+	/**
+	 * Move multiple files.  Records the batch in Bibliograph for undo.
+	 *
+	 * @param {Array<{Source:string, Destination:string}>} pMoves
+	 * @param {function} fCallback - Callback(pError, { BatchGUID, Completed, Failed })
+	 */
+	moveBatch(pMoves, fCallback)
+	{
+		let tmpSelf = this;
+
+		if (!Array.isArray(pMoves) || pMoves.length === 0)
+		{
+			return fCallback(new Error('No moves provided.'));
+		}
+
+		if (pMoves.length > this.options.MaxBatchSize)
+		{
+			return fCallback(new Error(`Batch exceeds maximum size of ${this.options.MaxBatchSize}.`));
+		}
+
+		// Pre-validate all paths before moving anything
+		let tmpValidatedMoves = [];
+		for (let i = 0; i < pMoves.length; i++)
+		{
+			let tmpMove = pMoves[i];
+			let tmpSourceRel = this._sanitizePath(tmpMove.Source);
+			let tmpDestRel = this._sanitizePath(tmpMove.Destination);
+
+			if (!tmpSourceRel || !tmpDestRel)
+			{
+				return fCallback(new Error(`Invalid path at index ${i}.`));
+			}
+
+			let tmpSourceAbs = libPath.join(this.contentPath, tmpSourceRel);
+			if (!libFs.existsSync(tmpSourceAbs))
+			{
+				return fCallback(new Error(`Source not found at index ${i}: ${tmpSourceRel}`));
+			}
+
+			let tmpDestAbs = libPath.join(this.contentPath, tmpDestRel);
+			if (libFs.existsSync(tmpDestAbs))
+			{
+				return fCallback(new Error(`Destination already exists at index ${i}: ${tmpDestRel}`));
+			}
+
+			tmpValidatedMoves.push(
+			{
+				Source: tmpSourceRel,
+				Destination: tmpDestRel,
+				SourceAbs: tmpSourceAbs,
+				DestAbs: tmpDestAbs
+			});
+		}
+
+		// Execute moves sequentially
+		let tmpCompleted = [];
+		let tmpFailed = [];
+		let tmpIndex = 0;
+
+		function _moveNext()
+		{
+			if (tmpIndex >= tmpValidatedMoves.length)
+			{
+				// Record batch in Bibliograph for undo
+				let tmpBatchGUID = tmpSelf.fable.getUUID();
+				let tmpBatchRecord =
+				{
+					GUID: tmpBatchGUID,
+					Timestamp: new Date().toISOString(),
+					Moves: tmpCompleted,
+					FailedCount: tmpFailed.length,
+					Status: (tmpFailed.length === 0) ? 'completed' : 'partial'
+				};
+
+				tmpSelf.fable.Bibliograph.write(SOURCE_NAME, tmpBatchGUID, tmpBatchRecord,
+					(pWriteError) =>
+					{
+						if (pWriteError)
+						{
+							tmpSelf.fable.log.warn(`Failed to record batch: ${pWriteError.message}`);
+						}
+
+						return fCallback(null,
+						{
+							BatchGUID: tmpBatchGUID,
+							Completed: tmpCompleted,
+							Failed: tmpFailed,
+							TotalMoved: tmpCompleted.length,
+							TotalFailed: tmpFailed.length
+						});
+					});
+				return;
+			}
+
+			let tmpMove = tmpValidatedMoves[tmpIndex];
+			tmpIndex++;
+
+			try
+			{
+				// Create parent directory if needed
+				let tmpDestDir = libPath.dirname(tmpMove.DestAbs);
+				if (!libFs.existsSync(tmpDestDir))
+				{
+					libFs.mkdirSync(tmpDestDir, { recursive: true });
+				}
+
+				// Try rename first
+				try
+				{
+					libFs.renameSync(tmpMove.SourceAbs, tmpMove.DestAbs);
+				}
+				catch (pRenameError)
+				{
+					if (pRenameError.code === 'EXDEV')
+					{
+						libFs.copyFileSync(tmpMove.SourceAbs, tmpMove.DestAbs);
+						libFs.unlinkSync(tmpMove.SourceAbs);
+					}
+					else
+					{
+						throw pRenameError;
+					}
+				}
+
+				tmpCompleted.push({ Source: tmpMove.Source, Destination: tmpMove.Destination });
+			}
+			catch (pMoveError)
+			{
+				tmpFailed.push(
+				{
+					Source: tmpMove.Source,
+					Destination: tmpMove.Destination,
+					Error: pMoveError.message
+				});
+			}
+
+			_moveNext();
+		}
+
+		// Initialize Bibliograph source, then proceed
+		this.fable.Bibliograph.createSource(SOURCE_NAME,
+			(pCreateError) =>
+			{
+				// createSource may error if source exists; that's fine
+				_moveNext();
+			});
+	}
+
+	/**
+	 * Undo a previously executed batch by reversing all moves.
+	 *
+	 * @param {string} pBatchGUID
+	 * @param {function} fCallback - Callback(pError, { Reversed, Failed })
+	 */
+	undoBatch(pBatchGUID, fCallback)
+	{
+		let tmpSelf = this;
+
+		this.fable.Bibliograph.createSource(SOURCE_NAME,
+			(pCreateError) =>
+			{
+				tmpSelf.fable.Bibliograph.read(SOURCE_NAME, pBatchGUID,
+					(pReadError, pRecord) =>
+					{
+						if (pReadError || !pRecord)
+						{
+							return fCallback(new Error('Batch not found: ' + pBatchGUID));
+						}
+
+						if (pRecord.Status === 'undone')
+						{
+							return fCallback(new Error('Batch already undone.'));
+						}
+
+						let tmpMoves = pRecord.Moves || [];
+						let tmpReversed = [];
+						let tmpFailed = [];
+
+						// Reverse in reverse order
+						for (let i = tmpMoves.length - 1; i >= 0; i--)
+						{
+							let tmpMove = tmpMoves[i];
+
+							try
+							{
+								let tmpCurrentAbs = libPath.join(tmpSelf.contentPath, tmpMove.Destination);
+								let tmpOriginalAbs = libPath.join(tmpSelf.contentPath, tmpMove.Source);
+
+								if (!libFs.existsSync(tmpCurrentAbs))
+								{
+									tmpFailed.push(
+									{
+										Source: tmpMove.Destination,
+										Destination: tmpMove.Source,
+										Error: 'File not found at current location'
+									});
+									continue;
+								}
+
+								// Re-create original directory if needed
+								let tmpOrigDir = libPath.dirname(tmpOriginalAbs);
+								if (!libFs.existsSync(tmpOrigDir))
+								{
+									libFs.mkdirSync(tmpOrigDir, { recursive: true });
+								}
+
+								try
+								{
+									libFs.renameSync(tmpCurrentAbs, tmpOriginalAbs);
+								}
+								catch (pRenameError)
+								{
+									if (pRenameError.code === 'EXDEV')
+									{
+										libFs.copyFileSync(tmpCurrentAbs, tmpOriginalAbs);
+										libFs.unlinkSync(tmpCurrentAbs);
+									}
+									else
+									{
+										throw pRenameError;
+									}
+								}
+
+								tmpReversed.push({ Source: tmpMove.Destination, Destination: tmpMove.Source });
+							}
+							catch (pUndoError)
+							{
+								tmpFailed.push(
+								{
+									Source: tmpMove.Destination,
+									Destination: tmpMove.Source,
+									Error: pUndoError.message
+								});
+							}
+						}
+
+						// Update batch record
+						pRecord.Status = 'undone';
+						pRecord.UndoneAt = new Date().toISOString();
+
+						tmpSelf.fable.Bibliograph.write(SOURCE_NAME, pBatchGUID, pRecord,
+							(pWriteError) =>
+							{
+								return fCallback(null,
+								{
+									Reversed: tmpReversed,
+									Failed: tmpFailed,
+									TotalReversed: tmpReversed.length,
+									TotalFailed: tmpFailed.length
+								});
+							});
+					});
+			});
+	}
+
+	/**
+	 * Wire REST endpoints.
+	 *
+	 * @param {object} pServiceServer - The Orator service server
+	 */
+	connectRoutes(pServiceServer)
+	{
+		let tmpSelf = this;
+		let tmpServer = pServiceServer.server;
+
+		// --- POST /api/files/mkdir ---
+		tmpServer.post('/api/files/mkdir',
+			(pRequest, pResponse, fNext) =>
+			{
+				try
+				{
+					let tmpPath = tmpSelf._sanitizePath(pRequest.body && pRequest.body.Path);
+
+					if (!tmpPath)
+					{
+						pResponse.send(400, { Success: false, Error: 'Invalid path.' });
+						return fNext();
+					}
+
+					let tmpAbsPath = libPath.join(tmpSelf.contentPath, tmpPath);
+
+					if (libFs.existsSync(tmpAbsPath))
+					{
+						pResponse.send(200, { Success: true, Path: tmpPath, AlreadyExists: true });
+						return fNext();
+					}
+
+					libFs.mkdirSync(tmpAbsPath, { recursive: true });
+					pResponse.send(200, { Success: true, Path: tmpPath });
+					return fNext();
+				}
+				catch (pError)
+				{
+					pResponse.send(500, { Success: false, Error: pError.message });
+					return fNext();
+				}
+			});
+
+		// --- POST /api/files/move ---
+		tmpServer.post('/api/files/move',
+			(pRequest, pResponse, fNext) =>
+			{
+				try
+				{
+					let tmpSource = pRequest.body && pRequest.body.Source;
+					let tmpDest = pRequest.body && pRequest.body.Destination;
+
+					tmpSelf.moveFile(tmpSource, tmpDest,
+						(pError, pResult) =>
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Success: false, Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(200, { Success: true, Source: pResult.Source, Destination: pResult.Destination });
+							return fNext();
+						});
+				}
+				catch (pError)
+				{
+					pResponse.send(500, { Success: false, Error: pError.message });
+					return fNext();
+				}
+			});
+
+		// --- POST /api/files/move-batch ---
+		tmpServer.post('/api/files/move-batch',
+			(pRequest, pResponse, fNext) =>
+			{
+				try
+				{
+					let tmpMoves = pRequest.body && pRequest.body.Moves;
+
+					tmpSelf.moveBatch(tmpMoves,
+						(pError, pResult) =>
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Success: false, Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(200,
+							{
+								Success: true,
+								BatchGUID: pResult.BatchGUID,
+								TotalMoved: pResult.TotalMoved,
+								TotalFailed: pResult.TotalFailed,
+								Completed: pResult.Completed,
+								Failed: pResult.Failed
+							});
+							return fNext();
+						});
+				}
+				catch (pError)
+				{
+					pResponse.send(500, { Success: false, Error: pError.message });
+					return fNext();
+				}
+			});
+
+		// --- POST /api/files/undo-batch ---
+		tmpServer.post('/api/files/undo-batch',
+			(pRequest, pResponse, fNext) =>
+			{
+				try
+				{
+					let tmpBatchGUID = pRequest.body && pRequest.body.BatchGUID;
+
+					if (!tmpBatchGUID)
+					{
+						pResponse.send(400, { Success: false, Error: 'Missing BatchGUID.' });
+						return fNext();
+					}
+
+					tmpSelf.undoBatch(tmpBatchGUID,
+						(pError, pResult) =>
+						{
+							if (pError)
+							{
+								pResponse.send(400, { Success: false, Error: pError.message });
+								return fNext();
+							}
+							pResponse.send(200,
+							{
+								Success: true,
+								TotalReversed: pResult.TotalReversed,
+								TotalFailed: pResult.TotalFailed,
+								Reversed: pResult.Reversed,
+								Failed: pResult.Failed
+							});
+							return fNext();
+						});
+				}
+				catch (pError)
+				{
+					pResponse.send(500, { Success: false, Error: pError.message });
+					return fNext();
+				}
+			});
+	}
+}
+
+module.exports = RetoldRemoteFileOperationService;

package/source/server/RetoldRemote-MediaService.js

@@ -18,15 +18,11 @@ const libUrl = require('url');
 const libToolDetector = require('./RetoldRemote-ToolDetector.js');
 const libThumbnailCache = require('./RetoldRemote-ThumbnailCache.js');
 
-const _ImageExtensions = { 'png': true, 'jpg': true, 'jpeg': true, 'gif': true, 'webp': true, 'svg': true, 'bmp': true, 'ico': true, 'avif': true, 'tiff': true, 'tif': true, 'heic': true, 'heif': true };
-const _VideoExtensions = { 'mp4': true, 'webm': true, 'mov': true, 'mkv': true, 'avi': true, 'wmv': true, 'flv': true, 'm4v': true, 'ogv': true, 'mpg': true, 'mpeg': true, 'mpe': true, 'mpv': true, 'm2v': true, 'ts': true, 'mts': true, 'm2ts': true, 'vob': true, '3gp': true, '3g2': true, 'f4v': true, 'rm': true, 'rmvb': true, 'divx': true, 'asf': true, 'mxf': true, 'dv': true, 'nsv': true, 'nuv': true, 'y4m': true, 'wtv': true, 'swf': true, 'dat': true };
-const _AudioExtensions = { 'mp3': true, 'wav': true, 'ogg': true, 'flac': true, 'aac': true, 'm4a': true, 'wma': true, 'oga': true };
-const _DocumentExtensions = { 'pdf': true, 'epub': true, 'mobi': true, 'doc': true, 'docx': true };
+const libExtensionMaps = require('../RetoldRemote-ExtensionMaps.js');
 
 const _DefaultServiceConfiguration =
 {
 	"ContentPath": ".",
-	"ThumbnailCachePath": null,
 	"APIRoutePrefix": "/api/media",
 	"DefaultThumbnailWidth": 200,
 	"DefaultThumbnailHeight": 200
@@ -51,12 +47,9 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
-		let tmpCachePath = this.options.ThumbnailCachePath
-			|| libPath.join(process.cwd(), 'dist', 'retold-cache', 'thumbnails');
-
 		this.toolDetector = new libToolDetector();
 		this.capabilities = this.toolDetector.detect();
-		this.thumbnailCache = new libThumbnailCache(tmpCachePath);
+		this.thumbnailCache = new libThumbnailCache(this.fable);
 		this.pathRegistry = this.options.PathRegistry || null;
 
 		this.fable.log.info(`Media Service: capabilities = ${JSON.stringify(this.capabilities)}`);
@@ -95,11 +88,7 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 	 */
 	_getMediaCategory(pExtension)
 	{
-		if (_ImageExtensions[pExtension]) return 'image';
-		if (_VideoExtensions[pExtension]) return 'video';
-		if (_AudioExtensions[pExtension]) return 'audio';
-		if (_DocumentExtensions[pExtension]) return 'document';
-		return 'other';
+		return libExtensionMaps.getCategory(pExtension);
 	}
 
 	/**
@@ -265,6 +254,7 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 									tmpProbe.Height = pMetadata.height;
 									tmpProbe.Codec = pMetadata.codec;
 									tmpProbe.Bitrate = pMetadata.bitrate;
+									tmpProbe.Tags = pMetadata.tags || {};
 								}
 								pResponse.send(tmpProbe);
 								return fNext();
@@ -502,6 +492,17 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 			{
 				tmpResult.duration = parseFloat(tmpData.format.duration) || null;
 				tmpResult.bitrate = parseInt(tmpData.format.bit_rate, 10) || null;
+
+				// Extract format-level tags (ID3, Vorbis comments, etc.)
+				if (tmpData.format.tags)
+				{
+					tmpResult.tags = {};
+					let tmpTagKeys = Object.keys(tmpData.format.tags);
+					for (let t = 0; t < tmpTagKeys.length; t++)
+					{
+						tmpResult.tags[tmpTagKeys[t].toLowerCase()] = tmpData.format.tags[tmpTagKeys[t]];
+					}
+				}
 			}
 
 			// Find video stream for dimensions