retold-content-system 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "retold-content-system",
-	"version": "1.0.9",
+	"version": "1.0.11",
 	"description": "Retold Content System - Markdown content viewer and editor",
 	"main": "source/Pict-ContentSystem-Bundle.js",
 	"bin": {
@@ -17,7 +17,7 @@
 		"LICENSE"
 	],
 	"scripts": {
-		"start": "node source/server/Simple-Server.js",
+		"start": "node source/cli/ContentSystem-CLI-Run.js serve",
 		"build": "npx quack build && npx quack copy",
 		"build-codemirror": "node build/build-codemirror-bundle.js",
 		"build-codejar": "node build/build-codejar-bundle.js",
@@ -27,11 +27,14 @@
 	},
 	"author": "steven velozo <steven@velozo.com>",
 	"license": "MIT",
+	"optionalDependencies": {
+		"ultravisor-beacon": "^0.0.1"
+	},
 	"dependencies": {
-		"fable": "^3.1.65",
+		"fable": "^3.1.66",
 		"orator": "^6.0.4",
 		"orator-serviceserver-restify": "^2.0.9",
-		"pict": "^1.0.357",
+		"pict": "^1.0.359",
 		"pict-application": "^1.0.33",
 		"pict-docuserve": "^0.0.32",
 		"pict-provider": "^1.0.12",
@@ -50,7 +53,7 @@
 		"codemirror": "^6.0.2",
 		"esbuild": "^0.27.4",
 		"highlight.js": "^11.11.1",
-		"quackage": "^1.0.64"
+		"quackage": "^1.0.65"
 	},
 	"copyFilesSettings": {
 		"whenFileExists": "overwrite"

package/source/Pict-Application-ContentEditor.js

@@ -117,7 +117,7 @@ class ContentEditorApplication extends libPictApplication
 			// Settings
 			AutoSegmentMarkdown: false,
 			AutoSegmentDepth: 1,
-			AutoContentPreview: true,
+			ContentPreviewMode: 'off',
 			MarkdownEditingControls: true,
 			MarkdownWordWrap: true,
 			CodeWordWrap: false,
@@ -738,19 +738,8 @@ class ContentEditorApplication extends libPictApplication
 					tmpEditorView.render();
 					tmpEditorView.marshalToView();
 
-					// Always ensure the global preview class is clear so
-					// per-segment toggles work.
-					tmpEditorView.togglePreview(true);
-
-					// Set per-segment preview visibility based on the
-					// Auto Content Preview setting.  We must always loop
-					// to clear any stale _hiddenPreviewSegments state
-					// from previous file loads.
-					let tmpShowPreviews = !!tmpSelf.pict.AppData.ContentEditor.AutoContentPreview;
-					for (let tmpIdx in tmpEditorView._segmentEditors)
-					{
-						tmpEditorView.toggleSegmentPreview(parseInt(tmpIdx, 10), tmpShowPreviews);
-					}
+					// Apply the Content Preview Mode setting
+					tmpEditorView.setPreviewMode(tmpSelf.pict.AppData.ContentEditor.ContentPreviewMode || 'off');
 
 					// Apply the Editing Controls setting (line numbers
 					// and right sidebar) via the library's toggleControls.
@@ -1426,7 +1415,7 @@ class ContentEditorApplication extends libPictApplication
 		{
 			AutoSegmentMarkdown: tmpSettings.AutoSegmentMarkdown,
 			AutoSegmentDepth: tmpSettings.AutoSegmentDepth,
-			AutoContentPreview: tmpSettings.AutoContentPreview,
+			ContentPreviewMode: tmpSettings.ContentPreviewMode,
 			MarkdownEditingControls: tmpSettings.MarkdownEditingControls,
 			MarkdownWordWrap: tmpSettings.MarkdownWordWrap,
 			CodeWordWrap: tmpSettings.CodeWordWrap,
@@ -1479,9 +1468,14 @@ class ContentEditorApplication extends libPictApplication
 			{
 				tmpSettings.AutoSegmentDepth = tmpStored.AutoSegmentDepth;
 			}
-			if (typeof (tmpStored.AutoContentPreview) === 'boolean')
+			if (typeof (tmpStored.ContentPreviewMode) === 'string')
+			{
+				tmpSettings.ContentPreviewMode = tmpStored.ContentPreviewMode;
+			}
+			else if (typeof (tmpStored.AutoContentPreview) === 'boolean')
 			{
-				tmpSettings.AutoContentPreview = tmpStored.AutoContentPreview;
+				// Backward compat: migrate old boolean setting
+				tmpSettings.ContentPreviewMode = tmpStored.AutoContentPreview ? 'bottom' : 'off';
 			}
 			if (typeof (tmpStored.MarkdownEditingControls) === 'boolean')
 			{

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

@@ -402,6 +402,15 @@ function setupContentSystemServer(pOptions, fCallback)
 			tmpOrator.startService(
 				function ()
 				{
+					// --- Optional Ultravisor Beacon Integration ---
+					// When pOptions.Beacon is provided and Enabled is true,
+					// register this content system as a beacon worker.
+					let tmpBeaconConfig = pOptions.Beacon || {};
+					if (tmpBeaconConfig.Enabled)
+					{
+						_initializeBeacon(tmpFable, tmpContentPath, tmpBeaconConfig);
+					}
+
 					return fCallback(null,
 					{
 						Fable: tmpFable,
@@ -412,4 +421,266 @@ function setupContentSystemServer(pOptions, fCallback)
 		});
 }
 
+// ═══════════════════════════════════════════════════════════════════
+//  Ultravisor Beacon Integration
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * Initialize the Ultravisor beacon service and register ContentSystem
+ * capabilities.  This is opt-in — only called when Beacon.Enabled is true.
+ *
+ * @param {object} pFable - Fable instance
+ * @param {string} pContentPath - Resolved content directory path
+ * @param {object} pBeaconConfig - Beacon configuration object
+ */
+function _initializeBeacon(pFable, pContentPath, pBeaconConfig)
+{
+	let libBeaconService;
+	try
+	{
+		libBeaconService = require('ultravisor-beacon');
+	}
+	catch (pError)
+	{
+		pFable.log.warn(`Content System Beacon: ultravisor-beacon not installed. Skipping beacon init.`);
+		return;
+	}
+
+	pFable.serviceManager.addAndInstantiateServiceType('UltravisorBeacon', libBeaconService, pBeaconConfig);
+	let tmpBeacon = pFable.services.UltravisorBeacon;
+
+	tmpBeacon.registerCapability({
+		Capability: 'ContentSystem',
+		Name: 'ContentSystemProvider',
+		actions:
+		{
+			'ReadFile':
+			{
+				Description: 'Read a content file',
+				SettingsSchema: [
+					{ Name: 'FilePath', DataType: 'String', Required: true }
+				],
+				Handler: function (pWorkItem, pContext, fCallback)
+				{
+					try
+					{
+						let tmpFilePath = sanitizePath(pWorkItem.Settings.FilePath);
+						if (!tmpFilePath)
+						{
+							return fCallback(null, {
+								Outputs: { Content: '', StdOut: 'Invalid file path.' },
+								Log: ['ReadFile: invalid or unsafe path rejected.']
+							});
+						}
+
+						let tmpFullPath = libPath.join(pContentPath, tmpFilePath);
+						let tmpRealContent = libFs.realpathSync(pContentPath);
+						if (!tmpFullPath.startsWith(tmpRealContent))
+						{
+							return fCallback(null, {
+								Outputs: { Content: '', StdOut: 'Access denied.' },
+								Log: ['ReadFile: path outside content directory.']
+							});
+						}
+
+						if (!libFs.existsSync(tmpFullPath))
+						{
+							return fCallback(null, {
+								Outputs: { Content: '', StdOut: 'File not found.' },
+								Log: [`ReadFile: ${tmpFilePath} not found.`]
+							});
+						}
+
+						let tmpContent = libFs.readFileSync(tmpFullPath, 'utf8');
+						pFable.log.info(`Beacon ReadFile: ${tmpFilePath} (${tmpContent.length} bytes)`);
+						return fCallback(null, {
+							Outputs: { Content: tmpContent, StdOut: `Read ${tmpContent.length} bytes from ${tmpFilePath}` },
+							Log: [`ReadFile: read ${tmpContent.length} bytes from ${tmpFilePath}`]
+						});
+					}
+					catch (pError)
+					{
+						return fCallback(pError);
+					}
+				}
+			},
+
+			'SaveFile':
+			{
+				Description: 'Save content to a file',
+				SettingsSchema: [
+					{ Name: 'FilePath', DataType: 'String', Required: true },
+					{ Name: 'Content', DataType: 'String', Required: true }
+				],
+				Handler: function (pWorkItem, pContext, fCallback)
+				{
+					try
+					{
+						let tmpFilePath = sanitizePath(pWorkItem.Settings.FilePath);
+						if (!tmpFilePath)
+						{
+							return fCallback(null, {
+								Outputs: { FilePath: '', StdOut: 'Invalid file path.' },
+								Log: ['SaveFile: invalid or unsafe path rejected.']
+							});
+						}
+
+						let tmpFullPath = libPath.join(pContentPath, tmpFilePath);
+						let tmpRealContent = libFs.realpathSync(pContentPath);
+						let tmpTargetDir = libPath.dirname(tmpFullPath);
+						if (!tmpTargetDir.startsWith(tmpRealContent))
+						{
+							return fCallback(null, {
+								Outputs: { FilePath: '', StdOut: 'Access denied.' },
+								Log: ['SaveFile: path outside content directory.']
+							});
+						}
+
+						// Ensure directory exists
+						if (!libFs.existsSync(tmpTargetDir))
+						{
+							libFs.mkdirSync(tmpTargetDir, { recursive: true });
+						}
+
+						let tmpContent = pWorkItem.Settings.Content || '';
+						libFs.writeFileSync(tmpFullPath, tmpContent, 'utf8');
+						pFable.log.info(`Beacon SaveFile: ${tmpFilePath} (${tmpContent.length} bytes)`);
+						return fCallback(null, {
+							Outputs: { FilePath: tmpFilePath, StdOut: `Saved ${tmpContent.length} bytes to ${tmpFilePath}` },
+							Log: [`SaveFile: wrote ${tmpContent.length} bytes to ${tmpFilePath}`]
+						});
+					}
+					catch (pError)
+					{
+						return fCallback(pError);
+					}
+				}
+			},
+
+			'ListFiles':
+			{
+				Description: 'List files in a content directory',
+				SettingsSchema: [
+					{ Name: 'Path', DataType: 'String', Required: false }
+				],
+				Handler: function (pWorkItem, pContext, fCallback)
+				{
+					try
+					{
+						let tmpRelPath = pWorkItem.Settings.Path || '';
+						let tmpSafePath = tmpRelPath ? sanitizePath(tmpRelPath) : '';
+						let tmpTargetPath = tmpSafePath
+							? libPath.join(pContentPath, tmpSafePath)
+							: pContentPath;
+
+						let tmpRealContent = libFs.realpathSync(pContentPath);
+						if (!tmpTargetPath.startsWith(tmpRealContent))
+						{
+							return fCallback(null, {
+								Outputs: { Files: '[]', StdOut: 'Access denied.' },
+								Log: ['ListFiles: path outside content directory.']
+							});
+						}
+
+						if (!libFs.existsSync(tmpTargetPath))
+						{
+							return fCallback(null, {
+								Outputs: { Files: '[]', StdOut: 'Directory not found.' },
+								Log: [`ListFiles: ${tmpSafePath || '/'} not found.`]
+							});
+						}
+
+						let tmpEntries = libFs.readdirSync(tmpTargetPath, { withFileTypes: true });
+						let tmpFiles = tmpEntries.map(function (pEntry)
+						{
+							return {
+								Name: pEntry.name,
+								IsDirectory: pEntry.isDirectory()
+							};
+						});
+
+						pFable.log.info(`Beacon ListFiles: ${tmpSafePath || '/'} (${tmpFiles.length} entries)`);
+						return fCallback(null, {
+							Outputs: { Files: JSON.stringify(tmpFiles), StdOut: `Found ${tmpFiles.length} entries in ${tmpSafePath || '/'}` },
+							Log: [`ListFiles: ${tmpFiles.length} entries in ${tmpSafePath || '/'}`]
+						});
+					}
+					catch (pError)
+					{
+						return fCallback(pError);
+					}
+				}
+			},
+
+			'CreateFolder':
+			{
+				Description: 'Create a folder in the content directory',
+				SettingsSchema: [
+					{ Name: 'Path', DataType: 'String', Required: true }
+				],
+				Handler: function (pWorkItem, pContext, fCallback)
+				{
+					try
+					{
+						let tmpSafePath = sanitizePath(pWorkItem.Settings.Path);
+						if (!tmpSafePath)
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: 'Invalid folder path.' },
+								Log: ['CreateFolder: invalid or unsafe path rejected.']
+							});
+						}
+
+						let tmpFullPath = libPath.join(pContentPath, tmpSafePath);
+						let tmpRealContent = libFs.realpathSync(pContentPath);
+						let tmpTargetParent = libPath.dirname(tmpFullPath);
+						if (libFs.existsSync(tmpTargetParent))
+						{
+							tmpTargetParent = libFs.realpathSync(tmpTargetParent);
+						}
+						if (!tmpTargetParent.startsWith(tmpRealContent))
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: 'Access denied.' },
+								Log: ['CreateFolder: path outside content directory.']
+							});
+						}
+
+						if (libFs.existsSync(tmpFullPath))
+						{
+							return fCallback(null, {
+								Outputs: { StdOut: 'Folder already exists.' },
+								Log: [`CreateFolder: ${tmpSafePath} already exists.`]
+							});
+						}
+
+						libFs.mkdirSync(tmpFullPath, { recursive: true });
+						pFable.log.info(`Beacon CreateFolder: ${tmpSafePath}`);
+						return fCallback(null, {
+							Outputs: { StdOut: `Created folder ${tmpSafePath}` },
+							Log: [`CreateFolder: created ${tmpSafePath}`]
+						});
+					}
+					catch (pError)
+					{
+						return fCallback(pError);
+					}
+				}
+			}
+		}
+	});
+
+	tmpBeacon.enable(function (pError)
+	{
+		if (pError)
+		{
+			pFable.log.warn(`Content System Beacon: enable failed: ${pError.message}`);
+		}
+		else
+		{
+			pFable.log.info('Content System Beacon: enabled and connected to Ultravisor.');
+		}
+	});
+}
+
 module.exports = setupContentSystemServer;

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

@@ -18,6 +18,15 @@ class ContentSystemCommandServe extends libCommandLineCommand
 		this.options.CommandOptions.push(
 			{ Name: '-p, --port [port]', Description: 'Port to serve on (defaults to random 7000-7999).', Default: '0' });
 
+		this.options.CommandOptions.push(
+			{ Name: '-b, --beacon [url]', Description: 'Enable beacon mode and connect to the Ultravisor server at [url] (e.g. http://localhost:54321).' });
+
+		this.options.CommandOptions.push(
+			{ Name: '--beacon-name [name]', Description: 'Beacon identity name (defaults to "content-system-1").', Default: 'content-system-1' });
+
+		this.options.CommandOptions.push(
+			{ Name: '--beacon-password [password]', Description: 'Beacon authentication password.', Default: '' });
+
 		this.addCommand();
 	}
 
@@ -55,6 +64,17 @@ class ContentSystemCommandServe extends libCommandLineCommand
 			this.log.info(`Created content directory: ${tmpContentPath}`);
 		}
 
+		let tmpBeaconConfig = {};
+		if (this.CommandOptions.beacon)
+		{
+			tmpBeaconConfig = {
+				Enabled: true,
+				ServerURL: (typeof this.CommandOptions.beacon === 'string') ? this.CommandOptions.beacon : 'http://localhost:54321',
+				Name: this.CommandOptions.beaconName || 'content-system-1',
+				Password: this.CommandOptions.beaconPassword || ''
+			};
+		}
+
 		let tmpSelf = this;
 		let tmpSetupServer = require('../ContentSystem-Server-Setup.js');
 
@@ -62,7 +82,8 @@ class ContentSystemCommandServe extends libCommandLineCommand
 			{
 				ContentPath: tmpContentPath,
 				DistPath: tmpDistPath,
-				Port: tmpPort
+				Port: tmpPort,
+				Beacon: tmpBeaconConfig
 			},
 			function (pError, pServerInfo)
 			{

package/source/views/PictView-Editor-SettingsPanel.js

@@ -274,11 +274,15 @@ const _ViewConfiguration =
 						onchange="{~P~}.views['ContentEditor-SettingsPanel'].onEditingControlsChanged(this.checked)">
 				</div>
 				<div class="content-editor-settings-row">
-					<label class="content-editor-settings-checkbox-label"
-						for="ContentEditor-Setting-AutoPreview">Auto Content Preview</label>
-					<input type="checkbox" class="content-editor-settings-checkbox"
-						id="ContentEditor-Setting-AutoPreview"
-						onchange="{~P~}.views['ContentEditor-SettingsPanel'].onAutoPreviewChanged(this.checked)">
+					<span class="content-editor-settings-select-label">Content Preview</span>
+					<select class="content-editor-settings-select"
+						id="ContentEditor-Setting-ContentPreviewMode"
+						onchange="{~P~}.views['ContentEditor-SettingsPanel'].onContentPreviewModeChanged(this.value)">
+						<option value="off">Off</option>
+						<option value="bottom">Underneath</option>
+						<option value="side">Beside</option>
+						<option value="tabbed">Tab</option>
+					</select>
 				</div>
 				<div class="content-editor-settings-row">
 					<label class="content-editor-settings-checkbox-label"
@@ -387,10 +391,10 @@ class ContentEditorSettingsPanelView extends libPictView
 			tmpControlsCheckbox[0].checked = tmpSettings.MarkdownEditingControls;
 		}
 
-		let tmpPreviewCheckbox = this.pict.ContentAssignment.getElement('#ContentEditor-Setting-AutoPreview');
-		if (tmpPreviewCheckbox && tmpPreviewCheckbox[0])
+		let tmpPreviewSelect = this.pict.ContentAssignment.getElement('#ContentEditor-Setting-ContentPreviewMode');
+		if (tmpPreviewSelect && tmpPreviewSelect[0])
 		{
-			tmpPreviewCheckbox[0].checked = tmpSettings.AutoContentPreview;
+			tmpPreviewSelect[0].value = tmpSettings.ContentPreviewMode || 'off';
 		}
 
 		let tmpSegmentCheckbox = this.pict.ContentAssignment.getElement('#ContentEditor-Setting-AutoSegment');
@@ -535,32 +539,15 @@ class ContentEditorSettingsPanelView extends libPictView
 		}
 	}
 
-	onAutoPreviewChanged(pChecked)
+	onContentPreviewModeChanged(pMode)
 	{
-		this.pict.AppData.ContentEditor.AutoContentPreview = pChecked;
+		this.pict.AppData.ContentEditor.ContentPreviewMode = pMode;
 		this.pict.PictApplication.saveSettings();
 
 		let tmpEditorView = this.pict.views['ContentEditor-MarkdownEditor'];
 		if (tmpEditorView && this.pict.AppData.ContentEditor.ActiveEditor === 'markdown')
 		{
-			if (pChecked)
-			{
-				// Turning ON: clear global hidden class and show all previews
-				tmpEditorView.togglePreview(true);
-				for (let tmpIdx in tmpEditorView._segmentEditors)
-				{
-					tmpEditorView.toggleSegmentPreview(parseInt(tmpIdx, 10), true);
-				}
-			}
-			else
-			{
-				// Turning OFF: hide each segment individually so
-				// per-segment toggle buttons still work
-				for (let tmpIdx in tmpEditorView._segmentEditors)
-				{
-					tmpEditorView.toggleSegmentPreview(parseInt(tmpIdx, 10), false);
-				}
-			}
+			tmpEditorView.setPreviewMode(pMode);
 		}
 	}