@glassnote/client 2.4.0

package/main.js

@@ -0,0 +1,745 @@
+const {
+	app,
+	BrowserWindow,
+	Notification,
+	Tray,
+	Menu,
+	screen,
+} = require('electron');
+const packageJson = require('./package.json');
+const LocalServer = require('./localserver');
+const userData = require('./userData');
+const { ipcMain } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const AutoStart = require('./autoStart');
+const AutoUpdate = require('./autoupdate');
+const NpmUpdate = require('./npmUpdate');
+const npmMode = require('./npmMode');
+const AutoUpdateRenderer = require('./autoupdate_renderer');
+const { createTailUtility } = require('./logUtilities');
+
+const logRenderer = packageJson.logRenderer !== undefined ? packageJson.logRenderer : true;
+
+// Sin empaquetar, electron llamaría a la app "Electron" en la bandeja, el menú de macOS
+// y las notificaciones. Instalado por npm eso es siempre el caso, así que se nombra a
+// mano. Los datos de usuario no dependen de esto (userData.js calcula su propia ruta).
+app.setName('glassnote');
+
+let mainWindow;
+let localServer = null;
+let tray = null;
+let lockCheckerInterval = null;
+let lockCheckerTimeout = null;
+let isCleaningUp = false;
+
+
+// Inicializar y pasar datos de usuario
+const uuid = userData.getUUID();
+
+// Configure logging - usar el directorio personalizado en lugar de Electron
+const logsDir = path.join(userData.getUserDataDir(), 'logs');
+if (!fs.existsSync(logsDir)) {
+	fs.mkdirSync(logsDir, { recursive: true });
+}
+
+// Clean up old logs (older than 30 days)
+function cleanupOldLogs() {
+	try {
+		const files = fs.readdirSync(logsDir);
+		const now = Date.now();
+		const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1000;
+
+		files.forEach((file) => {
+			if (file.endsWith('.log')) {
+				const filePath = path.join(logsDir, file);
+				const stats = fs.statSync(filePath);
+				if (stats.mtimeMs < thirtyDaysAgo) {
+					fs.unlinkSync(filePath);
+				}
+			}
+		});
+	} catch (error) {
+		console.error('Error cleaning up old logs:', error);
+	}
+}
+
+// Create log file for current session
+const currentDate = new Date().toISOString().split('T')[0];
+const logFilePath = path.join(logsDir, `glassnote-${currentDate}.log`);
+
+// Override console.log to write to file
+const originalConsoleLog = console.log;
+console.log = function (...args) {
+	const timestamp = new Date().toISOString();
+	const message = args
+		.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
+		.join(' ');
+
+	const logMessage = `[${timestamp}] ${message}\n`;
+	
+
+	// Write to file
+	try {
+		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+	} catch (error) {
+		originalConsoleLog.apply(console, ['Error writing to log file:', error]);
+	}
+
+	// Call original console.log
+	originalConsoleLog.apply(console, args);
+};
+console.warn('====== APPLICATION START ======');
+let initialLock = Date.now().toString();
+
+// Override console.error as well
+const originalConsoleError = console.error;
+console.error = function (...args) {
+	const timestamp = new Date().toISOString();
+	const message = args
+		.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
+		.join(' ');
+
+	const logMessage = `[${timestamp}] ERROR: ${message}\n`;
+
+	// Write to file
+	try {
+		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+	} catch (error) {
+		originalConsoleError.apply(console, ['Error writing to log file:', error]);
+	}
+
+	// Call original console.error
+	originalConsoleError.apply(console, args);
+};
+
+// Clean up old logs on startup
+cleanupOldLogs();
+
+// Create tail utility in logs directory for debugging
+createTailUtility(logsDir);
+
+app.whenReady().then(() => {
+	// Configure auto-start - this will handle shortcut creation
+	//
+	// Corriendo por `npx` no se registra nada: la app vive en la caché de npx, que se
+	// limpia sola. Una entrada de arranque automático apuntando ahí queda rota sin que
+	// nadie se entere. Quien quiera que arranque solo, instala: `npx glassnote install`.
+	if (npmMode.isEphemeral()) {
+		console.log('[autostart] modo npx: no se registra el arranque automático');
+	} else {
+		try {
+			const autoStart = new AutoStart();
+			const autoStartResult = autoStart.configureAutoStart();
+			if (!autoStartResult) {
+				console.log('Auto-start configuration may have failed, but application will continue running normally');
+			}
+		} catch (error) {
+			console.error('Auto-start configuration failed, but application will continue running normally:', error.message);
+		}
+	}
+
+	// Configure auto-update
+	//
+	// Instalado por npm no hay instalador que bajar: actualizar es `npm install -g` y
+	// reabrir. El updater de S3 (.exe/.dmg) queda solo para los builds nativos, que
+	// están en deprecación — ver README, sección «Instalación».
+	const autoUpdate = npmMode.isNpmMode() ? new NpmUpdate() : new AutoUpdate();
+	autoUpdate.start();
+
+	// Create system tray with platform-appropriate icon
+	let iconPath;
+	if (process.platform === 'win32') {
+		iconPath = path.join(__dirname, 'images/icon.ico');
+	} else if (process.platform === 'darwin') {
+		// macOS uses smaller tray icons - use icon-16.png for proper sizing
+		iconPath = path.join(__dirname, 'images/icon-16.png');
+	} else {
+		iconPath = path.join(__dirname, 'images/icon.png');
+	}
+	tray = new Tray(iconPath);
+	const contextMenu = Menu.buildFromTemplate([
+		{
+			label: `glassnote v${packageJson.version}`,
+			enabled: false,
+		},
+		{ type: 'separator' },
+		{
+			label: 'Config Menu',
+			click: () => {
+				// Enviar mensaje al renderer para mostrar el ConfigMenu con vista Review
+				if (mainWindow && !mainWindow.isDestroyed()) {
+					mainWindow.webContents.send('show-config-menu', 'review');
+				}
+			}
+		}
+	]);
+	tray.setToolTip(`GlassNote v${packageJson.version}`);
+	tray.setContextMenu(contextMenu);
+	
+	// Agregar funcionalidad de click izquierdo para mostrar el Config Menu
+	tray.on('click', () => {
+		// Enviar mensaje al renderer para mostrar el ConfigMenu con vista Review
+		if (mainWindow && !mainWindow.isDestroyed()) {
+			mainWindow.webContents.send('show-config-menu', 'review');
+		}
+	});
+
+	// Platform-specific window configuration
+	// On macOS: Use screen dimensions instead of fullscreen to avoid virtual desktop behavior
+	// On Windows: Keep original fullscreen behavior
+	let windowOptions = {
+		transparent: true,
+		frame: false,
+		alwaysOnTop: true,
+		skipTaskbar: true,
+		resizable: false,
+		x: 0,
+		y: 0,
+		acceptFirstMouse: true,
+		webPreferences: {
+			nodeIntegration: false,
+			contextIsolation: true,
+			enableRemoteModule: false,
+			preload: path.join(__dirname, 'preload.js'),
+			sandbox: false, // Allow access to Node.js modules in preload
+			webSecurity: false, // Allow connections to local WebSocket servers
+		},
+	};
+
+	if (process.platform === 'darwin') {
+		// macOS
+		const primaryDisplay = screen.getPrimaryDisplay();
+		const { width, height } = primaryDisplay.workAreaSize;
+		windowOptions.width = width;
+		windowOptions.height = height;
+		// Explicitly set fullscreen to false for macOS
+		windowOptions.fullscreen = false;
+	} else {
+		// Windows and other platforms
+		windowOptions.width = 400;
+		windowOptions.height = 300;
+		windowOptions.fullscreen = true;
+	}
+
+	mainWindow = new BrowserWindow(windowOptions);
+
+	// Interceptar console.log de la página renderizada
+	if (logRenderer) {
+		mainWindow.webContents.on(
+			'console-message',
+			(event, level, message, line, sourceId) => {
+				const levels = ['', 'INFO', 'WARNING', 'ERROR', 'DEBUG'];
+				const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
+				const logMessage = `[${timestamp}] [RENDERER ${levels[level]}] ${message} (${sourceId}:${line})`;
+
+				// Write to both console and log file
+				console.info(logMessage);
+				// Also write directly to log file to ensure it's captured
+				const fileLogMessage = `[${timestamp}] ${logMessage}\n`;
+				try {
+					fs.appendFileSync(logFilePath, fileLogMessage, 'utf8');
+				} catch (error) {
+					console.error('Error writing renderer log to file:', error);
+				}
+			}
+		);
+	}
+
+	// Generic userData operations via IPC
+	ipcMain.on('get-user-data', (event, { key, nestedKey }) => {
+		try {
+			const value = userData.get(key, nestedKey);
+			
+			// Serialize the value for IPC communication
+			let serializableValue;
+			if (value === undefined || value === null) {
+				serializableValue = null;
+			} else {
+				// Convert to JSON string and back to ensure proper serialization
+				serializableValue = JSON.parse(JSON.stringify(value));
+			}
+			
+			event.reply('user-data-response', { key, nestedKey, value: serializableValue, success: true });
+		} catch (error) {
+			console.error('Error getting user data for key:', key, 'nestedKey:', nestedKey, error);
+			event.reply('user-data-response', { key, nestedKey, value: null, success: false, error: error.message });
+		}
+	});
+
+	// Direct userData operation for IPC serialization issues
+	ipcMain.on('get-user-data-direct', (event, { key, nestedKey }) => {
+		try {
+			const value = userData.get(key, nestedKey);
+			
+			// Use a different approach for direct communication
+			// Send the value as a JSON string to avoid IPC serialization issues
+			const response = {
+				key,
+				nestedKey,
+				value: value ? JSON.stringify(value) : null,
+				success: true
+			};
+			
+			event.reply('user-data-direct-response', response);
+		} catch (error) {
+			console.error('Error getting user data directly for key:', key, 'nestedKey:', nestedKey, error);
+			event.reply('user-data-direct-response', { key, nestedKey, value: null, success: false, error: error.message });
+		}
+	});
+
+	ipcMain.on('set-user-data', (event, { key, nestedKey, value }) => {
+		try {
+			const success = userData.set(key, nestedKey, value);
+			event.reply('user-data-response', { key, nestedKey, value, success });
+			
+			// If setting servers, send updated list to renderer
+			if (key === 'servers' && Array.isArray(value) && nestedKey === undefined) {
+				if (mainWindow && !mainWindow.isDestroyed()) {
+					mainWindow.webContents.send('servers-list', value);
+				}
+			}
+		} catch (error) {
+			console.error('Error setting user data for key:', key, 'nestedKey:', nestedKey, error);
+			event.reply('user-data-response', { key, nestedKey, value, success: false, error: error.message });
+		}
+	});
+
+	ipcMain.on('remove-user-data', (event, { key, nestedKey }) => {
+		try {
+			const success = userData.remove(key, nestedKey);
+			event.reply('user-data-response', { key, nestedKey, value: null, success });
+		} catch (error) {
+			console.error('Error removing user data for key:', key, 'nestedKey:', nestedKey, error);
+			event.reply('user-data-response', { key, nestedKey, value: null, success: false, error: error.message });
+		}
+	});
+
+	// Initialize renderer auto-update after mainWindow is created
+	const autoUpdateRenderer = new AutoUpdateRenderer((version) => {
+		// Recargar la ventana para aplicar los cambios
+		setTimeout(() => {
+			reloadMainWindow();
+		}, 1000);
+	});
+	autoUpdateRenderer.start();
+
+	// Cargar el HTML del renderer (priorizar userData, fallback a app)
+	loadRendererHtml(mainWindow, uuid);
+
+	// Mouse events control
+	mainWindow.setIgnoreMouseEvents(true, { forward: true });
+	ipcMain.on('set-ignore-events-true', () => {
+		mainWindow.setIgnoreMouseEvents(true, { forward: true });
+	});
+	ipcMain.on('set-ignore-events-false', () => {
+		mainWindow.setIgnoreMouseEvents(false, { forward: true });
+	});
+
+	// Window visibility control
+	ipcMain.on('show-window', () => {
+		if (mainWindow && !mainWindow.isDestroyed()) {
+			mainWindow.show();
+		}
+	});
+
+	ipcMain.on('hide-window', () => {
+		if (mainWindow && !mainWindow.isDestroyed()) {
+			mainWindow.hide();
+		}
+	});
+
+	mainWindow.setAlwaysOnTop(true, 'screen-saver');
+	mainWindow.webContents.on('did-finish-load', () => {
+	  mainWindow.webContents.send('servers-list', userData.readData().servers);
+	  mainWindow.webContents.send('app-data', { version: packageJson.version });
+	});
+
+
+	// Handle external URL opening
+	ipcMain.on('open-external', (event, url) => {
+		const { shell } = require('electron');
+		shell.openExternal(url);
+	});
+
+	ipcMain.on('open-external-browser', (event, url) => {
+		const { shell } = require('electron');
+		shell.openExternal(url);
+	});
+
+	// Handle registration window opening (larger window without menus)
+	ipcMain.on('open-registration-window', (event, url) => {
+		// Create a custom browser window for registration
+		const registrationWindow = new BrowserWindow({
+			width: 1200,
+			height: 800,
+			minWidth: 800,
+			minHeight: 600,
+			show: false,
+			titleBarStyle: 'default',
+			autoHideMenuBar: true,
+			webPreferences: {
+				nodeIntegration: false,
+				contextIsolation: true,
+				webSecurity: true
+			}
+		});
+
+		// Remove menu bar
+		registrationWindow.setMenuBarVisibility(false);
+
+		// Load the URL
+		registrationWindow.loadURL(url);
+
+		// Show window when ready
+		registrationWindow.once('ready-to-show', () => {
+			registrationWindow.show();
+		});
+
+		// Handle window closed
+		registrationWindow.on('closed', () => {
+			// Window closed, no action needed
+		});
+	});
+
+	mainWindow.on('ready-to-show', () => {
+		mainWindow.show();
+
+		// Use LocalServer singleton
+		if (!localServer) {
+			localServer = new LocalServer();
+			localServer.start(mainWindow);
+		} else {
+			// Update the mainWindow reference if server already exists
+			localServer.updateMainWindow(mainWindow);
+		}
+	});
+
+	lockChecker();
+});
+
+app.on('window-all-closed', () => {
+	// Don't quit when all windows are closed if we have a tray
+	if (tray && process.platform !== 'darwin') {
+		// Keep the app running with tray
+	} else {
+		cleanupAndQuit();
+	}
+});
+
+// Clean up on quit
+app.on('before-quit', () => {
+	if (!isCleaningUp) {
+		// Clear intervals and timeouts
+		if (lockCheckerInterval) {
+			clearInterval(lockCheckerInterval);
+			lockCheckerInterval = null;
+		}
+		if (lockCheckerTimeout) {
+			clearTimeout(lockCheckerTimeout);
+			lockCheckerTimeout = null;
+		}
+		
+		// Destroy main window
+		if (mainWindow && !mainWindow.isDestroyed()) {
+			mainWindow.destroy();
+			mainWindow = null;
+		}
+		
+		// Stop local server
+		if (localServer) {
+			localServer.stop();
+			localServer = null;
+		}
+		
+		// Destroy tray
+		if (tray) {
+			tray.destroy();
+			tray = null;
+		}
+	}
+});
+
+function lockChecker() {
+	lockCheckerTimeout = setTimeout(() => {
+		userData.set('lock', initialLock);
+	}, 1000);
+	lockCheckerInterval = setInterval(() => {
+		// Leer el lock directamente del archivo, no del cache
+		const currentData = userData.getLockFromFile();
+		// Si currentData es undefined, significa que el archivo .glassnote fue borrado o corrompido
+		// También verificar si el valor del lock cambió
+		if (currentData === undefined || currentData.toString() != initialLock.toString()) {
+			cleanupAndQuit();
+		}
+	}, 10000); // Check every 10 seconds
+}
+
+function cleanupAndQuit() {
+	// Prevent multiple cleanup calls
+	if (isCleaningUp) {
+		return;
+	}
+	isCleaningUp = true;
+	
+	
+	// Clear intervals and timeouts
+	if (lockCheckerInterval) {
+		clearInterval(lockCheckerInterval);
+		lockCheckerInterval = null;
+	}
+	if (lockCheckerTimeout) {
+		clearTimeout(lockCheckerTimeout);
+		lockCheckerTimeout = null;
+	}
+	
+	// Destroy main window
+	if (mainWindow && !mainWindow.isDestroyed()) {
+		mainWindow.destroy();
+		mainWindow = null;
+	}
+	
+	// Stop local server
+	if (localServer) {
+		localServer.stop();
+		localServer = null;
+	}
+	
+	// Destroy tray
+	if (tray) {
+		tray.destroy();
+		tray = null;
+	}
+	
+	// Force exit after a timeout to ensure process terminates
+	setTimeout(() => {
+		app.exit(0);
+		// Double safety: exit process after another timeout
+		setTimeout(() => {
+			process.exit(0);
+		}, 1000);
+	}, 500);
+}
+
+// Handle process signals for clean shutdown
+process.on('SIGINT', () => {
+	cleanupAndQuit();
+});
+
+process.on('SIGTERM', () => {
+	cleanupAndQuit();
+});
+
+// Handle uncaught exceptions to prevent zombie processes
+process.on('uncaughtException', (error) => {
+	console.error('Uncaught exception:', error);
+	cleanupAndQuit();
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+	console.error('Unhandled promise rejection:', reason);
+	cleanupAndQuit();
+});
+
+// Start lock checker after everything is initialized
+
+
+
+/**
+ * Carga el HTML del renderer desde la fuente con versión SUPERIOR.
+ *
+ * Dos fuentes, y la division importa:
+ *   - userData: lo que bajo el auto-update de S3. Es el canal EN CALIENTE: una version
+ *     nueva del renderer llega ahi sin republicar el cliente ni tocar el binario.
+ *   - baseline: el renderer que viaja con la instalacion. Es lo que ve una instalacion
+ *     nueva antes de su primer update en caliente.
+ *
+ * Gana la version mas alta, sin importar de donde venga; empate, gana userData.
+ */
+// De donde sale el baseline. En una instalacion es la dependencia @glassnote/renderer,
+// que npm resuelve sola. Pero si hay un clon del renderer al lado —el flujo de quien lo
+// desarrolla, con `npm run watch-renderer`— ese gana: si no, editarlo no se veria nunca,
+// tapado por la version publicada.
+function baselineRendererDir() {
+  const clonLocal = path.join(__dirname, 'glassnote-renderer', 'dist');
+  if (fs.existsSync(clonLocal)) return clonLocal;
+  try {
+    return path.join(path.dirname(require.resolve('@glassnote/renderer/package.json')), 'dist');
+  } catch (error) {
+    // Sin dependencia ni clon solo queda userData; si tampoco esta, mas abajo se avisa.
+    return clonLocal;
+  }
+}
+
+function loadRendererHtml(window, uuid) {
+  // Definir las dos fuentes a considerar con archivos HTML alternativos
+  const sources = [
+    {
+      name: 'userData',
+      dir: path.join(userData.getUserDataDir(), 'renderer'),
+      htmlFiles: ['glassnote.html'], // userData siempre usa glassnote.html
+      type: 'auto-update'
+    },
+    {
+      name: 'baseline',
+      dir: baselineRendererDir(),
+      htmlFiles: ['glassnote.html', 'index.html'], // Intenta glassnote.html primero, luego index.html
+      type: 'paquete'
+    }
+  ];
+
+
+  // Obtener versiones y verificar archivos HTML para ambas fuentes
+  const sourcesWithInfo = sources.map(source => {
+    const version = getRendererVersionFromPath(source.dir);
+    
+    // Buscar el primer archivo HTML que exista
+    let htmlPath = null;
+    let htmlFile = null;
+    for (const file of source.htmlFiles) {
+      const potentialPath = path.join(source.dir, file);
+      if (fs.existsSync(potentialPath)) {
+        htmlPath = potentialPath;
+        htmlFile = file;
+        break;
+      }
+    }
+    
+    const htmlExists = htmlPath !== null;
+    
+    return {
+      ...source,
+      version,
+      htmlPath,
+      htmlFile,
+      htmlExists
+    };
+  });
+
+  // Log de información encontrada
+  sourcesWithInfo.forEach(source => {
+    if (source.htmlExists) {
+    } else {
+      console.log(`  ${source.name}: versión ${source.version}, SIN ARCHIVO HTML`);
+    }
+  });
+
+  // Comparar versiones para determinar cuál es superior
+  const versionComparison = compareVersions(
+    sourcesWithInfo[0].version,
+    sourcesWithInfo[1].version
+  );
+
+  // Determinar fuente con versión superior
+  let superiorSource;
+  if (versionComparison > 0) {
+    // userData tiene versión superior
+    superiorSource = sourcesWithInfo[0];
+  } else if (versionComparison < 0) {
+    // glassnote-renderer/dist tiene versión superior
+    superiorSource = sourcesWithInfo[1];
+  } else {
+    // Versiones iguales, priorizar userData (auto-update)
+    superiorSource = sourcesWithInfo[0];
+  }
+
+  // Intentar cargar desde la fuente con versión superior
+  if (superiorSource.htmlExists) {
+    window.loadFile(superiorSource.htmlPath, {
+      query: { uuid: uuid, version: packageJson.version }
+    });
+    return;
+  }
+
+  // Si la fuente con versión superior no tiene HTML, intentar la otra fuente
+  const otherSource = superiorSource.name === 'userData' ? sourcesWithInfo[1] : sourcesWithInfo[0];
+  
+  if (otherSource.htmlExists) {
+	
+    window.loadFile(otherSource.htmlPath, {
+      query: { uuid: uuid, version: packageJson.version }
+    });
+    return;
+  }
+
+  // Si ninguna fuente tiene HTML, error
+  console.error('ERROR: No se encontró archivo HTML del renderer en ninguna fuente');
+  console.error('userData buscó:', sourcesWithInfo[0].htmlFiles.join(', '));
+  console.error(`baseline (${sourcesWithInfo[1].dir}) buscó:`, sourcesWithInfo[1].htmlFiles.join(', '));
+  
+  // Error fatal - no hay renderer disponible
+  console.error('ERROR FATAL: No se puede cargar el renderer');
+  // Intentar cargar una página de error o cerrar la aplicación
+  window.loadURL('data:text/html,<h1>Error: No se pudo cargar el renderer</h1>');
+}
+
+/**
+ * Compara dos versiones semánticas (formato: major.minor.patch)
+ * Retorna 1 si version1 > version2
+ * Retorna 0 si version1 == version2
+ * Retorna -1 si version1 < version2
+ */
+function compareVersions(version1, version2) {
+	const v1Parts = version1.split('.').map((part) => parseInt(part) || 0);
+	const v2Parts = version2.split('.').map((part) => parseInt(part) || 0);
+
+	// Comparar partes principales (major, minor, patch)
+	for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+		const v1Part = v1Parts[i] || 0;
+		const v2Part = v2Parts[i] || 0;
+
+		if (v1Part > v2Part) return 1;
+		if (v1Part < v2Part) return -1;
+	}
+
+	return 0; // Las versiones son iguales
+}
+
+/**
+ * Obtiene la versión del renderer desde el package.json en el directorio especificado
+ * Si el directorio es un dist/ sin package.json, se mira el del paquete que lo contiene.
+ */
+function getRendererVersionFromPath(rendererPath) {
+	try {
+		// Primero intentar en el directorio especificado
+		const packageJsonPath = path.join(rendererPath, 'package.json');
+		if (fs.existsSync(packageJsonPath)) {
+			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+			return packageJson.version || '0.0.0';
+		}
+		
+		// Un dist/ sin package.json propio: la version la tiene el paquete de arriba.
+		if (path.basename(rendererPath) === 'dist') {
+			const parentDir = path.join(rendererPath, '..'); // Subir un nivel
+			const parentPackageJsonPath = path.join(parentDir, 'package.json');
+			if (fs.existsSync(parentPackageJsonPath)) {
+				const packageJson = JSON.parse(fs.readFileSync(parentPackageJsonPath, 'utf8'));
+				return packageJson.version || '0.0.0';
+			}
+		}
+	} catch (error) {
+		console.error(
+			'Error reading renderer version from',
+			rendererPath,
+			':',
+			error
+		);
+	}
+	return '0.0.0'; // Versión por defecto si no existe o hay error
+}
+
+/**
+ * Recarga el main window después de una actualización del renderer
+ */
+function reloadMainWindow() {
+	if (mainWindow && !mainWindow.isDestroyed()) {
+
+		// Update LocalServer with the new mainWindow reference
+		if (localServer) {
+			localServer.updateMainWindow(mainWindow);
+		}
+
+		loadRendererHtml(mainWindow, uuid);
+	}
+}
+