@glassnote/client 2.4.7 → 2.4.9

package/INSTALACION.md

@@ -108,6 +108,31 @@ sesión de PowerShell, y la app —que la abre el autoarranque— no lo tendría
 auto-actualización no puede funcionar en esa máquina: hay que reinstalar el cliente
 (`irm https://glassnote.intermark.ec/install.ps1 | iex`) o instalar Node.
 
+## Identidad del dispositivo
+
+El uuid con el que el backend reconoce al equipo vive en su propio archivo, `device-id`,
+al lado de los datos de usuario (`%APPDATA%\glassnote` en Windows, `~/.config/glassnote`
+en Linux, `~/Library/Application Support/glassnote` en macOS). Se escribe una vez y no se
+vuelve a tocar.
+
+Antes vivía dentro de `.glassnote`, que se reescribe cada vez que cambia cualquier ajuste.
+Bastaba que ese archivo quedara ilegible —un BOM que le metiera cualquier herramienta de
+Windows, un corte de luz a mitad de la escritura— para que la app generara un uuid nuevo:
+el equipo aparecía como uno distinto en el backend y el anterior quedaba huérfano, sin
+rastro de que eran el mismo.
+
+Lo que hace ahora al arrancar, en orden:
+
+1. `device-id`, si está;
+2. si no, lo migra del `.glassnote`, de su `.backup` o del archivo de la versión Godot —
+   por eso los equipos que ya están instalados conservan su identidad;
+3. solo si no queda nada de dónde sacarlo, genera uno nuevo, y lo dice en el log
+   (`Sin identidad previa recuperable`).
+
+Un `.glassnote` ilegible ya no se sobrescribe: se aparta como `.glassnote.corrupto-<fecha>`
+y se intenta recuperar la configuración del `.backup`. Las escrituras van a un temporal y
+se renombran, así un cierre a destiempo no deja el archivo a medias.
+
 Por `npx` no se actualiza nada: la caché es efímera y npx ya baja la última versión cada
 vez. Tampoco se registra el arranque automático — apuntaría a una carpeta que se limpia
 sola.

package/autoStart.js

@@ -220,35 +220,6 @@ class AutoStart {
         }
       }
 
-      // Remove existing plist if it exists
-      if (fs.existsSync(plistPath)) {
-        try {
-          // Use spawn instead of execSync to avoid blocking
-          const unloadProcess = spawn('launchctl', ['unload', plistPath], {
-            stdio: 'ignore',
-            timeout: 5000 // 5 second timeout
-          });
-          
-          unloadProcess.on('error', (error) => {
-          });
-          
-          unloadProcess.on('exit', (code) => {
-            if (code !== 0) {
-              console.warn('launchctl unload exited with code:', code, '(may not be loaded)');
-            }
-          });
-        } catch (error) {
-          console.error('Could not unload existing plist:', error.message);
-        }
-        
-        // Remove the plist file regardless of launchctl status
-        try {
-          fs.unlinkSync(plistPath);
-        } catch (error) {
-          console.error('Could not remove plist file:', error.message);
-        }
-      }
-
       const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -273,29 +244,30 @@ ${launchArgs.map((a) => `    <string>${a}</string>`).join('\n')}
         fs.mkdirSync(plistDir, { recursive: true });
       }
 
-      fs.writeFileSync(plistPath, plistContent);
-
-      // Load the launch agent asynchronously
+      // El plist NO se borra ni se recarga si ya dice lo mismo, y NUNCA se hace
+      // `launchctl unload`.
+      //
+      // Esto lo llama el main en CADA arranque. En macOS, cuando el que arranca es el
+      // propio LaunchAgent (o sea: al iniciar sesión, que es el caso normal), la app era
+      // el job de launchd: el `launchctl unload` de aquí abajo mataba el job, y con él a
+      // la app que lo estaba ejecutando. Medido: el cliente se abría al login y se moría
+      // a los ~3 segundos, antes incluso del primer chequeo de actualización, que es a
+      // los 5. Encima el agente quedaba descargado, así que ni `launchctl list` lo veía.
+      //
+      // Tampoco se hace `load` cuando el contenido cambia: `RunAtLoad` arrancaría OTRA
+      // instancia encima de esta —la app no tiene lock de instancia única— y el archivo
+      // nuevo lo lee launchd solo en el próximo login, que es justo cuando tiene que
+      // valer. Escribirlo es todo lo que hace falta.
+      let actual = null;
       try {
-        const loadProcess = spawn('launchctl', ['load', plistPath], {
-          stdio: 'ignore',
-          timeout: 5000 // 5 second timeout
-        });
-        
-        loadProcess.on('error', (error) => {
-          console.error('Error spawning launchctl load:', error.message);
-        });
-        
-        loadProcess.on('exit', (code) => {
-          if (code !== 0) {
-            console.warn('launchctl load exited with code:', code);
-          } else {
-            console.warn('macOS auto-start configured:', plistPath);
-          }
-        });
+        actual = fs.readFileSync(plistPath, 'utf8');
       } catch (error) {
-        console.error('Error loading launch agent:', error.message);
+        actual = null; // no existía
       }
+      if (actual === plistContent) return true;
+
+      fs.writeFileSync(plistPath, plistContent);
+      console.log('macOS auto-start configured:', plistPath);
 
       return true;
     } catch (error) {

package/bin/glassnote.js

@@ -52,14 +52,26 @@ function npmEnv() {
 // con otro entorno, y ahí `npm` no existe. La auto-actualización moría en "npm no se
 // reconoce como un comando" y nadie lo veía. Si no hay forma de resolver el npm-cli.js se
 // vuelve al shim de siempre.
-function runNpm(args, opts) {
+// Separado de runNpm a propósito: decidir CÓMO se llama a npm es una función pura, y por
+// eso se puede comprobar en cualquier sistema (scripts/test-update.js lo hace). Ejecutarlo
+// no. La regresión que hay que impedir es volver a `shell: true` con un array de
+// argumentos: Node no entrecomilla en ese caso y en Windows la ruta del prefix se parte en
+// el primer espacio —`C:\Users\Santiago Andrade\...`—, con lo que npm intenta un
+// mkdir de 'C:\Users\Santiago' y la instalación entera falla con EPERM.
+function npmInvocation(args) {
 	const nodeBinary = mode.resolveNodeBinary(process.execPath);
 	const npmCli = mode.resolveNpmCli(nodeBinary);
-	const base = { stdio: 'inherit', shell: false, env: npmEnv() };
 	if (nodeBinary && npmCli) {
-		return spawnSync(nodeBinary, [npmCli].concat(args), Object.assign(base, opts || {}));
+		return { file: nodeBinary, args: [npmCli].concat(args), shell: false, viaNode: true };
 	}
-	return spawnSync(NPM_CMD, args, Object.assign(base, { shell: IS_WIN }, opts || {}));
+	// Sin npm-cli.js localizable no queda más que el shim del PATH. Sigue sin shell:
+	// spawnSync con un array ya entrecomilla por su cuenta cuando no hay shell de por medio.
+	return { file: NPM_CMD, args, shell: false, viaNode: false };
+}
+
+function runNpm(args, opts) {
+	const { file, args: argv, shell } = npmInvocation(args);
+	return spawnSync(file, argv, Object.assign({ stdio: 'inherit', shell, env: npmEnv() }, opts || {}));
 }
 
 // userData tira de `uuid`, y este CLI corre también donde el árbol de dependencias no
@@ -772,4 +784,10 @@ function main() {
 	}
 }
 
-process.exit(main());
+// Requerido desde un test, el archivo NO debe correr nada: solo expone las piezas que
+// se comprueban. Como CLI se comporta igual que siempre.
+if (require.main === module) {
+	process.exit(main());
+} else {
+	module.exports = { npmInvocation, npmEnv, toSpec };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.7",
+  "version": "2.4.9",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -51,7 +51,9 @@
     "sync-installers": "node scripts/sync-installers.js",
     "local-registry": "node scripts/local-registry.js",
     "prepublishOnly": "node scripts/check-publish.js",
-    "start-electron": "electron ."
+    "start-electron": "electron .",
+    "test-update": "node scripts/test-update.js",
+    "test": "node scripts/test-update.js"
   },
   "keywords": [
     "glassnote",

package/userData.js

@@ -1,492 +1,437 @@
-const fs = require('fs');
-const path = require('path');
-const { v4: uuidv4 } = require('uuid');
-
-// Logging de diagnóstico para problema del UUID
-
-const userDataDir = path.join(
-	process.env.APPDATA ||
-		(process.platform === 'darwin'
-			? path.join(process.env.HOME, 'Library', 'Application Support')
-			: path.join(process.env.HOME, '.config')),
-	'glassnote'
-);
-
-const userDataPath = path.join(userDataDir, '.glassnote');
-
-// Path to Godot version's data file
-// Get the base app data directory (parent of userDataDir)
-const baseAppDataDir = path.dirname(userDataDir);
-const godotDataPath = path.join(
-	userDataDir,
-	'Godot',
-	'app_userdata',
-	'glassnote',
-	'.glassnote'
-);
-
-
-// In-memory cache for user data
-let userDataCache = null;
-
-function ensureFileExists() {
-	
-	if (!fs.existsSync(userDataDir)) {
-		fs.mkdirSync(userDataDir, { recursive: true });
-	}
-
-	if (!fs.existsSync(userDataPath)) {
-		let uuid = uuidv4(); // Default to new UUID
-		let servers = []; // Default empty servers array
-
-		// Check if Godot version's data file exists and try to migrate data
-		if (fs.existsSync(godotDataPath)) {
-			try {
-				const godotData = fs.readFileSync(godotDataPath, 'utf8');
-				const parsedData = JSON.parse(godotData);
-
-				// Migrate UUID if available
-				if (parsedData.uuid) {
-					uuid = parsedData.uuid;
-				}
-
-				// Migrate server value to servers array if available
-				if (parsedData.server) {
-					servers = [parsedData.server];
-				}
-			} catch (err) {
-				console.error('Error reading Godot data file:', err);
-				console.error('Generating new UUID due to error reading Godot data');
-			}
-		} else {
-			console.log('No Godot data file found, generating new UUID:', uuid);
-		}
-
-		const initialData = { uuid: uuid, servers: servers };
-		fs.writeFileSync(userDataPath, JSON.stringify(initialData, null, 2));
-		userDataCache = initialData;
-		return initialData;
-	}
-	
-	// Load data into cache if not already loaded
-	if (userDataCache === null) {
-		userDataCache = readData();
-	} else {
-		console.log('Cache already loaded, skipping readData()');
-	}
-	
-	// Validate that UUID exists and is a valid format
-	
-	if (!userDataCache.uuid || typeof userDataCache.uuid !== 'string' || userDataCache.uuid.trim() === '' || !isValidUUID(userDataCache.uuid)) {
-		
-		const newUUID = uuidv4();
-		userDataCache.uuid = newUUID;
-		writeData(userDataCache);
-	} else {
-		console.log('UUID validation PASSED');
-	}
-	
-	return userDataCache;
-}
-
-function readData() {
-    
-    try {
-        const data = fs.readFileSync(userDataPath, 'utf8');
-        
-        const parsedData = JSON.parse(data);
-        
-        // Ensure we always return an object with proper structure
-        if (typeof parsedData !== 'object' || parsedData === null) {
-            console.error('Invalid data format, returning default structure');
-            userDataCache = { uuid: null, servers: [] };
-            return userDataCache;
-        }
-        
-        // Ensure servers array exists
-        if (!Array.isArray(parsedData.servers)) {
-            if (typeof parsedData.servers === 'string') {
-                parsedData.servers = [parsedData.servers];
-            } else {
-                parsedData.servers = [];
-            }
-        } else {
-            console.log('servers is already array, length:', parsedData.servers.length);
-        }
-        
-        userDataCache = parsedData;
-        return userDataCache;
-    } catch (err) {
-        console.error('Error reading user data:', err.message);
-        console.error('Error stack:', err.stack);
-        // Return a properly structured object instead of empty
-        userDataCache = { uuid: null, servers: [] };
-        console.error('Returning error structure:', userDataCache);
-        console.error('=== readData() returning (error) ===');
-        return userDataCache;
-    }
-}
-
-function writeData(data) {
-	
-	// Validate data structure before writing
-	if (!data || typeof data !== 'object') {
-		console.error('writeData() called with invalid data:', data);
-		return false;
-	}
-	
-	// ALWAYS preserve a valid UUID - never overwrite with invalid/null UUID
-	let originalUUID = data.uuid;
-	let needsUUIDPreservation = false;
-	
-	// Check if UUID in data is valid
-	if (!data.uuid || typeof data.uuid !== 'string' || !isValidUUID(data.uuid)) {
-		console.warn('writeData(): UUID in data is invalid:', data.uuid);
-		needsUUIDPreservation = true;
-	}
-	
-	// If UUID needs preservation, read current file
-	if (needsUUIDPreservation) {
-		try {
-			if (fs.existsSync(userDataPath)) {
-				const currentContent = fs.readFileSync(userDataPath, 'utf8');
-				const currentData = JSON.parse(currentContent);
-				if (currentData.uuid && isValidUUID(currentData.uuid)) {
-					data.uuid = currentData.uuid;
-				} else {
-					console.warn('writeData(): No valid UUID in current file either');
-					// If no valid UUID exists anywhere, generate a new one
-					if (!data.uuid || !isValidUUID(data.uuid)) {
-						const newUUID = uuidv4();
-						data.uuid = newUUID;
-					}
-				}
-			} else {
-				// File doesn't exist, ensure we have a valid UUID
-				if (!data.uuid || !isValidUUID(data.uuid)) {
-					const newUUID = uuidv4();
-					data.uuid = newUUID;
-				}
-			}
-		} catch (err) {
-			console.error('writeData(): Error reading current file:', err.message);
-			// On error, ensure we have a valid UUID
-			if (!data.uuid || !isValidUUID(data.uuid)) {
-				const newUUID = uuidv4();
-				console.error('writeData(): Generating new UUID after error:', newUUID);
-				data.uuid = newUUID;
-			}
-		}
-	} else {
-		console.log('writeData(): UUID in data is valid:', data.uuid);
-	}
-	
-	// Create backup before writing
-	try {
-		if (fs.existsSync(userDataPath)) {
-			const backupPath = userDataPath + '.backup';
-			fs.copyFileSync(userDataPath, backupPath);
-		}
-	} catch (err) {
-		console.warn('writeData(): Could not create backup:', err.message);
-	}
-	
-	try {
-		fs.writeFileSync(userDataPath, JSON.stringify(data, null, 2));
-		return true;
-	} catch (err) {
-		console.error('Error writing user data:', err.message);
-		console.error('Error stack:', err.stack);
-		return false;
-	}
-}
-
-function get(key, nestedKey) {
-    // Handle both get(key) and get(key, nestedKey)
-    if (arguments.length === 1) {
-        nestedKey = undefined;
-    }
-    
-    // Ensure cache is loaded
-    if (userDataCache === null) {
-        ensureFileExists();
-    }
-    
-    if (nestedKey !== undefined) {
-        // If nestedKey is provided, get nested value
-        if (userDataCache[key] && typeof userDataCache[key] === 'object' && userDataCache[key] !== null) {
-            return userDataCache[key][nestedKey];
-        }
-        return undefined;
-    } else {
-        // If only key is provided, get top-level value
-        return userDataCache[key];
-    }
-}
-
-function set(key, nestedKey, value) {
-    
-    // Handle both set(key, value) and set(key, nestedKey, value)
-    if (arguments.length === 2) {
-        // set(key, value) - value is actually the second argument
-        value = nestedKey;
-        nestedKey = undefined;
-    }
-    
-    // BLOCK ATTEMPTS TO OVERWRITE UUID FROM RENDERER
-    if (key === 'uuid' && nestedKey === undefined) {
-        console.error('SECURITY: Attempt to overwrite UUID blocked!');
-        console.error('UUID can only be set by Electron main process, not from renderer.');
-        
-        // Get current UUID to return success but don't actually change it
-        if (userDataCache === null) {
-            ensureFileExists();
-        }
-        
-        // CRITICAL FIX: DO NOT update cache with invalid UUID from renderer
-        // Keep the existing UUID in cache to prevent ensureFileExists() from regenerating it
-        
-        // Return true to avoid breaking renderer expectations, but UUID is not actually changed
-        return true;
-    }
-    
-    // Ensure cache is loaded
-    if (userDataCache === null) {
-        ensureFileExists();
-    }
-    
-    // Validate cache structure
-    if (!userDataCache || typeof userDataCache !== 'object') {
-        console.error('set(): userDataCache is invalid, reinitializing');
-        userDataCache = { uuid: null, servers: [] };
-    }
-    
-    // Preserve UUID if it exists but cache structure is incomplete
-    if (!userDataCache.uuid || typeof userDataCache.uuid !== 'string') {
-        try {
-            if (fs.existsSync(userDataPath)) {
-                const currentContent = fs.readFileSync(userDataPath, 'utf8');
-                const currentData = JSON.parse(currentContent);
-                if (currentData.uuid && typeof currentData.uuid === 'string') {
-                    userDataCache.uuid = currentData.uuid;
-                }
-            }
-        } catch (err) {
-            console.error('set(): Error reading file for UUID:', err.message);
-        }
-    }
-    
-    // Handle case where nestedKey is an object but should be treated as value
-    // This happens when: set(key, object, undefined) or set(key, object, null)
-    if (nestedKey !== undefined && typeof nestedKey === 'object' &&
-        (value === undefined || value === null)) {
-        // Swap: value = nestedKey, nestedKey = undefined
-        value = nestedKey;
-        nestedKey = undefined;
-    }
-    
-    // Also handle case where nestedKey is not a string (invalid for nested key)
-    if (nestedKey !== undefined && typeof nestedKey !== 'string') {
-        // If nestedKey is not a string, it can't be used as an object key
-        // Treat it as value instead
-        value = nestedKey;
-        nestedKey = undefined;
-    }
-    
-    if (nestedKey !== undefined) {
-        // If nestedKey is provided, set nested value
-        // Check if current value is an object, if not, replace it with an object
-        if (!userDataCache[key] || typeof userDataCache[key] !== 'object' || Array.isArray(userDataCache[key])) {
-            userDataCache[key] = {};
-        }
-        userDataCache[key][nestedKey] = value;
-    } else {
-        // If only key is provided, set top-level value
-        userDataCache[key] = value;
-    }
-    
-    return writeData(userDataCache);
-}
-
-function remove(key, nestedKey) {
-    // Handle both remove(key) and remove(key, nestedKey)
-    if (arguments.length === 1) {
-        nestedKey = undefined;
-    }
-    
-    // Ensure cache is loaded
-    if (userDataCache === null) {
-        ensureFileExists();
-    }
-    
-    if (nestedKey !== undefined) {
-        // If nestedKey is provided, remove nested value
-        if (userDataCache[key] && typeof userDataCache[key] === 'object' && userDataCache[key] !== null) {
-            delete userDataCache[key][nestedKey];
-            // If the object becomes empty, remove the entire key
-            if (Object.keys(userDataCache[key]).length === 0) {
-                delete userDataCache[key];
-            }
-        }
-    } else {
-        // If only key is provided, remove top-level value
-        delete userDataCache[key];
-    }
-    
-    return writeData(userDataCache);
-}
-
-function getUUID() {
-	
-	// If UUID is already in cache and valid, return it immediately
-	if (userDataCache && userDataCache.uuid && typeof userDataCache.uuid === 'string' && isValidUUID(userDataCache.uuid)) {
-		return userDataCache.uuid;
-	}
-	
-	// Otherwise, ensure file exists and get UUID
-	const data = ensureFileExists();
-	
-	// Double-check that UUID is valid
-	if (!data.uuid || typeof data.uuid !== 'string' || !isValidUUID(data.uuid)) {
-		console.error('getUUID(): Invalid UUID returned from ensureFileExists():', data.uuid);
-		// Try to read directly from file as last resort
-		try {
-			if (fs.existsSync(userDataPath)) {
-				const fileContent = fs.readFileSync(userDataPath, 'utf8');
-				const fileData = JSON.parse(fileContent);
-				if (fileData.uuid && isValidUUID(fileData.uuid)) {
-					// Update cache
-					userDataCache.uuid = fileData.uuid;
-					writeData(userDataCache);
-					return fileData.uuid;
-				}
-			}
-		} catch (err) {
-			console.error('getUUID(): Error reading UUID from file:', err.message);
-		}
-		
-		// Generate new UUID as last resort
-		const newUUID = uuidv4();
-		userDataCache.uuid = newUUID;
-		writeData(userDataCache);
-		return newUUID;
-	}
-	
-	return data.uuid;
-}
-
-// Función específica para leer el lock desde el archivo (no del cache)
-function getLockFromFile() {
-    try {
-        // Leer directamente del archivo, no del cache
-        if (!fs.existsSync(userDataPath)) {
-            return undefined;
-        }
-        
-        const data = fs.readFileSync(userDataPath, 'utf8');
-        const parsedData = JSON.parse(data);
-        
-        // Retornar el valor del lock si existe
-        return parsedData.lock;
-    } catch (err) {
-        console.error('Error reading lock from file:', err);
-        return undefined;
-    }
-}
-
-function getUserDataPath() {
-	return userDataDir;
-}
-
-function getUserDataDir() {
-	return userDataDir;
-}
-
-// Función auxiliar para validar formato UUID
-function isValidUUID(uuid) {
-	if (!uuid || typeof uuid !== 'string') return false;
-	const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-	return uuidRegex.test(uuid);
-}
-
-// Función para validar y reparar datos de usuario
-function validateAndRepairUserData() {
-	
-	try {
-		if (!fs.existsSync(userDataPath)) {
-			return ensureFileExists();
-		}
-		
-		// Read current file
-		const fileContent = fs.readFileSync(userDataPath, 'utf8');
-		const fileData = JSON.parse(fileContent);
-		
-		let needsRepair = false;
-		
-		// Validate UUID
-		if (!fileData.uuid || typeof fileData.uuid !== 'string' || !isValidUUID(fileData.uuid)) {
-			console.warn('Invalid UUID in file, repairing...');
-			needsRepair = true;
-			
-			// Try to preserve existing UUID if format is close
-			if (fileData.uuid && typeof fileData.uuid === 'string' && fileData.uuid.trim() !== '') {
-				// Check if it's a UUID without dashes or with wrong format
-				const cleanUUID = fileData.uuid.trim().toLowerCase();
-				if (cleanUUID.length === 32 && /^[0-9a-f]{32}$/.test(cleanUUID)) {
-					// Convert 32-char hex to UUID format
-					fileData.uuid = cleanUUID.replace(/([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})/, '$1-$2-$3-$4-$5');
-				} else {
-					// Generate new UUID
-					fileData.uuid = uuidv4();
-				}
-			} else {
-				// Generate new UUID
-				fileData.uuid = uuidv4();
-			}
-		}
-		
-		// Ensure servers array exists
-		if (!Array.isArray(fileData.servers)) {
-			console.warn('Invalid servers format, repairing...');
-			needsRepair = true;
-			if (typeof fileData.servers === 'string') {
-				fileData.servers = [fileData.servers];
-			} else {
-				fileData.servers = [];
-			}
-		}
-		
-		// Update cache
-		userDataCache = fileData;
-		
-		if (needsRepair) {
-			writeData(fileData);
-		} else {
-			console.log('Data validation passed, no repairs needed');
-		}
-		
-		return fileData;
-	} catch (err) {
-		console.error('Error validating user data:', err.message);
-		console.error('Falling back to ensureFileExists()');
-		return ensureFileExists();
-	}
-}
-
-// NOT calling ensureFileExists() here anymore - will be called on demand
-// This prevents double initialization and potential UUID regeneration
-
-module.exports = {
-	ensureFileExists,
-	readData,
-	writeData,
-	get,
-	set,
-	remove,
-	getUUID,
-	getLockFromFile,
-	getUserDataPath,
-	getUserDataDir,
-	isValidUUID,
-	validateAndRepairUserData,
-};
+const fs = require('fs');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+// Logging de diagnóstico para problema del UUID
+
+const userDataDir = path.join(
+	process.env.APPDATA ||
+		(process.platform === 'darwin'
+			? path.join(process.env.HOME, 'Library', 'Application Support')
+			: path.join(process.env.HOME, '.config')),
+	'glassnote'
+);
+
+const userDataPath = path.join(userDataDir, '.glassnote');
+
+// Path to Godot version's data file
+// Get the base app data directory (parent of userDataDir)
+const baseAppDataDir = path.dirname(userDataDir);
+const godotDataPath = path.join(
+	userDataDir,
+	'Godot',
+	'app_userdata',
+	'glassnote',
+	'.glassnote'
+);
+
+
+// In-memory cache for user data
+let userDataCache = null;
+
+// ── Identidad del dispositivo ───────────────────────────────────────────────────────
+//
+// El uuid vive en SU PROPIO archivo (`device-id`), que se escribe una vez y no se vuelve
+// a tocar. Antes vivía dentro de `.glassnote`, que se reescribe cada vez que cambia
+// cualquier ajuste: bastaba que ese archivo quedara ilegible —un BOM que le metiera
+// cualquier herramienta de Windows, un corte de luz a mitad de la escritura— para que la
+// app generara un uuid nuevo y el backend viera un equipo distinto, sin forma de saber
+// que era el mismo. Separarlo convierte «se corrompió la configuración», que es
+// recuperable, en algo que ya no arrastra la identidad.
+const deviceIdPath = path.join(userDataDir, 'device-id');
+const backupPath = userDataPath + '.backup';
+
+let deviceIdCache = null;
+
+// El BOM son tres bytes (EF BB BF) que Windows antepone al UTF-8 y que JSON.parse no
+// tolera: el archivo se ve perfecto al abrirlo y revienta igual. Se quita antes de parsear.
+function stripBom(text) {
+	return typeof text === 'string' && text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+
+// Escribir directo sobre el archivo real lo deja truncado si el proceso muere a mitad, y
+// un archivo truncado es justo cómo se llegaba a perder la identidad. Al temporal y
+// rename, que es atómico.
+function writeAtomic(file, content) {
+	const tmp = `${file}.tmp-${process.pid}`;
+	fs.writeFileSync(tmp, content);
+	fs.renameSync(tmp, file);
+}
+
+// null  = el archivo NO existe. Caso legítimo: primer arranque.
+// lanza = existe pero no se pudo leer o parsear.
+// Confundir los dos casos era el bug: un archivo ilegible se trataba como «no hay datos»
+// y de ahí salía un uuid nuevo.
+function loadFile(file) {
+	if (!fs.existsSync(file)) return null;
+	const parsed = JSON.parse(stripBom(fs.readFileSync(file, 'utf8')));
+	if (typeof parsed !== 'object' || parsed === null) {
+		throw new Error('el contenido no es un objeto');
+	}
+	return parsed;
+}
+
+// El ilegible se aparta con fecha en vez de sobrescribirse: sin esto no queda rastro de
+// qué pasó ni forma de recuperarlo a mano.
+function apartarIlegible(file) {
+	try {
+		if (!fs.existsSync(file)) return null;
+		const destino = `${file}.corrupto-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+		fs.renameSync(file, destino);
+		console.error(`Archivo ilegible apartado en ${destino}`);
+		return destino;
+	} catch (error) {
+		console.error('No se pudo apartar el archivo ilegible:', error.message);
+		return null;
+	}
+}
+
+function readDeviceId() {
+	try {
+		const raw = stripBom(fs.readFileSync(deviceIdPath, 'utf8')).trim();
+		return isValidUUID(raw) ? raw : null;
+	} catch (error) {
+		return null;
+	}
+}
+
+function writeDeviceId(uuid) {
+	try {
+		fs.mkdirSync(userDataDir, { recursive: true });
+		writeAtomic(deviceIdPath, `${uuid}\n`);
+		return true;
+	} catch (error) {
+		console.error('No se pudo guardar device-id:', error.message);
+		return false;
+	}
+}
+
+// El uuid del equipo, por orden de confianza. Es el ÚNICO sitio del archivo donde se
+// genera uno nuevo: antes había cuatro repartidos y cualquiera podía disparar.
+function deviceUUID() {
+	if (deviceIdCache) return deviceIdCache;
+
+	const guardado = readDeviceId();
+	if (guardado) {
+		deviceIdCache = guardado;
+		return guardado;
+	}
+
+	// Migración de lo que ya está instalado: hasta ahora el uuid vivía en la config, y
+	// antes de eso en el archivo de la versión Godot.
+	for (const origen of [userDataPath, backupPath, godotDataPath]) {
+		let datos = null;
+		try {
+			datos = loadFile(origen);
+		} catch (error) {
+			continue; // ilegible: se prueba el siguiente
+		}
+		if (datos && isValidUUID(datos.uuid)) {
+			writeDeviceId(datos.uuid);
+			console.log(`device-id creado a partir de ${origen}`);
+			deviceIdCache = datos.uuid;
+			return datos.uuid;
+		}
+	}
+
+	// Primer arranque de verdad, o no quedó nada de dónde sacarlo. Se avisa fuerte: es
+	// el único camino por el que un equipo cambia de identidad.
+	const nuevo = uuidv4();
+	console.warn(`Sin identidad previa recuperable: se genera un uuid nuevo (${nuevo})`);
+	writeDeviceId(nuevo);
+	deviceIdCache = nuevo;
+	return nuevo;
+}
+
+// Config de primer arranque. El uuid NO se decide acá: lo pone deviceUUID().
+function datosIniciales() {
+	let servers = [];
+	try {
+		const godot = loadFile(godotDataPath);
+		if (godot && godot.server) servers = [godot.server];
+	} catch (error) {
+		console.error('No se pudo migrar la config de la versión Godot:', error.message);
+	}
+	return { uuid: null, servers };
+}
+
+function ensureFileExists() {
+	if (!fs.existsSync(userDataDir)) {
+		fs.mkdirSync(userDataDir, { recursive: true });
+	}
+
+	// La identidad se resuelve aparte de la configuración, y antes que ella.
+	const uuid = deviceUUID();
+
+	if (userDataCache === null) {
+		userDataCache = readData();
+	}
+
+	if (userDataCache.uuid !== uuid) {
+		userDataCache.uuid = uuid;
+		writeData(userDataCache);
+	}
+
+	return userDataCache;
+}
+
+function readData() {
+	let datos = null;
+	try {
+		datos = loadFile(userDataPath);
+	} catch (error) {
+		console.error(`No se pudo leer ${userDataPath}: ${error.message}`);
+		// El backup se venía escribiendo desde siempre y no lo leía NADIE: una red
+		// tendida y sin conectar. Antes de dar la configuración por perdida, se prueba.
+		try {
+			datos = loadFile(backupPath);
+			if (datos) console.warn('Configuración recuperada del backup.');
+		} catch (errorBackup) {
+			console.error(`El backup tampoco sirve: ${errorBackup.message}`);
+			datos = null;
+		}
+		apartarIlegible(userDataPath);
+	}
+
+	if (datos === null) datos = datosIniciales();
+
+	if (!Array.isArray(datos.servers)) {
+		datos.servers = typeof datos.servers === 'string' ? [datos.servers] : [];
+	}
+
+	userDataCache = datos;
+	return userDataCache;
+}
+
+function writeData(data) {
+	if (!data || typeof data !== 'object') {
+		console.error('writeData(): datos inválidos:', data);
+		return false;
+	}
+
+	// El uuid ya no se negocia acá: manda device-id. La maquinaria que había antes para
+	// «preservar el uuid leyendo el archivo actual» no llegaba a correr nunca, porque
+	// quien llamaba ya venía con uno recién inventado en la mano.
+	data.uuid = deviceUUID();
+
+	// El backup se hace SOLO desde un archivo que se puede leer. Copiarlo a ciegas
+	// destruía la única copia buena justo cuando hacía falta.
+	try {
+		if (loadFile(userDataPath)) fs.copyFileSync(userDataPath, backupPath);
+	} catch (error) {
+		console.warn('El archivo actual no es legible: se conserva el backup anterior.');
+	}
+
+	try {
+		writeAtomic(userDataPath, JSON.stringify(data, null, 2));
+		return true;
+	} catch (error) {
+		console.error('Error escribiendo los datos de usuario:', error.message);
+		return false;
+	}
+}
+
+function get(key, nestedKey) {
+    // Handle both get(key) and get(key, nestedKey)
+    if (arguments.length === 1) {
+        nestedKey = undefined;
+    }
+    
+    // Ensure cache is loaded
+    if (userDataCache === null) {
+        ensureFileExists();
+    }
+    
+    if (nestedKey !== undefined) {
+        // If nestedKey is provided, get nested value
+        if (userDataCache[key] && typeof userDataCache[key] === 'object' && userDataCache[key] !== null) {
+            return userDataCache[key][nestedKey];
+        }
+        return undefined;
+    } else {
+        // If only key is provided, get top-level value
+        return userDataCache[key];
+    }
+}
+
+function set(key, nestedKey, value) {
+    
+    // Handle both set(key, value) and set(key, nestedKey, value)
+    if (arguments.length === 2) {
+        // set(key, value) - value is actually the second argument
+        value = nestedKey;
+        nestedKey = undefined;
+    }
+    
+    // BLOCK ATTEMPTS TO OVERWRITE UUID FROM RENDERER
+    if (key === 'uuid' && nestedKey === undefined) {
+        console.error('SECURITY: Attempt to overwrite UUID blocked!');
+        console.error('UUID can only be set by Electron main process, not from renderer.');
+        
+        // Get current UUID to return success but don't actually change it
+        if (userDataCache === null) {
+            ensureFileExists();
+        }
+        
+        // CRITICAL FIX: DO NOT update cache with invalid UUID from renderer
+        // Keep the existing UUID in cache to prevent ensureFileExists() from regenerating it
+        
+        // Return true to avoid breaking renderer expectations, but UUID is not actually changed
+        return true;
+    }
+    
+    // Ensure cache is loaded
+    if (userDataCache === null) {
+        ensureFileExists();
+    }
+    
+    // Validate cache structure
+    if (!userDataCache || typeof userDataCache !== 'object') {
+        console.error('set(): userDataCache is invalid, reinitializing');
+        userDataCache = { uuid: null, servers: [] };
+    }
+    
+    // El uuid no se rescata acá: writeData() lo fija desde device-id en cada escritura.
+    
+    // Handle case where nestedKey is an object but should be treated as value
+    // This happens when: set(key, object, undefined) or set(key, object, null)
+    if (nestedKey !== undefined && typeof nestedKey === 'object' &&
+        (value === undefined || value === null)) {
+        // Swap: value = nestedKey, nestedKey = undefined
+        value = nestedKey;
+        nestedKey = undefined;
+    }
+    
+    // Also handle case where nestedKey is not a string (invalid for nested key)
+    if (nestedKey !== undefined && typeof nestedKey !== 'string') {
+        // If nestedKey is not a string, it can't be used as an object key
+        // Treat it as value instead
+        value = nestedKey;
+        nestedKey = undefined;
+    }
+    
+    if (nestedKey !== undefined) {
+        // If nestedKey is provided, set nested value
+        // Check if current value is an object, if not, replace it with an object
+        if (!userDataCache[key] || typeof userDataCache[key] !== 'object' || Array.isArray(userDataCache[key])) {
+            userDataCache[key] = {};
+        }
+        userDataCache[key][nestedKey] = value;
+    } else {
+        // If only key is provided, set top-level value
+        userDataCache[key] = value;
+    }
+    
+    return writeData(userDataCache);
+}
+
+function remove(key, nestedKey) {
+    // Handle both remove(key) and remove(key, nestedKey)
+    if (arguments.length === 1) {
+        nestedKey = undefined;
+    }
+    
+    // Ensure cache is loaded
+    if (userDataCache === null) {
+        ensureFileExists();
+    }
+    
+    if (nestedKey !== undefined) {
+        // If nestedKey is provided, remove nested value
+        if (userDataCache[key] && typeof userDataCache[key] === 'object' && userDataCache[key] !== null) {
+            delete userDataCache[key][nestedKey];
+            // If the object becomes empty, remove the entire key
+            if (Object.keys(userDataCache[key]).length === 0) {
+                delete userDataCache[key];
+            }
+        }
+    } else {
+        // If only key is provided, remove top-level value
+        delete userDataCache[key];
+    }
+    
+    return writeData(userDataCache);
+}
+
+function getUUID() {
+	// Una sola fuente: device-id. Antes esto tenía su propia cadena de rescates que
+	// terminaba, como todas las demás, generando un uuid nuevo por su cuenta.
+	if (userDataCache === null) ensureFileExists();
+	return deviceUUID();
+}
+
+// Función específica para leer el lock desde el archivo (no del cache)
+function getLockFromFile() {
+    try {
+        // Leer directamente del archivo, no del cache
+        if (!fs.existsSync(userDataPath)) {
+            return undefined;
+        }
+        
+        const parsedData = JSON.parse(stripBom(fs.readFileSync(userDataPath, 'utf8')));
+
+        // Retornar el valor del lock si existe
+        return parsedData.lock;
+    } catch (err) {
+        console.error('Error reading lock from file:', err);
+        return undefined;
+    }
+}
+
+function getUserDataPath() {
+	return userDataDir;
+}
+
+function getUserDataDir() {
+	return userDataDir;
+}
+
+// Función auxiliar para validar formato UUID
+function isValidUUID(uuid) {
+	if (!uuid || typeof uuid !== 'string') return false;
+	const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+	return uuidRegex.test(uuid);
+}
+
+// Función para validar y reparar datos de usuario
+function validateAndRepairUserData() {
+	// Repara la CONFIGURACIÓN. El uuid no se toca acá: lo pone deviceUUID() y writeData
+	// lo vuelve a fijar en cada escritura. Antes esta función también intentaba
+	// "arreglar" el uuid y acababa inventando uno.
+	try {
+		const datos = ensureFileExists();
+		let reparar = false;
+
+		if (!Array.isArray(datos.servers)) {
+			console.warn('El campo servers no era un array; se repara.');
+			datos.servers = typeof datos.servers === 'string' ? [datos.servers] : [];
+			reparar = true;
+		}
+
+		if (reparar) writeData(datos);
+		return datos;
+	} catch (error) {
+		console.error('Error validando los datos de usuario:', error.message);
+		return ensureFileExists();
+	}
+}
+
+// NOT calling ensureFileExists() here anymore - will be called on demand
+// This prevents double initialization and potential UUID regeneration
+
+module.exports = {
+	ensureFileExists,
+	readData,
+	writeData,
+	get,
+	set,
+	remove,
+	getUUID,
+	getLockFromFile,
+	getUserDataPath,
+	getUserDataDir,
+	isValidUUID,
+	validateAndRepairUserData,
+	deviceUUID,
+	getDeviceIdPath: () => deviceIdPath,
+};