@glassnote/client 2.4.0 → 2.4.2

package/autoupdate_renderer.js

@@ -5,6 +5,7 @@ const https = require('https');
 const crypto = require('crypto');
 const { exec } = require('child_process');
 const userData = require('./userData');
+const { baselineRendererDir, rendererVersionFrom } = require('./rendererPaths');
 
 // 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
@@ -23,29 +24,21 @@ class AutoUpdateRenderer {
     }
 
     /**
-     * Obtiene la versión actual del renderer desde package.json
+     * La versión del renderer que está EN USO, que es contra la que hay que comparar el
+     * canal. En uso es la que elige loadRendererHtml: la más alta entre lo bajado a
+     * userData y el baseline que viaja con el paquete.
+     *
+     * Antes esto miraba solo userData y, si no había, `<paquete>/renderer/package.json`
+     * —una carpeta que dejó de existir cuando el renderer pasó a ser dependencia npm—.
+     * Devolvía 0.0.0, así que en cada instalación nueva cualquier versión del canal le
+     * ganaba: bajaba el zip de S3 aunque fuera MÁS VIEJO que el baseline, y después el
+     * loader se quedaba con el baseline igual: 1.1 MB tirados y una versión "actual"
+     * que no era la que se estaba usando.
      */
     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';
-        }
+        const enUserData = rendererVersionFrom(path.join(userData.getUserDataDir(), 'renderer'));
+        const enBaseline = rendererVersionFrom(baselineRendererDir());
+        return this.compareVersions(enUserData, enBaseline) >= 0 ? enUserData : enBaseline;
     }
 
     /**

package/bin/glassnote.js

@@ -32,6 +32,48 @@ function npmEnv() {
 	});
 }
 
+// userData tira de `uuid`, y este CLI corre también donde el árbol de dependencias no
+// está (un tarball recién desempacado, un install a medias). Por eso se carga tarde y
+// tolerando el fallo: si no se puede dejar constancia, el peor caso es que la app
+// reintente en el chequeo siguiente. Romper el CLI —que es quien instala— sería peor.
+function conUserData(hacer) {
+	try {
+		return hacer(require('../userData'));
+	} catch (error) {
+		return undefined;
+	}
+}
+
+// La app mira esto antes de reintentar: sin memoria del fallo, un npm que falla siempre
+// deja al cliente cerrándose y abriéndose cada veinte segundos (falla, se relanza,
+// chequea a los 5 segundos, vuelve a fallar).
+function recordarFalloDeUpdate(version, motivo) {
+	conUserData((userData) => userData.set('failedUpdate', { version, at: Date.now(), motivo }));
+}
+
+function olvidarFalloDeUpdate() {
+	conUserData((userData) => {
+		if (userData.get('failedUpdate')) userData.remove('failedUpdate');
+	});
+}
+
+// ¿Hay un cliente vivo? Levanta su servidor local en 48984 (localserver.js), así que su
+// /uuid es la señal más barata. Node no tiene HTTP síncrono y el CLI sí lo es, así que la
+// consulta va en un proceso aparte.
+function clienteEnMarcha() {
+	const sonda =
+		"const http=require('http');" +
+		"const r=http.get('http://127.0.0.1:48984/uuid',(res)=>{res.resume();process.exit(res.statusCode===200?0:1)});" +
+		"r.on('error',()=>process.exit(1));" +
+		"r.setTimeout(700,()=>{r.destroy();process.exit(1)});";
+	const res = spawnSync(process.execPath, ['-e', sonda], {
+		env: Object.assign({}, process.env, { ELECTRON_RUN_AS_NODE: '1' }),
+		stdio: 'ignore',
+		timeout: 4000,
+	});
+	return res.status === 0;
+}
+
 // Sueño síncrono sin dependencias: el ayudante de actualización tiene que esperar a que
 // la app termine de cerrarse antes de que npm le reemplace los archivos.
 function sleepSync(ms) {
@@ -346,6 +388,7 @@ function cmdUpdate(args) {
 		env: npmEnv(),
 	});
 	if (res.status !== 0) {
+		recordarFalloDeUpdate(version, `npm salió con ${res.status}`);
 		if (relaunch) {
 			// Falló la actualización: al menos el cliente vuelve. Quedarse sin app por
 			// un npm que no pudo con la red es peor que seguir en la versión vieja.
@@ -355,6 +398,7 @@ function cmdUpdate(args) {
 		fail('npm no pudo actualizar el paquete.');
 	}
 
+	olvidarFalloDeUpdate();
 	log(`Actualizado a v${installedVersion()}.`);
 	if (relaunch) {
 		launch({ detach: true });
@@ -366,6 +410,10 @@ function cmdUpdate(args) {
 
 function cmdUninstall() {
 	log('glassnote — desinstalando');
+	// Se comprueba ANTES de borrar: después los archivos ya no están, pero el proceso que
+	// los tenía abiertos sigue vivo y con su ícono en la bandeja. Decir "Desinstalado" con
+	// la app todavía en pantalla es lo que confunde.
+	const seguiaAbierto = clienteEnMarcha();
 	step('quitando el autoarranque');
 	removeAutoStart();
 
@@ -383,6 +431,12 @@ function cmdUninstall() {
 		fs.rmSync(mode.HOME_DIR, { recursive: true, force: true });
 	}
 	log('');
+	if (seguiaAbierto) {
+		log('OJO: el cliente sigue abierto. Sus archivos ya no están, pero el proceso vive');
+		log('hasta que lo cierres desde el ícono de la bandeja (Salir). Después no vuelve a');
+		log('abrirse: el autoarranque ya no está.');
+		log('');
+	}
 	log('Desinstalado. Tus datos y notas siguen donde estaban:');
 	log(`  ${userDataDir()}`);
 	log('Borralos a mano si también querés perderlos.');

package/main.js

@@ -17,6 +17,7 @@ const AutoUpdate = require('./autoupdate');
 const NpmUpdate = require('./npmUpdate');
 const npmMode = require('./npmMode');
 const AutoUpdateRenderer = require('./autoupdate_renderer');
+const { baselineRendererDir, rendererVersionFrom: getRendererVersionFromPath } = require('./rendererPaths');
 const { createTailUtility } = require('./logUtilities');
 
 const logRenderer = packageJson.logRenderer !== undefined ? packageJson.logRenderer : true;
@@ -556,20 +557,7 @@ process.on('unhandledRejection', (reason, promise) => {
  *
  * 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;
-  }
-}
+// baselineRendererDir vive en rendererPaths.js: lo comparte con el updater del renderer.
 
 function loadRendererHtml(window, uuid) {
   // Definir las dos fuentes a considerar con archivos HTML alternativos
@@ -695,38 +683,7 @@ function compareVersions(version1, version2) {
 	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
-}
+// getRendererVersionFromPath = rendererVersionFrom de rendererPaths.js (ver el require de arriba).
 
 /**
  * Recarga el main window después de una actualización del renderer

package/npmUpdate.js

@@ -8,6 +8,7 @@
 // desprendido, la app se cierra, el ayudante actualiza y la vuelve a abrir. Igual en las
 // tres plataformas, así no hay una rama por sistema operativo que solo se pruebe en uno.
 const https = require('https');
+const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 
@@ -90,18 +91,38 @@ class NpmUpdate {
 			const meta = await this.getJson(`${REGISTRY}/${npmMode.PKG_NAME}/${target}`);
 			if (!meta || !meta.version) return;
 
-			if (isLatest) {
-				if (compareVersions(this.currentVersion, meta.version) < 0) {
-					this.applyUpdate(meta.version);
-				}
-			} else if (this.currentVersion !== meta.version) {
-				this.applyUpdate(meta.version);
-			}
+			const objetivo = meta.version;
+			const hayQueActualizar = isLatest
+				? compareVersions(this.currentVersion, objetivo) < 0
+				: this.currentVersion !== objetivo;
+			if (!hayQueActualizar) return;
+			if (this.fallidoHacePoco(objetivo)) return;
+			this.applyUpdate(objetivo);
 		} catch (error) {
 			console.error('[update] error comprobando actualizaciones:', error.message);
 		}
 	}
 
+	// Una actualización que falló NO se reintenta enseguida. cmdUpdate relanza la app a
+	// propósito cuando npm falla —quedarse sin cliente es peor que quedarse en la versión
+	// vieja—, pero el chequeo vuelve a los 5 segundos de arrancar. Con un fallo que
+	// persiste (sin red, el registry caído, una dependencia que no resuelve) eso es la app
+	// cerrándose y abriéndose cada veinte segundos, para siempre y sin decir por qué. Se
+	// recuerda la versión que falló y se espera al chequeo normal.
+	fallidoHacePoco(version) {
+		try {
+			const fallo = userData.get('failedUpdate');
+			if (!fallo || fallo.version !== version) return false;
+			const desde = Date.now() - (fallo.at || 0);
+			if (desde >= CHECK_INTERVAL_MS) return false;
+			const minutos = Math.max(1, Math.round((CHECK_INTERVAL_MS - desde) / 60000));
+			console.log(`[update] ${version} ya falló; no se reintenta hasta dentro de ~${minutos} min`);
+			return true;
+		} catch (error) {
+			return false;
+		}
+	}
+
 	applyUpdate(version) {
 		if (this.updating) return;
 		this.updating = true;
@@ -117,11 +138,22 @@ class NpmUpdate {
 			PATH: `${npmMode.BIN_DIR}${path.delimiter}${process.env.PATH || ''}`,
 		});
 
+		// El ayudante corre desprendido y su salida no la veía nadie: cuando npm fallaba,
+		// el único síntoma era la app reiniciándose sola. Va a un archivo al lado de los
+		// datos de usuario, que es donde alguien lo va a buscar.
+		let salida = 'ignore';
+		try {
+			fs.mkdirSync(userData.getUserDataDir(), { recursive: true });
+			salida = fs.openSync(path.join(userData.getUserDataDir(), 'update.log'), 'a');
+		} catch (error) {
+			console.error('[update] no se pudo abrir update.log:', error.message);
+		}
+
 		try {
 			const child = spawn(
 				process.execPath,
 				[cli, 'update', version, '--relaunch', '--wait', '4000'],
-				{ detached: true, stdio: 'ignore', env }
+				{ detached: true, stdio: ['ignore', salida, salida], env }
 			);
 			child.unref();
 		} catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -29,6 +29,7 @@
     "autoStart.js",
     "autoupdate.js",
     "autoupdate_renderer.js",
+    "rendererPaths.js",
     "npmMode.js",
     "npmUpdate.js",
     "localserver.js",

package/rendererPaths.js

@@ -0,0 +1,62 @@
+// De dónde sale el renderer y qué versión tiene. En un solo sitio a propósito.
+//
+// Esto vivía duplicado en main.js y en autoupdate_renderer.js, y las dos copias se
+// fueron separando: la del updater seguía mirando `<paquete>/renderer/`, una carpeta que
+// dejó de existir cuando el renderer pasó a ser la dependencia @glassnote/renderer. Como
+// no la encontraba devolvía 0.0.0, cualquier versión del canal le ganaba, y cada
+// instalación nueva bajaba el zip de S3 —incluso más viejo que el baseline— para después
+// no usarlo. Un bug silencioso: se ve como 1.1 MB de tráfico que nadie pidió.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// El baseline 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 vería nunca, tapado por la versión
+// 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; quien llama avisa si tampoco está.
+		return clonLocal;
+	}
+}
+
+// La versión de un directorio de renderer. El dist/ publicado trae su propio
+// package.json; si algún día no lo trajera, la versión la tiene el paquete de arriba.
+function rendererVersionFrom(rendererPath) {
+	try {
+		const propio = path.join(rendererPath, 'package.json');
+		if (fs.existsSync(propio)) {
+			return JSON.parse(fs.readFileSync(propio, 'utf8')).version || '0.0.0';
+		}
+		if (path.basename(rendererPath) === 'dist') {
+			const delPadre = path.join(rendererPath, '..', 'package.json');
+			if (fs.existsSync(delPadre)) {
+				return JSON.parse(fs.readFileSync(delPadre, 'utf8')).version || '0.0.0';
+			}
+		}
+	} catch (error) {
+		console.error('Error reading renderer version from', rendererPath, ':', error);
+	}
+	return '0.0.0'; // No hay renderer ahí, o no se pudo leer.
+}
+
+// Compara dos versiones semánticas: 1 si a es mayor, -1 si b lo es, 0 si empatan.
+function compareRendererVersions(a, b) {
+	const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+	const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const va = i < pa.length ? pa[i] : 0;
+		const vb = i < pb.length ? pb[i] : 0;
+		if (va > vb) return 1;
+		if (va < vb) return -1;
+	}
+	return 0;
+}
+
+module.exports = { baselineRendererDir, rendererVersionFrom, compareRendererVersions };