@glassnote/client 2.4.13 → 2.4.15

package/autoupdate_renderer.js

@@ -21,6 +21,7 @@ class AutoUpdateRenderer {
         this.expectedHash = null;
         this.updateInterval = null;
         this.reloadCallback = reloadCallback;
+        this.ultimoChequeo = null;
     }
 
     /**
@@ -45,6 +46,11 @@ class AutoUpdateRenderer {
      * Inicia el sistema de auto-actualización del renderer
      */
     start() {
+        console.log(
+            `[renderer] auto-actualización activa: en uso ${this.currentVersion}, ` +
+                `primer chequeo en 10 s y despues cada 60 min contra ${this.S3_BASE_URL}`
+        );
+
         // Primera verificación después de 10 segundos
         setTimeout(() => {
             this.checkForUpdates();
@@ -67,15 +73,30 @@ class AutoUpdateRenderer {
     }
 
     /**
-     * Verifica si hay actualizaciones disponibles del renderer
+     * Verifica si hay actualizaciones disponibles del renderer.
+     *
+     * Igual que en npmUpdate: CADA chequeo deja una linea. Antes solo hablaba cuando
+     * fallaba, asi que un renderer viejo en un equipo era indistinguible de un chequeo que
+     * nunca corrio, y son dos cosas muy distintas. El atraso contra el intervalo delata al
+     * equipo que estuvo suspendido, que es la explicacion mas comun de "no se actualizo
+     * hasta que reinicie".
      */
     async checkForUpdates() {
+        const ahora = Date.now();
+        const desdeElAnterior = this.ultimoChequeo ? ahora - this.ultimoChequeo : null;
+        this.ultimoChequeo = ahora;
+        const atraso =
+            desdeElAnterior !== null
+                ? ` (${Math.round(desdeElAnterior / 60000)} min desde el anterior` +
+                    `${desdeElAnterior > 90 * 60 * 1000 ? ', MUCHO mas que el intervalo' : ''})`
+                : '';
+
         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');
+                console.error(`[renderer] chequeo${atraso}: el canal no devolvio version_renderer.txt`);
                 return;
             }
 
@@ -86,11 +107,20 @@ class AutoUpdateRenderer {
 
             // Comparar versiones
             if (this.compareVersions(this.currentVersion, newVersion) < 0) {
+                console.warn(
+                    `[renderer] chequeo${atraso}: hay ${newVersion} y esta en uso ` +
+                        `${this.currentVersion}; bajando`
+                );
                 await this.downloadRenderer(newVersion);
+            } else {
+                console.log(
+                    `[renderer] chequeo${atraso}: ${this.currentVersion} al día ` +
+                        `(el canal está en ${newVersion})`
+                );
             }
 
         } catch (error) {
-            console.error('Error checking for renderer updates:', error);
+            console.error(`[renderer] chequeo${atraso}: error comprobando actualizaciones:`, error.message || error);
         }
     }
 
@@ -231,7 +261,13 @@ class AutoUpdateRenderer {
                 fs.unlinkSync(tempZipPath);
 
                 // Actualizar versión actual
+                const anterior = this.currentVersion;
                 this.currentVersion = version;
+
+                console.warn(
+                    `[renderer] ${anterior} → ${version}: descomprimido en ${rendererDir} ` +
+                        `(${Math.round(rendererBuffer.length / 1024)} KB)`
+                );
                 
                 // Notificar al main window para refrescar
                 this.notifyMainWindow();
@@ -240,10 +276,10 @@ class AutoUpdateRenderer {
 
             } catch (error) {
                 retryCount++;
-                console.error(`Error downloading renderer (attempt ${retryCount}/${maxRetries + 1}):`, error.message);
+                console.error(`[renderer] fallo al bajar ${version} (intento ${retryCount}/${maxRetries + 1}):`, error.message);
                 
                 if (retryCount > maxRetries) {
-                    console.error('All renderer download attempts failed. Giving up.');
+                    console.error(`[renderer] ${version} no se pudo bajar en ${maxRetries + 1} intentos; se sigue con ${this.currentVersion}`);
                     // Restaurar backup si existe
                     await this.restoreBackupIfNeeded();
                     throw error;

package/bin/glassnote.js

@@ -723,7 +723,20 @@ function cmdUpdate(args) {
 	);
 	const version = positional[0] || 'latest';
 
-	if (waitMs > 0) esperarAQueCierre(waitMs);
+	// Cuando esto lo lanza la app, su salida va al log DEL DÍA, mezclada con la de la
+	// app. Por eso el bloque se abre y se cierra con una banda reconocible y cada renglón
+	// propio lleva la hora en el mismo formato que usa main.js: lo que npm escriba en el
+	// medio no tiene ni prefijo ni hora, y sin las bandas no se sabría de dónde salió.
+	const desde = installedVersion();
+	log(`\n[${new Date().toISOString()}] ====== UPDATE: ${desde} → ${version} ======`);
+
+	if (waitMs > 0) {
+		const cerro = esperarAQueCierre(waitMs);
+		log(
+			`[${new Date().toISOString()}] el cliente ${cerro ? 'se cerró' : 'SIGUE ABIERTO'}` +
+				`; npm arranca ahora`
+		);
+	}
 
 	// Sin `--wait` esto lo está corriendo una persona a mano, con el cliente abierto: el
 	// mismo EBUSY de Windows que en install, y con el mismo remedio.
@@ -744,10 +757,14 @@ function cmdUpdate(args) {
 	}
 
 	const spec = toSpec(version);
-	log(`glassnote — actualizando a ${spec}`);
+	log(`[${new Date().toISOString()}] glassnote — actualizando a ${spec}`);
 	const res = runNpm(['install', '-g', '--prefix', mode.NPM_PREFIX, spec]);
 	if (res.status !== 0) {
 		recordarFalloDeUpdate(version, `npm salió con ${res.status}`);
+		console.error(
+			`[${new Date().toISOString()}] ====== UPDATE FALLIDO: npm salió con ${res.status}, ` +
+				`sigue instalada la ${desde} ======`
+		);
 		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.
@@ -766,7 +783,7 @@ function cmdUpdate(args) {
 	// por el install, y el .app tiene que aparecerle igual (y con la version al dia).
 	const appMac = instalarAppMac();
 	if (appMac) step(`app actualizada en ${appMac}`);
-	log(`Actualizado a v${installedVersion()}.`);
+	log(`[${new Date().toISOString()}] ====== UPDATE OK: v${installedVersion()} ======`);
 	if (relaunch) {
 		launch({ detach: true });
 		return 0;

package/main.js

@@ -54,6 +54,9 @@ let cursorFueraDeLaVentana = false;
 let passthroughPedidoPorRenderer = true;
 let ignorandoMouse = true;
 let isCleaningUp = false;
+// El actualizador del renderer, para poder pedirle un chequeo desde afuera de la funcion
+// que lo crea (al volver de dormir).
+let actualizadorRenderer = null;
 
 
 // Inicializar y pasar datos de usuario
@@ -93,9 +96,22 @@ function cleanupOldLogs() {
 	}
 }
 
-// Create log file for current session
-const currentDate = new Date().toISOString().split('T')[0];
-const logFilePath = path.join(logsDir, `glassnote-${currentDate}.log`);
+// El archivo del dia, resuelto EN CADA ESCRITURA y no una sola vez al arrancar. Este
+// cliente se queda prendido semanas: con la ruta calculada al inicio, una sesion que
+// empezaba el martes seguia escribiendo en glassnote-<martes>.log el miercoles y el
+// jueves. Quien pedia "el log de hoy" recibia un archivo vacio y lo de hoy estaba
+// enterrado al final del de tres dias antes.
+let diaDelLog = null;
+let logFilePath = null;
+
+function archivoDeLog() {
+	const hoy = new Date().toISOString().split('T')[0];
+	if (hoy !== diaDelLog) {
+		diaDelLog = hoy;
+		logFilePath = path.join(logsDir, `glassnote-${hoy}.log`);
+	}
+	return logFilePath;
+}
 
 // Override console.log to write to file
 const originalConsoleLog = console.log;
@@ -110,7 +126,7 @@ console.log = function (...args) {
 
 	// Write to file
 	try {
-		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+		fs.appendFileSync(archivoDeLog(), logMessage, 'utf8');
 	} catch (error) {
 		originalConsoleLog.apply(console, ['Error writing to log file:', error]);
 	}
@@ -132,7 +148,7 @@ console.warn = function (...args) {
 	const logMessage = `[${timestamp}] WARN: ${message}\n`;
 
 	try {
-		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+		fs.appendFileSync(archivoDeLog(), logMessage, 'utf8');
 	} catch (error) {
 		originalConsoleWarn.apply(console, ['Error writing to log file:', error]);
 	}
@@ -193,7 +209,7 @@ console.error = function (...args) {
 
 	// Write to file
 	try {
-		fs.appendFileSync(logFilePath, logMessage, 'utf8');
+		fs.appendFileSync(archivoDeLog(), logMessage, 'utf8');
 	} catch (error) {
 		originalConsoleError.apply(console, ['Error writing to log file:', error]);
 	}
@@ -265,6 +281,8 @@ app.whenReady().then(() => {
 	const versionReport = new VersionReport();
 	versionReport.start();
 
+	vigilarEnergia(autoUpdate);
+
 	avisarSiFaltaCompositor();
 
 	// Create system tray with platform-appropriate icon
@@ -398,7 +416,7 @@ app.whenReady().then(() => {
 				// Also write directly to log file to ensure it's captured
 				const fileLogMessage = `[${timestamp}] ${logMessage}\n`;
 				try {
-					fs.appendFileSync(logFilePath, fileLogMessage, 'utf8');
+					fs.appendFileSync(archivoDeLog(), fileLogMessage, 'utf8');
 				} catch (error) {
 					console.error('Error writing renderer log to file:', error);
 				}
@@ -478,10 +496,14 @@ app.whenReady().then(() => {
 	// Initialize renderer auto-update after mainWindow is created
 	const autoUpdateRenderer = new AutoUpdateRenderer((version) => {
 		// Recargar la ventana para aplicar los cambios
+		console.warn(`[renderer] recargando la ventana para estrenar la ${version}`);
 		setTimeout(() => {
 			reloadMainWindow();
 		}, 1000);
 	});
+	// Guardado aparte: al volver de dormir se le pide un chequeo desde vigilarEnergia,
+	// que vive fuera de esta funcion.
+	actualizadorRenderer = autoUpdateRenderer;
 	autoUpdateRenderer.start();
 
 	// Cargar el HTML del renderer (priorizar userData, fallback a app)
@@ -750,6 +772,10 @@ function lockChecker() {
 const SONDEO_CURSOR_MS = 30;
 // Cada cuanto se repite la posicion aunque el cursor no se haya movido.
 const REEMISION_QUIETO_MS = 400;
+// Cada cuanto se repone el alwaysOnTop mientras la ventana esta a la vista. Es un
+// SetWindowPos cada tanto: barato al lado de un glass que se queda debajo de todo.
+const REAFIRMAR_ALWAYS_ON_TOP_MS = 4000;
+let ultimaReafirmacion = 0;
 
 // El passthrough efectivo sale de dos cosas: lo que pidio el renderer y si el cursor esta
 // siquiera sobre la ventana.
@@ -771,17 +797,21 @@ const REEMISION_QUIETO_MS = 400;
 // main, sin tocar lo que el renderer cree: cuando el cursor vuelve a entrar se reaplica
 // su decision tal cual, y desde ahi los eventos reales —que si llegan con la ventana
 // clickeable— lo ponen al dia.
-// El "siempre encima" se vuelve a pedir en cada show, y no alcanza con pedirlo una vez al
-// arrancar. Electron guarda el nivel de z-order como un estado suyo y solo baja a la API
-// del sistema cuando ESE estado cambia: si Windows le saca el TOPMOST a la ventana por su
-// cuenta, para Electron sigue estando arriba —isAlwaysOnTop() devuelve true— y no vuelve a
-// pedirlo nunca. De ahi el false y despues el true: es la unica forma de forzar que se
-// reemita.
+// El "siempre encima" hay que REPONERLO, no basta con pedirlo una vez al arrancar.
+//
+// Electron guarda el nivel de z-order como un estado suyo y solo baja a la API del sistema
+// cuando ESE estado cambia. Si Windows le saca el TOPMOST a la ventana por su cuenta, para
+// Electron la ventana sigue arriba —isAlwaysOnTop() devuelve true— y no lo vuelve a pedir
+// nunca. Medido en una VM de Windows 11: quitandole el TOPMOST a mano con SetWindowPos, la
+// ventana se queda abajo indefinidamente (14 s de muestreo, sin recuperarse una sola vez).
+// De ahi el false y despues el true: pedir true sobre true no reemite nada.
 //
-// Antes esto no se notaba porque cada glass entraba con show(), que ademas de mostrar
-// ACTIVA la ventana, y activarla la sube igual. Al pasar a showInactive() —para no robarle
-// el teclado a lo que estes haciendo— se muestra sin activar, y con eso quedo a la vista
-// que el alwaysOnTop no se estaba reponiendo.
+// Se repone en dos momentos, y hacen falta los dos:
+//   - en el evento `show`, que es cada glass que llega;
+//   - cada REAFIRMAR_ALWAYS_ON_TOP_MS mientras la ventana este visible, porque un mensaje
+//     largo se queda puesto horas y ahi no hay ningun show que lo repare. Quien le quita
+//     el TOPMOST no se pudo reproducir —ni con alt+tab, ni con una app a pantalla completa,
+//     ni con el ciclo ocultar/mostrar— asi que esto no depende de saber quien es.
 //
 // En Linux no se toca: ahi el "arriba de todo" es _NET_WM_STATE_ABOVE y quitarlo y ponerlo
 // invita al gestor de ventanas a recolocar la ventana, que es justo lo que costo domar.
@@ -811,6 +841,14 @@ function iniciarSondeoCursor() {
 	sondeoCursor = setInterval(() => {
 		if (!mainWindow || mainWindow.isDestroyed() || !mainWindow.isVisible()) return;
 
+		// Este tick ya corre solo con la ventana a la vista, que es justo cuando importa
+		// que este arriba: es el lugar natural para reponer el alwaysOnTop.
+		const ahoraMs = Date.now();
+		if (ahoraMs - ultimaReafirmacion >= REAFIRMAR_ALWAYS_ON_TOP_MS) {
+			ultimaReafirmacion = ahoraMs;
+			reafirmarAlwaysOnTop();
+		}
+
 		// En X11 screen.getCursorScreenPoint() no sirve: con la ventana ignorando el mouse
 		// Chromium se queda sin eventos y devuelve congelada la ultima posicion que vio
 		// (el porque, medido, esta en linuxCursor.js). Se le pregunta al servidor X. En
@@ -860,6 +898,55 @@ function detenerSondeoCursor() {
 	cursorFueraDeLaVentana = false;
 }
 
+// El equipo que duerme, escrito en el log.
+//
+// En los logs de campo una maquina suspendida se ve como un HUECO: ocho horas sin una
+// sola linea, y despues todo sigue como si nada. Desde afuera eso es indistinguible de
+// "la app se colgo", que es justo lo que se sospecha cuando alguien reporta que el
+// cliente no se actualizo hasta reiniciar. Anotando suspend/resume el hueco deja de ser
+// un misterio y se puede decir si los chequeos se saltearon porque el equipo no estaba.
+//
+// Y al volver de dormir se fuerza un chequeo: los relojes de setInterval no corren
+// mientras el equipo duerme, asi que un equipo que se suspende todas las noches llega a
+// la manana con el proximo chequeo mucho mas lejos de lo que dice el intervalo.
+function vigilarEnergia(autoUpdate) {
+	let dormidoDesde = null;
+
+	let powerMonitor;
+	try {
+		powerMonitor = require('electron').powerMonitor;
+	} catch (error) {
+		console.error('[energia] no hay powerMonitor:', error.message);
+		return;
+	}
+
+	powerMonitor.on('suspend', () => {
+		dormidoDesde = Date.now();
+		console.warn('[energia] el equipo se suspende');
+	});
+
+	powerMonitor.on('resume', () => {
+		const minutos = dormidoDesde ? Math.round((Date.now() - dormidoDesde) / 60000) : null;
+		dormidoDesde = null;
+		console.warn(
+			`[energia] el equipo volvio${minutos !== null ? ` tras ~${minutos} min dormido` : ''}` +
+				'; se fuerza un chequeo de actualizacion'
+		);
+		try {
+			if (autoUpdate && typeof autoUpdate.checkForUpdates === 'function') {
+				autoUpdate.checkForUpdates();
+			}
+			if (actualizadorRenderer) actualizadorRenderer.checkForUpdates();
+		} catch (error) {
+			console.error('[energia] el chequeo al volver fallo:', error.message);
+		}
+	});
+
+	powerMonitor.on('shutdown', () => console.warn('[energia] el sistema se esta apagando'));
+	powerMonitor.on('lock-screen', () => console.log('[energia] pantalla bloqueada'));
+	powerMonitor.on('unlock-screen', () => console.log('[energia] pantalla desbloqueada'));
+}
+
 // Una ventana transparente en X11 necesita un compositor: sin el, el servidor X no sabe
 // mezclar el ARGB con lo que hay detras y la ventana se pinta OPACA. En un overlay a
 // pantalla completa eso no es un detalle estetico, es la pantalla entera tapada de blanco.
@@ -996,6 +1083,13 @@ function loadRendererHtml(window, uuid) {
   }
 
   if (elegida) {
+    // Que version del renderer corre este equipo y de donde salio, dicho por el proceso
+    // principal y en el arranque. Antes solo se podia deducir del hash del bundle que
+    // aparecia en las lineas del renderer, que no le dice nada a nadie.
+    console.warn(
+      `[renderer] cargando ${elegida.version} desde ${elegida.nombre} (${elegida.htmlPath}) · ` +
+      fuentes.map((f) => `${f.nombre}=${f.version}`).join(' ')
+    );
     window.loadFile(elegida.htmlPath, {
       query: { uuid: uuid, version: packageJson.version }
     });

package/npmUpdate.js

@@ -26,11 +26,19 @@ const REGISTRY = process.env.GLASSNOTE_REGISTRY || 'https://registry.npmjs.org';
 const CHECK_DELAY_MS = 5000;
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // cada hora
 
+// El mismo archivo que usa main.js. Se calcula al vuelo y no se guarda: entre un
+// arranque y una actualización pueden pasar días, y el nombre lleva la fecha.
+function archivoDeLogDelDia() {
+	const hoy = new Date().toISOString().split('T')[0];
+	return path.join(userData.getUserDataDir(), 'logs', `glassnote-${hoy}.log`);
+}
+
 class NpmUpdate {
 	constructor() {
 		this.currentVersion = packageJson.version;
 		this.updateInterval = null;
 		this.updating = false;
+		this.ultimoChequeo = null;
 	}
 
 	start() {
@@ -42,6 +50,11 @@ class NpmUpdate {
 			return;
 		}
 
+		console.log(
+			`[update] auto-actualización activa: v${this.currentVersion}, ` +
+				`primer chequeo en ${Math.round(CHECK_DELAY_MS / 1000)} s y despues cada ` +
+				`${Math.round(CHECK_INTERVAL_MS / 60000)} min contra ${REGISTRY}`
+		);
 		setTimeout(() => this.checkForUpdates(), CHECK_DELAY_MS);
 		this.updateInterval = setInterval(() => this.checkForUpdates(), CHECK_INTERVAL_MS);
 	}
@@ -88,28 +101,68 @@ class NpmUpdate {
 		});
 	}
 
+	// CADA chequeo deja una linea, encuentre algo o no.
+	//
+	// Antes el camino feliz era mudo: solo se escribia cuando el registry fallaba. Con un
+	// cliente que se queda prendido semanas eso significa que "no se actualizo" y "ni
+	// siquiera miro" se ven EXACTAMENTE IGUAL en el log —las dos cosas son nada—, y son
+	// dos problemas distintos con dos arreglos distintos. Se dice tambien cuanto paso
+	// desde el chequeo anterior: los relojes de setInterval no corren mientras el equipo
+	// duerme, asi que un atraso grande es la pista de que el equipo estuvo suspendido y
+	// no de que el reloj se murio.
 	async checkForUpdates() {
-		if (this.updating) return;
+		if (this.updating) {
+			console.log('[update] ya hay una actualización en curso; este chequeo se saltea');
+			return;
+		}
+
+		const ahora = Date.now();
+		const desdeElAnterior = this.ultimoChequeo ? ahora - this.ultimoChequeo : null;
+		this.ultimoChequeo = ahora;
+		const atraso =
+			desdeElAnterior !== null
+				? ` (${Math.round(desdeElAnterior / 60000)} min desde el anterior` +
+					`${desdeElAnterior > CHECK_INTERVAL_MS * 1.5 ? ', MUCHO mas que el intervalo' : ''})`
+				: '';
+
 		try {
 			// Mismos nombres que el updater viejo, incluida la errata 'lastest', para no
 			// romper los userData que ya están en la calle.
 			const desiredVersion = userData.get('desiredVersion') || 'lastest';
-			if (!desiredVersion) return;
+			if (!desiredVersion) {
+				console.log(`[update] chequeo${atraso}: sin desiredVersion, no se mira nada`);
+				return;
+			}
 
 			const isLatest = desiredVersion === 'lastest' || desiredVersion === 'latest';
 			const target = isLatest ? 'latest' : desiredVersion;
 			const meta = await this.getJson(`${REGISTRY}/${npmMode.PKG_NAME}/${target}`);
-			if (!meta || !meta.version) return;
+			if (!meta || !meta.version) {
+				console.error(
+					`[update] chequeo${atraso}: el registry no dijo que version es '${target}'`
+				);
+				return;
+			}
 
 			const objetivo = meta.version;
 			const hayQueActualizar = isLatest
 				? compareVersions(this.currentVersion, objetivo) < 0
 				: this.currentVersion !== objetivo;
-			if (!hayQueActualizar) return;
+			if (!hayQueActualizar) {
+				console.log(
+					`[update] chequeo${atraso}: v${this.currentVersion} al día ` +
+						`(el canal '${target}' está en ${objetivo})`
+				);
+				return;
+			}
+			console.warn(
+				`[update] chequeo${atraso}: hay ${objetivo} y corre ${this.currentVersion} ` +
+					`(canal '${target}')`
+			);
 			if (this.fallidoHacePoco(objetivo)) return;
 			this.applyUpdate(objetivo);
 		} catch (error) {
-			console.error('[update] error comprobando actualizaciones:', error.message);
+			console.error(`[update] chequeo${atraso}: error comprobando actualizaciones:`, error.message);
 		}
 	}
 
@@ -126,7 +179,10 @@ class NpmUpdate {
 			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`);
+			console.warn(
+				`[update] ${version} ya falló${fallo.motivo ? ` (${fallo.motivo})` : ''}; ` +
+					`no se reintenta hasta dentro de ~${minutos} min`
+			);
 			return true;
 		} catch (error) {
 			return false;
@@ -137,7 +193,10 @@ class NpmUpdate {
 		if (this.updating) return;
 		this.updating = true;
 		this.stop();
-		console.log(`[update] ${this.currentVersion} → ${version}: actualizando y reiniciando`);
+		console.warn(
+			`[update] ${this.currentVersion} → ${version}: se lanza el ayudante, la app se cierra ` +
+				`y vuelve sola. El detalle del npm queda en este mismo log`
+		);
 
 		const cli = path.join(npmMode.PACKAGE_ROOT, 'bin', 'glassnote.js');
 
@@ -150,7 +209,7 @@ class NpmUpdate {
 		});
 		if (nodeBinary) {
 			delete env.ELECTRON_RUN_AS_NODE;
-			console.log(`[update] ayudante: ${nodeBinary}`);
+			console.log(`[update] ayudante: ${nodeBinary} (cli ${cli})`);
 		} else {
 			// Último recurso: electron haciendo de node. En Linux/macOS actualiza igual
 			// (borrar un binario en uso está permitido); en Windows lo más probable es
@@ -163,14 +222,19 @@ class NpmUpdate {
 		}
 
 		// 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.
+		// el único síntoma era la app reiniciándose sola. Va al log DEL DÍA, el mismo que
+		// escribe la app, y no a un update.log aparte: la actualización es lo que pasa
+		// entre el último renglón de un arranque y el primero del siguiente, y en dos
+		// archivos distintos —uno de ellos sin fechas— eso había que reconstruirlo a ojo.
+		// Aquí queda en su lugar de la línea de tiempo, y se borra con los demás a los 30
+		// días. La app ya cerró para cuando npm escribe, así que no se pisan.
 		let salida = 'ignore';
+		const logDelDia = archivoDeLogDelDia();
 		try {
-			fs.mkdirSync(userData.getUserDataDir(), { recursive: true });
-			salida = fs.openSync(path.join(userData.getUserDataDir(), 'update.log'), 'a');
+			fs.mkdirSync(path.dirname(logDelDia), { recursive: true });
+			salida = fs.openSync(logDelDia, 'a');
 		} catch (error) {
-			console.error('[update] no se pudo abrir update.log:', error.message);
+			console.error(`[update] no se pudo abrir ${logDelDia}:`, error.message);
 		}
 
 		try {
@@ -182,6 +246,7 @@ class NpmUpdate {
 				{ detached: true, stdio: ['ignore', salida, salida], env, cwd: os.tmpdir() }
 			);
 			child.unref();
+			console.warn(`[update] ayudante lanzado, pid ${child.pid}; la app se cierra en 500 ms`);
 		} catch (error) {
 			console.error('[update] no se pudo lanzar el actualizador:', error.message);
 			this.updating = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.13",
+  "version": "2.4.15",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -57,6 +57,7 @@
     "start-electron": "electron .",
     "test-update": "node scripts/test-update.js",
     "test-pairing": "node scripts/test-pairing.js",
+    "test-reconexion": "node scripts/test-reconexion.js",
     "test-cli": "node scripts/test-cli.js",
     "test": "node scripts/test-cli.js && node scripts/test-pairing.js && node scripts/test-update.js"
   },
@@ -74,7 +75,7 @@
     "url": "git+ssh://git@intermarkec/intermarkec/glassnote-electron.git"
   },
   "dependencies": {
-    "@glassnote/renderer": "2.0.12",
+    "@glassnote/renderer": "2.2.1",
     "cors": "^2.8.5",
     "electron": "^29.4.6",
     "express": "^4.18.2",