@glassnote/client 2.4.0 → 2.4.3

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

@@ -29,9 +29,58 @@ const MARK_B = '# <<< glassnote <<<';
 function npmEnv() {
 	return Object.assign({}, process.env, {
 		PATH: `${mode.BIN_DIR}${path.delimiter}${process.env.PATH || ''}`,
+		// Cache propia, bajo ~/.glassnote. Un ~/.npm con archivos de root —herencia de
+		// cualquier `sudo npm` viejo— hace que npm muera con EACCES antes de bajar nada,
+		// y el usuario tiene que andar con chown. Se pisa a propósito el npm_config_cache
+		// heredado: cuando esto corre bajo npx, npm nos pasa el suyo en el entorno, que es
+		// justo el que puede estar roto. Para forzar otra: GLASSNOTE_NPM_CACHE.
+		npm_config_cache:
+			process.env.GLASSNOTE_NPM_CACHE || path.join(mode.HOME_DIR, 'npm-cache'),
 	});
 }
 
+// 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) {
@@ -242,6 +291,108 @@ function toSpec(arg) {
 	return looksLikeSpec ? arg : `${mode.PKG_NAME}@${arg}`;
 }
 
+const MAC_APP_NAME = 'Glassnote.app';
+
+// Instalado por npm queda un comando, no una app: cerrada desde la bandeja no hay forma
+// de volver a abrirla desde el Finder, Spotlight o Launchpad. Esto crea un .app minimo
+// —un envoltorio que llama al CLI instalado— para tener de donde relanzarla.
+function macAppDirs() {
+	return [
+		path.join('/Applications', MAC_APP_NAME),
+		path.join(os.homedir(), 'Applications', MAC_APP_NAME),
+	];
+}
+
+function instalarAppMac() {
+	if (process.platform !== 'darwin') return null;
+
+	// /Applications pide ser admin; si no se puede escribir, la de usuario sirve igual y
+	// Spotlight la indexa lo mismo. Nada de sudo: la instalacion entera va sin root.
+	const [global, local] = macAppDirs();
+	let appDir = local;
+	try {
+		fs.accessSync('/Applications', fs.constants.W_OK);
+		appDir = global;
+	} catch (error) {
+		/* sin permiso: se usa ~/Applications */
+	}
+
+	const contents = path.join(appDir, 'Contents');
+	const cli = path.join(mode.BIN_DIR, mode.BIN_NAME);
+	try {
+		fs.mkdirSync(path.join(contents, 'MacOS'), { recursive: true });
+		fs.mkdirSync(path.join(contents, 'Resources'), { recursive: true });
+
+		// El ejecutable del bundle solo delega en el CLI, que ya sabe encontrar electron y
+		// arrancar desprendido. Asi el .app no se queda viejo cuando el cliente se actualiza.
+		const exe = path.join(contents, 'MacOS', 'Glassnote');
+		fs.writeFileSync(
+			exe,
+			[
+				'#!/bin/sh',
+				"# Generado por 'glassnote install': se reescribe en cada instalacion.",
+				`exec "${cli}" start`,
+				'',
+			].join('\n')
+		);
+		fs.chmodSync(exe, 0o755);
+
+		// El icono del bundle tiene que ser .icns; sips viene con macOS. Si falla, el .app
+		// queda con el icono generico: molesta, pero no impide relanzar.
+		const png = path.join(mode.INSTALLED_PACKAGE_DIR, 'images', 'icon-512.png');
+		if (fs.existsSync(png)) {
+			spawnSync(
+				'sips',
+				['-s', 'format', 'icns', png, '--out', path.join(contents, 'Resources', 'glassnote.icns')],
+				{ stdio: 'ignore' }
+			);
+		}
+
+		// LSUIElement, igual que la app: el envoltorio tampoco tiene que dejar icono en el Dock.
+		const version = installedVersion() || '0.0.0';
+		fs.writeFileSync(
+			path.join(contents, 'Info.plist'),
+			`<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>Glassnote</string>
+  <key>CFBundleDisplayName</key><string>Glassnote</string>
+  <key>CFBundleIdentifier</key><string>com.glassnote.launcher</string>
+  <key>CFBundleExecutable</key><string>Glassnote</string>
+  <key>CFBundleIconFile</key><string>glassnote</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleShortVersionString</key><string>${version}</string>
+  <key>CFBundleVersion</key><string>${version}</string>
+  <key>LSUIElement</key><true/>
+</dict>
+</plist>
+`
+		);
+
+		// El Finder cachea el bundle por fecha: sin esto puede seguir mostrando el icono viejo.
+		spawnSync('touch', [appDir], { stdio: 'ignore' });
+		return appDir;
+	} catch (error) {
+		// Que no se pueda crear la app no rompe la instalacion: el comando ya funciona.
+		log(`  (no pude crear ${MAC_APP_NAME}: ${error.message})`);
+		return null;
+	}
+}
+
+function borrarAppMac() {
+	if (process.platform !== 'darwin') return;
+	for (const dir of macAppDirs()) {
+		if (!fs.existsSync(dir)) continue;
+		try {
+			step(`borrando ${dir}`);
+			fs.rmSync(dir, { recursive: true, force: true });
+		} catch (error) {
+			log(`  (no pude borrar ${dir}: ${error.message})`);
+		}
+	}
+}
+
 function cmdInstall(args) {
 	const version = args.find((a) => !a.startsWith('-')) || 'latest';
 	const noPath = args.includes('--no-path');
@@ -281,6 +432,9 @@ function cmdInstall(args) {
 		}
 	}
 
+	const appMac = instalarAppMac();
+	if (appMac) step(`app creada en ${appMac} (para relanzarlo desde el Finder)`);
+
 	let pathInfo = { touched: [], line: '' };
 	if (!noPath) {
 		pathInfo = IS_WIN ? addToPathWindows() : addToPathUnix();
@@ -346,6 +500,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 +510,11 @@ function cmdUpdate(args) {
 		fail('npm no pudo actualizar el paquete.');
 	}
 
+	olvidarFalloDeUpdate();
+	// Se rehace en cada update: quien ya tenia el cliente instalado de antes no paso
+	// 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()}.`);
 	if (relaunch) {
 		launch({ detach: true });
@@ -366,6 +526,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();
 
@@ -378,11 +542,19 @@ function cmdUninstall() {
 		step('el PATH de usuario ya no tenía la entrada');
 	}
 
+	borrarAppMac();
+
 	if (fs.existsSync(mode.HOME_DIR)) {
 		step(`borrando ${mode.HOME_DIR}`);
 		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

@@ -4,6 +4,7 @@ const {
 	Notification,
 	Tray,
 	Menu,
+	nativeImage,
 	screen,
 } = require('electron');
 const packageJson = require('./package.json');
@@ -17,6 +18,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;
@@ -120,6 +122,23 @@ cleanupOldLogs();
 createTailUtility(logsDir);
 
 app.whenReady().then(() => {
+	// macOS: esto es una app de bandeja, se maneja desde la barra de menu. Instalada por
+	// npm no hay .app propio, asi que el Dock mostraba el icono por defecto de Electron y
+	// una entrada que no sirve para nada. Se saca del Dock, pero antes se le pone el icono
+	// de glassnote: si algo lo vuelve a mostrar (un dialogo modal lo hace), que al menos
+	// no aparezca como "Electron".
+	if (process.platform === 'darwin' && app.dock) {
+		try {
+			const dockIcon = nativeImage.createFromPath(
+				path.join(__dirname, 'images', 'icon-512.png')
+			);
+			if (!dockIcon.isEmpty()) app.dock.setIcon(dockIcon);
+		} catch (error) {
+			console.warn('[dock] no se pudo poner el icono:', error.message);
+		}
+		app.dock.hide();
+	}
+
 	// Configure auto-start - this will handle shortcut creation
 	//
 	// Corriendo por `npx` no se registra nada: la app vive en la caché de npx, que se
@@ -556,20 +575,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 +701,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.3",
   "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 };