@glassnote/client 2.4.0

package/autoupdate.js

@@ -0,0 +1,473 @@
+const { app } = require('electron');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+const { exec, spawn } = 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 AutoUpdate {
+    constructor() {
+        this.S3_BASE_URL = S3_BASE_URL;
+        this.currentVersion = app.getVersion();
+        this.expectedHash = null;
+        this.updateInterval = null;
+    }
+
+    /**
+     * Inicia el sistema de auto-actualización
+     */
+    start() {
+        // Primera verificación después de 5 segundos
+        setTimeout(() => {
+            this.checkForUpdates();
+        }, 5000);
+
+        // Verificación periódica cada hora (3600000 ms = 1 hora)
+        this.updateInterval = setInterval(() => {
+            this.checkForUpdates();
+        }, 60 * 60 * 3000); // 3 hora en milisegundos
+    }
+
+    /**
+     * Detiene el sistema de auto-actualización
+     */
+    stop() {
+        if (this.updateInterval) {
+            clearInterval(this.updateInterval);
+            this.updateInterval = null;
+        }
+    }
+
+    /**
+     * Verifica si hay actualizaciones disponibles
+     */
+    async checkForUpdates() {
+        try {
+            const desiredVersion = userData.get('desiredVersion') || 'lastest';
+            
+            if (!desiredVersion || desiredVersion === '') {
+                return;
+            }
+            
+            const versionUrl = this.getVersionUrl(desiredVersion);
+            const versionContent = await this.downloadTextFile(versionUrl);
+            if (!versionContent) {
+                console.error('Error downloading version file from:', versionUrl);
+                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;
+
+            // Log informativo de versiones
+
+            const isLatestDesired = desiredVersion === 'lastest';
+
+            if (isLatestDesired) {
+                // Para "lastest" - instalar si current < remote
+                const versionComparison = this.compareVersions(this.currentVersion, newVersion);
+                if (versionComparison < 0) {
+                    await this.downloadInstaller(newVersion);
+                }
+            } else {
+                // Para versión específica - instalar si current != desired
+                if (this.currentVersion !== desiredVersion) {
+                    await this.downloadInstaller(desiredVersion);
+                }
+            }
+
+        } catch (error) {
+            console.error('Error checking for updates:', error);
+        }
+    }
+
+    /**
+     * Obtiene la URL del archivo de versión
+     */
+    getVersionUrl(desiredVersion) {
+        const platform = process.platform;
+        let platformName = 'windows';
+        
+        if (platform === 'darwin') platformName = 'macos';
+        if (platform === 'linux') platformName = 'linux';
+
+        const versionPrefix = desiredVersion === 'lastest' ? '' : `${desiredVersion}_`;
+        return `${this.S3_BASE_URL}/version_${versionPrefix}${platformName}.txt`;
+    }
+
+    /**
+     * 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 chunks = [];
+                let totalBytes = 0;
+                
+                response.on('data', (chunk) => {
+                    chunks.push(chunk);
+                    totalBytes += chunk.length;
+                });
+
+                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;
+    }
+
+    /**
+     * Obtiene la extensión del instalador según la plataforma
+     */
+    getInstallerExtension() {
+        switch (process.platform) {
+            case 'darwin': return '.dmg';
+            case 'linux': return '.AppImage';
+            default: return '.exe';
+        }
+    }
+
+    /**
+     * Obtiene el nombre del archivo del instalador según la plataforma
+     */
+    getInstallerFilename() {
+        return process.platform === 'linux' ? 'glassnote' : 'glassnote-installer';
+    }
+
+    /**
+     * Obtiene la ruta local del instalador
+     */
+    getInstallerPath(version) {
+        const filename = `${this.getInstallerFilename()}-${version}${this.getInstallerExtension()}`;
+        return path.join(userData.getUserDataDir(), filename);
+    }
+
+    /**
+     * Descarga el instalador con reintentos y verificación robusta
+     */
+    async downloadInstaller(version, maxRetries = 3) {
+        let retryCount = 0;
+        
+        while (retryCount <= maxRetries) {
+            try {
+                const installerPath = this.getInstallerPath(version);
+                const installerUrl = `${this.S3_BASE_URL}/${this.getInstallerFilename()}-${version}${this.getInstallerExtension()}`;
+
+                // Verificar si el instalador ya existe y tiene el hash correcto
+                if (fs.existsSync(installerPath)) {
+                    if (this.expectedHash) {
+                        const fileHash = await this.calculateFileHash(installerPath);
+
+                        // Comparación case-insensitive del hash
+                        if (fileHash.toLowerCase() === this.expectedHash.toLowerCase()) {
+                            this.runInstaller(version);
+                            return;
+                        }
+                        // Eliminar archivo corrupto antes de reintentar
+                        fs.unlinkSync(installerPath);
+                    } else {
+                        fs.unlinkSync(installerPath);
+                    }
+                }
+                
+                const installerBuffer = await this.downloadBinaryFile(installerUrl);
+                
+                // Verificar que el archivo se descargó completamente
+                if (!installerBuffer || installerBuffer.length === 0) {
+                    throw new Error('Downloaded installer is empty or incomplete');
+                }
+                
+                // Guardar el instalador
+                fs.writeFileSync(installerPath, installerBuffer);
+                
+                // Verificar hash inmediatamente después de guardar
+                if (this.expectedHash) {
+                    const downloadedHash = await this.calculateBufferHash(installerBuffer);
+                    
+                    // Comparación case-insensitive del hash
+                    if (downloadedHash.toLowerCase() !== this.expectedHash.toLowerCase()) {
+                        // Eliminar el archivo corrupto
+                        fs.unlinkSync(installerPath);
+                        throw new Error(`Installer hash verification failed! Expected: ${this.expectedHash}, Got: ${downloadedHash}`);
+                    }
+                }
+
+                this.runInstaller(version);
+                return; // Éxito, salir del bucle
+
+            } catch (error) {
+                retryCount++;
+                console.error(`Error downloading installer (attempt ${retryCount}/${maxRetries + 1}):`, error.message);
+                
+                if (retryCount > maxRetries) {
+                    console.error('All download attempts failed. Giving up.');
+                    throw error;
+                }
+                
+                // Esperar antes de reintentar (backoff exponencial)
+                const waitTime = Math.pow(2, retryCount) * 1000;
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+    }
+
+    /**
+     * Calcula el hash SHA256 de un archivo
+     */
+    calculateFileHash(filePath) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+
+            stream.on('data', (data) => {
+                hash.update(data);
+            });
+
+            stream.on('end', () => {
+                resolve(hash.digest('hex'));
+            });
+
+            stream.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * Calcula el hash SHA256 de un buffer
+     */
+    calculateBufferHash(buffer) {
+        const hash = crypto.createHash('sha256');
+        hash.update(buffer);
+        return hash.digest('hex');
+    }
+
+    /**
+     * Ejecuta el instalador
+     */
+    runInstaller(version) {
+        const installerPath = this.getInstallerPath(version);
+
+        // Verificar hash si se proporcionó expectedHash
+        if (this.expectedHash) {
+            this.calculateFileHash(installerPath)
+                .then((fileHash) => {
+                    // Comparación case-insensitive del hash
+                    if (fileHash.toLowerCase() !== this.expectedHash.toLowerCase()) {
+                        console.error('Installer hash verification failed!');
+                        console.error('Expected:', this.expectedHash);
+                        console.error('Actual:', fileHash);
+                        return;
+                    }
+                    this.executeInstaller(installerPath);
+                })
+                .catch((error) => {
+                    console.error('Error verifying installer hash:', error);
+                });
+        } else {
+            this.executeInstaller(installerPath);
+        }
+    }
+
+    /**
+     * Ejecuta el instalador según la plataforma
+     */
+    executeInstaller(installerPath) {
+        try {
+            if (process.platform === 'darwin') {
+                // macOS - manejo especial para DMG
+                this.executeMacInstaller(installerPath);
+            } else {
+                // Windows y Linux - ejecución normal
+                const isLinux = process.platform === 'linux';
+                
+                // Ejecutar el instalador de forma asíncrona en un proceso independiente
+                let command;
+                if (process.platform === 'win32') {
+                    // Windows: usar start para ejecutar en proceso independiente
+                    command = `start "" "${installerPath}"`;
+                } else if (isLinux) {
+                    // Linux: ejecutar instalador en background
+                    command = `chmod +x "${installerPath}" && "${installerPath}" &`;
+                }
+                
+                
+                // Ejecutar el instalador en un proceso independiente
+                exec(command, (error) => {
+                    if (error) {
+                        console.error('Error executing installer:', error);
+                    }
+                    // El instalador se está ejecutando independientemente,
+                    // ahora podemos cerrar la aplicación limpiamente
+                    app.quit();
+                });
+            }
+        } catch (error) {
+            console.error('Error executing installer:', error);
+            // En caso de error, asegurar cierre de la aplicación
+            app.quit();
+        }
+    }
+
+    /**
+     * Maneja la instalación en macOS (DMG)
+     */
+    executeMacInstaller(installerPath) {
+        // Crear script de instalación automática para macOS
+        const installScript = this.createMacInstallScript(installerPath);
+        const scriptPath = path.join(app.getPath('temp'), 'glassnote_install.sh');
+        
+        try {
+            // Guardar el script
+            fs.writeFileSync(scriptPath, installScript, { mode: 0o755 });
+            
+            // Ejecutar el script (que cerrará la app y hará la instalación)
+            exec(`"${scriptPath}"`, (error) => {
+                if (error) {
+                    console.error('Error executing install script:', error);
+                    return;
+                }
+                // El script se encarga de cerrar la aplicación
+            });
+        } catch (error) {
+            console.error('Error creating install script:', error);
+        }
+    }
+
+    /**
+     * Crea un script de instalación para macOS
+     */
+    createMacInstallScript(installerPath) {
+        const appName = 'glassnote.app';
+        const tempMountPoint = '/Volumes/GlassNoteInstaller';
+        const applicationsDir = '/Applications';
+        
+        return `#!/bin/bash
+
+# Script de instalación automática para GlassNote macOS
+
+echo " Iniciando instalación automática de GlassNote..."
+
+# Cerrar la aplicación si está ejecutándose
+echo " Cerrando GlassNote si está en ejecución..."
+pkill -f "GlassNote" || true
+sleep 2
+
+# Asegurarse de que la aplicación esté completamente cerrada
+pkill -9 -f "GlassNote" || true
+sleep 1
+
+# Desmontar punto de montaje si existe
+echo " Desmontando imagen previa si existe..."
+hdiutil detach "${tempMountPoint}" -force 2>/dev/null || true
+
+# Montar el DMG
+echo " Montando imagen de instalación..."
+hdiutil attach "${installerPath}" -nobrowse -mountpoint "${tempMountPoint}"
+
+# Verificar que se montó correctamente
+if [ ! -d "${tempMountPoint}/${appName}" ]; then
+    echo " Error: No se pudo encontrar ${appName} en la imagen DMG"
+    hdiutil detach "${tempMountPoint}" -force
+    exit 1
+fi
+
+# Eliminar versión anterior si existe
+echo "️  Eliminando versión anterior si existe..."
+rm -rf "${applicationsDir}/${appName}"
+
+# Copiar la nueva aplicación
+echo " Copiando nueva versión a Applications..."
+cp -R "${tempMountPoint}/${appName}" "${applicationsDir}/"
+
+# Ajustar permisos
+echo " Ajustando permisos..."
+chmod -R 755 "${applicationsDir}/${appName}"
+
+# Desmontar la imagen
+echo " Desmontando imagen..."
+hdiutil detach "${tempMountPoint}" -force
+
+# Limpiar archivo de instalación temporal
+echo " Limpiando archivos temporales..."
+rm -f "${installerPath}"
+
+echo " Instalación completada exitosamente!"
+echo " GlassNote ha sido actualizado a la última versión"
+
+# Abrir la aplicación (opcional)
+sleep 2
+open -a "${applicationsDir}/${appName}"
+
+exit 0
+`;
+    }
+}
+
+module.exports = AutoUpdate;