@glassnote/client 2.4.0

package/userData.js

@@ -0,0 +1,492 @@
+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,
+};