@glassnote/client 2.4.0

package/autoupdate_renderer.js

@@ -0,0 +1,371 @@
+const { app } = require('electron');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+const { exec } = require('child_process');
+const userData = require('./userData');
+
+// El renderer se baja siempre del bucket de PRODUCCIÓN. Antes esto lo decidía un campo
+// `stage` en package.json que elegía entre este bucket y `glassnotedev`: ese ambiente ya
+// no existe, y el campo solo servía para publicar apuntando a un bucket muerto sin que se
+// notara hasta que alguien viera un renderer viejo. Para probar contra otro origen está
+// GLASSNOTE_S3_BASE_URL, que es explícito y no viaja en el paquete publicado.
+const S3_BASE_URL = process.env.GLASSNOTE_S3_BASE_URL || 'https://glassnote.s3.us-east-1.amazonaws.com';
+
+class AutoUpdateRenderer {
+    constructor(reloadCallback) {
+        this.S3_BASE_URL = S3_BASE_URL;
+        this.currentVersion = this.getCurrentRendererVersion();
+        this.expectedHash = null;
+        this.updateInterval = null;
+        this.reloadCallback = reloadCallback;
+    }
+
+    /**
+     * Obtiene la versión actual del renderer desde package.json
+     */
+    getCurrentRendererVersion() {
+        try {
+            // Primero verificar en userData (actualizaciones)
+            const userDataRendererPath = path.join(userData.getUserDataDir(), 'renderer', 'package.json');
+            if (fs.existsSync(userDataRendererPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(userDataRendererPath, 'utf8'));
+                return packageJson.version;
+            }
+            
+            // Si no existe en userData, verificar en la aplicación (versión por defecto)
+            const appRendererPath = path.join(__dirname, 'renderer', 'package.json');
+            if (fs.existsSync(appRendererPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(appRendererPath, 'utf8'));
+                return packageJson.version;
+            }
+            
+            return '0.0.0'; // Versión por defecto si no existe
+        } catch (error) {
+            console.error('Error reading renderer version:', error);
+            return '0.0.0';
+        }
+    }
+
+    /**
+     * Inicia el sistema de auto-actualización del renderer
+     */
+    start() {
+        // Primera verificación después de 10 segundos
+        setTimeout(() => {
+            this.checkForUpdates();
+        }, 10000);
+
+        // Configurar verificación periódica cada hora (3600000 ms)
+        this.updateInterval = setInterval(() => {
+            this.checkForUpdates();
+        }, 3600000);
+    }
+
+    /**
+     * Detiene el sistema de auto-actualización
+     */
+    stop() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+    }
+
+    /**
+     * Verifica si hay actualizaciones disponibles del renderer
+     */
+    async checkForUpdates() {
+        try {            
+            const versionUrl = `${this.S3_BASE_URL}/version_renderer.txt`;
+
+            const versionContent = await this.downloadTextFile(versionUrl);
+            if (!versionContent) {
+                console.error('Error downloading renderer version file');
+                return;
+            }
+
+            // Parsear contenido del archivo de versión
+            const versionParts = versionContent.trim().split(' ');
+            const newVersion = versionParts[0];
+            this.expectedHash = versionParts.length > 1 ? versionParts[1].trim() : null;
+
+            // Comparar versiones
+            if (this.compareVersions(this.currentVersion, newVersion) < 0) {
+                await this.downloadRenderer(newVersion);
+            }
+
+        } catch (error) {
+            console.error('Error checking for renderer updates:', error);
+        }
+    }
+
+    /**
+     * Descarga un archivo desde una URL (para archivos de texto)
+     */
+    downloadTextFile(url) {
+        return new Promise((resolve, reject) => {
+            https.get(url, (response) => {
+                if (response.statusCode !== 200) {
+                    console.error(`HTTP error ${response.statusCode} downloading text file from ${url}`);
+                    reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+                    return;
+                }
+
+                let data = '';
+                response.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                response.on('end', () => {
+                    resolve(data);
+                });
+
+            }).on('error', (error) => {
+                console.error(`Error downloading text file from ${url}:`, error.message);
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * Descarga un archivo binario desde una URL
+     */
+    downloadBinaryFile(url) {
+        return new Promise((resolve, reject) => {
+            https.get(url, (response) => {
+                if (response.statusCode !== 200) {
+                    console.error(`HTTP error ${response.statusCode} downloading binary file from ${url}`);
+                    reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+                    return;
+                }
+
+                const contentLength = response.headers['content-length'];
+
+                const chunks = [];
+                let totalBytes = 0;
+                let lastLoggedPercent = -1;
+                
+                response.on('data', (chunk) => {
+                    chunks.push(chunk);
+                    totalBytes += chunk.length;
+                    
+                    // Log progress only at 10% intervals to avoid spam
+                    if (contentLength) {
+                        const percent = Math.floor((totalBytes / contentLength) * 100 / 10) * 10;
+                        if (percent > lastLoggedPercent) {
+                            lastLoggedPercent = percent;
+                        }
+                    }
+                });
+
+                response.on('end', () => {
+                    const buffer = Buffer.concat(chunks);
+                    resolve(buffer);
+                });
+
+            }).on('error', (error) => {
+                console.error(`Error downloading binary file from ${url}:`, error.message);
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * Compara dos versiones semánticas
+     */
+    compareVersions(version1, version2) {
+        const v1Parts = version1.split('.').map(part => parseInt(part) || 0);
+        const v2Parts = version2.split('.').map(part => parseInt(part) || 0);
+
+        for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
+            const v1 = i < v1Parts.length ? v1Parts[i] : 0;
+            const v2 = i < v2Parts.length ? v2Parts[i] : 0;
+
+            if (v1 > v2) return 1;
+            if (v1 < v2) return -1;
+        }
+        return 0;
+    }
+
+    /**
+     * Descarga el renderer con reintentos y verificación robusta
+     */
+    async downloadRenderer(version, maxRetries = 3) {
+        let retryCount = 0;
+        
+        while (retryCount <= maxRetries) {
+            try {
+                const rendererUrl = `${this.S3_BASE_URL}/renderer-${version}.zip`;
+                const tempZipPath = path.join(app.getPath('temp'), `renderer-${version}.zip`);
+                const rendererDir = path.join(userData.getUserDataDir(), 'renderer');
+                const backupDir = path.join(app.getPath('temp'), `renderer-backup-${Date.now()}`);
+
+
+                const rendererBuffer = await this.downloadBinaryFile(rendererUrl);
+                
+                // Verificar que el archivo se descargó completamente
+                if (!rendererBuffer || rendererBuffer.length === 0) {
+                    throw new Error('Downloaded renderer is empty or incomplete');
+                }
+                
+                
+                // Guardar el zip temporalmente
+                fs.writeFileSync(tempZipPath, rendererBuffer);
+                
+                // Verificar hash si se proporcionó expectedHash
+                if (this.expectedHash) {
+                    const downloadedHash = this.calculateBufferHash(rendererBuffer);
+                    
+                    // Comparación case-insensitive del hash
+                    if (downloadedHash.toLowerCase() !== this.expectedHash.toLowerCase()) {
+                        // Eliminar el archivo corrupto
+                        fs.unlinkSync(tempZipPath);
+                        throw new Error(`Renderer hash verification failed! Expected: ${this.expectedHash}, Got: ${downloadedHash}`);
+                    }
+                }
+
+                // Crear backup del renderer actual
+                if (fs.existsSync(rendererDir)) {
+                    fs.cpSync(rendererDir, backupDir, { recursive: true });
+                }
+
+                // Extraer el nuevo renderer
+                await this.extractRenderer(tempZipPath, rendererDir);
+                
+                // Limpiar archivo temporal
+                fs.unlinkSync(tempZipPath);
+
+                // Actualizar versión actual
+                this.currentVersion = version;
+                
+                // Notificar al main window para refrescar
+                this.notifyMainWindow();
+                
+                return; // Éxito, salir del bucle
+
+            } catch (error) {
+                retryCount++;
+                console.error(`Error downloading renderer (attempt ${retryCount}/${maxRetries + 1}):`, error.message);
+                
+                if (retryCount > maxRetries) {
+                    console.error('All renderer download attempts failed. Giving up.');
+                    // Restaurar backup si existe
+                    await this.restoreBackupIfNeeded();
+                    throw error;
+                }
+                
+                // Esperar antes de reintentar (backoff exponencial)
+                const waitTime = Math.pow(2, retryCount) * 1000;
+                console.error(`Waiting ${waitTime}ms before retry...`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+    }
+
+    /**
+     * Extrae el renderer desde el archivo zip
+     */
+    async extractRenderer(zipPath, targetDir) {
+        return new Promise((resolve, reject) => {
+            // Asegurar que el directorio destino existe
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+
+            const platform = process.platform;
+            let command;
+
+            if (platform === 'win32') {
+                // Windows - usar PowerShell
+                command = `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${targetDir}' -Force"`;
+            } else {
+                // macOS y Linux - usar unzip nativo
+                command = `unzip -o "${zipPath}" -d "${targetDir}"`;
+            }
+
+            
+            exec(command, (error, stdout, stderr) => {
+                if (error) {
+                    console.error('Error extracting renderer with system command:', error);
+                    console.error('STDERR:', stderr);
+                    
+                    // Fallback para macOS si unzip falla: usar ditto (comando nativo de macOS)
+                    if (platform === 'darwin') {
+                        const dittoCommand = `ditto -x -k "${zipPath}" "${targetDir}"`;
+                        
+                        exec(dittoCommand, (dittoError, dittoStdout, dittoStderr) => {
+                            if (dittoError) {
+                                console.error('Ditto fallback also failed:', dittoError);
+                                console.error('Ditto STDERR:', dittoStderr);
+                                reject(new Error(`Failed to extract renderer on ${platform}. Both unzip and ditto commands failed.`));
+                            } else {
+                                resolve();
+                            }
+                        });
+                    } else {
+                        reject(new Error(`Failed to extract renderer on ${platform}`));
+                    }
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+
+    /**
+     * Restaura el backup si existe después de un error
+     */
+    async restoreBackupIfNeeded() {
+        try {
+            // Buscar el backup más reciente
+            const tempDir = app.getPath('temp');
+            const files = fs.readdirSync(tempDir);
+            const backupDirs = files.filter(f => f.startsWith('renderer-backup-') && fs.statSync(path.join(tempDir, f)).isDirectory());
+            
+            if (backupDirs.length > 0) {
+                // Ordenar por timestamp (más reciente primero)
+                backupDirs.sort((a, b) => {
+                    const aTime = parseInt(a.split('-').pop());
+                    const bTime = parseInt(b.split('-').pop());
+                    return bTime - aTime;
+                });
+                
+                const latestBackup = path.join(tempDir, backupDirs[0]);
+                const rendererDir = path.join(userData.getUserDataDir(), 'renderer');
+                
+                
+                // Limpiar directorio actual
+                if (fs.existsSync(rendererDir)) {
+                    fs.rmSync(rendererDir, { recursive: true, force: true });
+                }
+                
+                // Restaurar backup
+                fs.cpSync(latestBackup, rendererDir, { recursive: true });
+            }
+        } catch (error) {
+            console.error('Error restoring backup:', error);
+        }
+    }
+
+    /**
+     * Calcula el hash SHA256 de un buffer
+     */
+    calculateBufferHash(buffer) {
+        const hash = crypto.createHash('sha256');
+        hash.update(buffer);
+        return hash.digest('hex');
+    }
+
+    /**
+     * Notifica al main window para que refresque el contenido
+     */
+    notifyMainWindow() {
+        if (this.reloadCallback) {
+            this.reloadCallback(this.currentVersion);
+        }
+    }
+}
+
+module.exports = AutoUpdateRenderer;