@glassnote/client 2.4.4 → 2.4.6

package/INSTALACION.md

@@ -86,7 +86,8 @@ se rompe en silencio es la que descarga la gente.
 
 ## Actualizaciones
 
-Instalado por npm, el cliente comprueba el registry cada 3 horas y se actualiza solo:
+Instalado por npm, el cliente comprueba el registry a los 5 segundos de arrancar y cada
+hora a partir de ahí, y se actualiza solo:
 
 - lee `desiredVersion` de los datos de usuario (`lastest` = seguir la última, o una
   versión exacta y clavada); son las mismas claves que usaba el updater de S3, para no
@@ -95,6 +96,18 @@ Instalado por npm, el cliente comprueba el registry cada 3 horas y se actualiza
   abrir. El npm **no** se corre con la app en marcha: en Windows el `electron.exe` en uso
   está bloqueado y npm no podría reemplazarlo.
 
+El ayudante corre con un **node de fuera del paquete**, no con el electron de la propia
+app: ese electron vive dentro del árbol que npm va a reemplazar y en Windows lo mantenía
+bloqueado, así que npm fallaba y la actualización no se aplicaba nunca. Se busca, en
+orden: `GLASSNOTE_NODE`, el node anotado en `~/.glassnote/node-path` al instalar, el que
+bajó el instalador a `~/.glassnote/node-v*`, y el del PATH. A npm se lo llama por su
+`npm-cli.js`, no por el shim: en Windows el instalador mete su Node al PATH de esa sola
+sesión de PowerShell, y la app —que la abre el autoarranque— no lo tendría.
+
+`glassnote status` dice cuál se va a usar. Si sale `node de update: NO ENCONTRADO`, la
+auto-actualización no puede funcionar en esa máquina: hay que reinstalar el cliente
+(`irm https://glassnote.intermark.ec/install.ps1 | iex`) o instalar Node.
+
 Por `npx` no se actualiza nada: la caché es efímera y npx ya baja la última versión cada
 vez. Tampoco se registra el arranque automático — apuntaría a una carpeta que se limpia
 sola.

package/autoupdate.js

@@ -30,10 +30,12 @@ class AutoUpdate {
             this.checkForUpdates();
         }, 5000);
 
-        // Verificación periódica cada hora (3600000 ms = 1 hora)
+        // Verificación periódica cada hora. Antes decía "cada hora" en el comentario pero
+        // la cuenta era 60 * 60 * 3000, o sea 3 horas: un cliente podía tardar toda una
+        // tarde en enterarse de una versión nueva.
         this.updateInterval = setInterval(() => {
             this.checkForUpdates();
-        }, 60 * 60 * 3000); // 3 hora en milisegundos
+        }, 60 * 60 * 1000);
     }
 
     /**

package/bin/glassnote.js

@@ -39,6 +39,22 @@ function npmEnv() {
 	});
 }
 
+// npm se invoca por su `npm-cli.js` con el node que lo trae, NO por el shim del PATH.
+// En Windows el instalador puede bajarse un Node a ~/.glassnote y meterlo solo al PATH de
+// la sesión de PowerShell que corrió la instalación: la app la arranca el autoarranque,
+// con otro entorno, y ahí `npm` no existe. La auto-actualización moría en "npm no se
+// reconoce como un comando" y nadie lo veía. Si no hay forma de resolver el npm-cli.js se
+// vuelve al shim de siempre.
+function runNpm(args, opts) {
+	const nodeBinary = mode.resolveNodeBinary(process.execPath);
+	const npmCli = mode.resolveNpmCli(nodeBinary);
+	const base = { stdio: 'inherit', shell: false, env: npmEnv() };
+	if (nodeBinary && npmCli) {
+		return spawnSync(nodeBinary, [npmCli].concat(args), Object.assign(base, opts || {}));
+	}
+	return spawnSync(NPM_CMD, args, Object.assign(base, { shell: IS_WIN }, opts || {}));
+}
+
 // 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
@@ -188,10 +204,10 @@ function addToPathUnix() {
 	return { touched, line };
 }
 
-function addToPathWindows() {
+function addToPathWindows(dir = mode.BIN_DIR) {
 	// Nada de `setx`: trunca el PATH a 1024 caracteres y se come el de la gente.
 	const ps = [
-		"$dir = '" + mode.BIN_DIR.replace(/'/g, "''") + "'",
+		"$dir = '" + dir.replace(/'/g, "''") + "'",
 		"$cur = [Environment]::GetEnvironmentVariable('Path','User')",
 		"if ($null -eq $cur) { $cur = '' }",
 		"if (($cur -split ';') -notcontains $dir) {",
@@ -204,7 +220,22 @@ function addToPathWindows() {
 		encoding: 'utf8',
 	});
 	const added = res.status === 0 && String(res.stdout).includes('added');
-	return { touched: added ? ['PATH de usuario (sin administrador)'] : [], line: mode.BIN_DIR };
+	return { touched: added ? ['PATH de usuario (sin administrador)'] : [], line: dir };
+}
+
+// El shim `glassnote.cmd` que crea npm invoca `node` del PATH. Cuando el Node lo bajó el
+// instalador a ~/.glassnote, ese directorio solo quedaba en el PATH de la sesión de
+// PowerShell que corrió la instalación: en una terminal nueva —o en cualquier proceso
+// posterior— `glassnote` moría con «"node" no se reconoce como un comando». Se agrega el
+// directorio del node al PATH de usuario, igual que BIN_DIR.
+function addNodeToPathWindows() {
+	if (!IS_WIN) return null;
+	const nodeBinary = mode.resolveNodeBinary(process.execPath);
+	// Solo el node que trajimos nosotros: el del sistema ya está donde tiene que estar.
+	if (!nodeBinary || !mode.isInside(nodeBinary, mode.HOME_DIR)) return null;
+	const dir = path.dirname(nodeBinary);
+	const res = addToPathWindows(dir);
+	return res.touched.length ? dir : null;
 }
 
 function removeFromPathUnix() {
@@ -237,7 +268,10 @@ function removeFromPathWindows() {
 		"$dir = '" + mode.BIN_DIR.replace(/'/g, "''") + "'",
 		"$cur = [Environment]::GetEnvironmentVariable('Path','User')",
 		"if ($null -eq $cur) { Write-Output 'absent'; exit }",
-		"$new = (($cur -split ';') | Where-Object { $_ -ne '' -and $_ -ne $dir }) -join ';'",
+		// Se quita cualquier entrada bajo ~/.glassnote, no solo BIN_DIR: el install tambien
+		// agrega el directorio del node que bajo, y dejarlo seria una ruta muerta.
+		"$home2 = '" + mode.HOME_DIR.replace(/'/g, "''") + "'",
+		"$new = (($cur -split ';') | Where-Object { $_ -ne '' -and $_ -ne $dir -and -not $_.StartsWith($home2, [StringComparison]::OrdinalIgnoreCase) }) -join ';'",
 		'if ($new -ne $cur) {',
 		"  [Environment]::SetEnvironmentVariable('Path', $new, 'User')",
 		"  Write-Output 'removed'",
@@ -406,13 +440,15 @@ function cmdInstall(args) {
 	// Los scripts de instalación van ACTIVADOS a propósito: el binario de electron se
 	// baja en un postinstall. Con --ignore-scripts quedaría instalado y roto.
 	step(`npm install -g --prefix ${mode.NPM_PREFIX} (sin root, la primera vez tarda: baja electron)`);
-	const res = spawnSync(NPM_CMD, ['install', '-g', '--prefix', mode.NPM_PREFIX, spec], {
-		stdio: 'inherit',
-		shell: IS_WIN,
-		env: npmEnv(),
-	});
+	const res = runNpm(['install', '-g', '--prefix', mode.NPM_PREFIX, spec]);
 	if (res.status !== 0) fail('npm no pudo instalar el paquete (ver el error de arriba).');
 
+	// Se anota con qué node se instaló: la app lo necesita para auto-actualizarse y no
+	// puede contar con que el PATH de la sesión gráfica tenga uno.
+	if (mode.rememberNodeBinary(process.execPath)) {
+		step(`node para las actualizaciones: ${process.execPath}`);
+	}
+
 	if (!fs.existsSync(mode.INSTALLED_PACKAGE_DIR)) {
 		fail(`npm terminó pero no encuentro ${mode.INSTALLED_PACKAGE_DIR}`);
 	}
@@ -439,6 +475,8 @@ function cmdInstall(args) {
 	if (!noPath) {
 		pathInfo = IS_WIN ? addToPathWindows() : addToPathUnix();
 		if (pathInfo.touched.length) step(`agregado al PATH en: ${pathInfo.touched.join(' ')}`);
+		const nodeDir = addNodeToPathWindows();
+		if (nodeDir) step(`agregado al PATH: ${nodeDir} (lo necesita el comando glassnote)`);
 	}
 
 	log('');
@@ -487,18 +525,26 @@ function cmdUpdate(args) {
 	const waitIdx = args.indexOf('--wait');
 	const waitMs = waitIdx !== -1 ? parseInt(args[waitIdx + 1], 10) || 0 : 0;
 	const relaunch = args.includes('--relaunch');
-	const positional = args.filter((a, i) => !a.startsWith('-') && i !== waitIdx + 1);
+	// Sin `--wait`, waitIdx es -1 y waitIdx+1 es 0: el filtro se comía el PRIMER
+	// posicional, así que `glassnote update 2.4.3` instalaba latest en vez de 2.4.3.
+	const positional = args.filter(
+		(a, i) => !a.startsWith('-') && !(waitIdx !== -1 && i === waitIdx + 1)
+	);
 	const version = positional[0] || 'latest';
 
 	if (waitMs > 0) sleepSync(waitMs);
 
+	// El cwd no puede estar dentro de lo que npm va a borrar: en Windows un directorio
+	// que es el cwd de un proceso vivo no se puede eliminar, y ese proceso es este.
+	try {
+		process.chdir(os.tmpdir());
+	} catch (error) {
+		/* si no se puede, npm igual lo intenta */
+	}
+
 	const spec = toSpec(version);
 	log(`glassnote — actualizando a ${spec}`);
-	const res = spawnSync(NPM_CMD, ['install', '-g', '--prefix', mode.NPM_PREFIX, spec], {
-		stdio: 'inherit',
-		shell: IS_WIN,
-		env: npmEnv(),
-	});
+	const res = runNpm(['install', '-g', '--prefix', mode.NPM_PREFIX, spec]);
 	if (res.status !== 0) {
 		recordarFalloDeUpdate(version, `npm salió con ${res.status}`);
 		if (relaunch) {
@@ -511,6 +557,10 @@ function cmdUpdate(args) {
 	}
 
 	olvidarFalloDeUpdate();
+	// Igual que en install: si esta actualización la corrió un node de fuera del paquete,
+	// se anota para la siguiente. Los clientes instalados antes de que esto existiera no
+	// tienen el archivo, y el primer update es su oportunidad de conseguirlo.
+	mode.rememberNodeBinary(process.execPath);
 	// 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();
@@ -617,6 +667,11 @@ function cmdStatus() {
 	log(`  home:            ${mode.HOME_DIR}`);
 	log(`  datos:           ${userDataDir()}`);
 	log(`  autoarranque:    ${autoStartOn}`);
+	// Sin un node fuera del paquete no hay auto-actualización posible: es lo primero que
+	// hay que mirar cuando un cliente se queda clavado en una versión vieja.
+	const nodeBinary = mode.resolveNodeBinary(process.execPath);
+	log(`  node de update:  ${nodeBinary || 'NO ENCONTRADO (la auto-actualización va a fallar)'}`);
+	log(`  npm de update:   ${mode.resolveNpmCli(nodeBinary) || `shim del PATH (${NPM_CMD})`}`);
 	if (process.platform === 'linux') {
 		let sandboxState = 'sin electron';
 		try {

package/npmMode.js

@@ -115,6 +115,116 @@ function sandboxFlags(electronBinary) {
 	return ['--no-sandbox'];
 }
 
+// ── Encontrar un node "de verdad" ──────────────────────────────────────────────────
+//
+// La auto-actualización lanza un ayudante que corre `npm install -g`, y ese ayudante NO
+// puede ser el electron del propio paquete: npm reemplaza justamente ese árbol y en
+// Windows un ejecutable en marcha está BLOQUEADO, así que npm moría con EPERM y la
+// actualización no se aplicaba nunca. (En Linux/macOS borrar un binario en uso sí
+// funciona: por eso el fallo solo se veía en Windows.) Hace falta un node de fuera.
+//
+// Tampoco vale confiar en el PATH para encontrar `npm`: en Windows el instalador puede
+// bajarse un Node a ~/.glassnote y solo lo mete al PATH de ESA sesión de PowerShell. La
+// app la arranca el autoarranque, con otro entorno, y ahí `npm` no existe. Por eso se
+// busca el binario en disco, se recuerda cuál se usó al instalar, y a npm se lo invoca
+// por su npm-cli.js en vez de por el shim.
+const NODE_EXE = process.platform === 'win32' ? 'node.exe' : 'node';
+const NODE_PATH_FILE = path.join(HOME_DIR, 'node-path');
+
+function esArchivo(p) {
+	try {
+		return !!p && fs.statSync(p).isFile();
+	} catch (error) {
+		return false;
+	}
+}
+
+function usableNode(p) {
+	if (!p) return false;
+	if (path.basename(p).toLowerCase() !== NODE_EXE) return false;
+	if (!esArchivo(p)) return false;
+	// Lo que esté dentro del paquete es lo que npm va a reemplazar: no sirve.
+	if (isInside(p, INSTALLED_PACKAGE_DIR)) return false;
+	if (isInside(p, PACKAGE_ROOT)) return false;
+	return true;
+}
+
+function readNodePathFile() {
+	try {
+		return fs.readFileSync(NODE_PATH_FILE, 'utf8').trim() || null;
+	} catch (error) {
+		return null;
+	}
+}
+
+// El CLI deja constancia del node con el que se instaló: es el único que se sabe seguro
+// que existe en esta máquina, aunque no esté en el PATH de la sesión gráfica.
+function rememberNodeBinary(binary) {
+	try {
+		if (!usableNode(binary)) return false;
+		fs.mkdirSync(HOME_DIR, { recursive: true });
+		fs.writeFileSync(NODE_PATH_FILE, realpath(binary), 'utf8');
+		return true;
+	} catch (error) {
+		return false;
+	}
+}
+
+// install.sh e install.ps1 desempacan el tarball oficial en ~/.glassnote/node-vX.Y.Z-...
+function nodesBootstrapeados() {
+	const out = [];
+	try {
+		for (const entry of fs.readdirSync(HOME_DIR)) {
+			if (!entry.startsWith('node-v')) continue;
+			out.push(path.join(HOME_DIR, entry, NODE_EXE)); // zip de windows
+			out.push(path.join(HOME_DIR, entry, 'bin', NODE_EXE)); // tarball unix
+		}
+	} catch (error) {
+		/* ~/.glassnote puede no existir todavía */
+	}
+	return out;
+}
+
+function nodesEnPath() {
+	return String(process.env.PATH || '')
+		.split(path.delimiter)
+		.filter(Boolean)
+		.map((dir) => path.join(dir, NODE_EXE));
+}
+
+// `preferido` es el ejecutable actual: cuando el CLI corre bajo node (npx, el ayudante)
+// ese es el candidato correcto. Cuando corre bajo electron queda descartado solo, por
+// estar dentro del paquete.
+function resolveNodeBinary(preferido) {
+	const candidatos = [
+		process.env.GLASSNOTE_NODE,
+		preferido,
+		readNodePathFile(),
+		path.join(BIN_DIR, NODE_EXE),
+	]
+		.concat(nodesBootstrapeados())
+		.concat(nodesEnPath());
+	for (const candidato of candidatos) {
+		if (usableNode(candidato)) return realpath(candidato);
+	}
+	return null;
+}
+
+// npm-cli.js siempre viaja al lado del node que lo trae; el shim del PATH, no.
+function resolveNpmCli(nodeBinary) {
+	if (!nodeBinary) return null;
+	const dir = path.dirname(nodeBinary);
+	const candidatos = [
+		path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'), // zip de windows
+		path.join(dir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'), // tarball unix / node del sistema
+		path.join(dir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+	];
+	for (const candidato of candidatos) {
+		if (esArchivo(candidato)) return path.normalize(candidato);
+	}
+	return null;
+}
+
 const isNpmMode = () => detect() === 'npm-global' || detect() === 'npx';
 const isEphemeral = () => detect() === 'npx';
 const isGlobalInstall = () => detect() === 'npm-global';
@@ -132,6 +242,10 @@ module.exports = {
 	sandboxIsSetuidRoot,
 	chromeSandboxPath,
 	userNamespacesUsable,
+	resolveNodeBinary,
+	resolveNpmCli,
+	rememberNodeBinary,
+	NODE_PATH_FILE,
 	isNpmMode,
 	isEphemeral,
 	isGlobalInstall,

package/npmUpdate.js

@@ -7,8 +7,14 @@
 // se está ejecutando está bloqueado y npm no puede reemplazarlo. Se lanza un ayudante
 // 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.
+//
+// El ayudante corre con un node de FUERA del paquete (npmMode.resolveNodeBinary). Antes
+// se lanzaba con el propio electron en modo node, que vive dentro del árbol que npm va a
+// reemplazar: en Windows eso lo mantenía bloqueado y el update fallaba siempre.
 const https = require('https');
+const http = require('http');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawn } = require('child_process');
 
@@ -18,7 +24,7 @@ const packageJson = require('./package.json');
 
 const REGISTRY = process.env.GLASSNOTE_REGISTRY || 'https://registry.npmjs.org';
 const CHECK_DELAY_MS = 5000;
-const CHECK_INTERVAL_MS = 3 * 60 * 60 * 1000; // cada 3 horas, como el updater viejo
+const CHECK_INTERVAL_MS = 60 * 60 * 1000; // cada hora
 
 class NpmUpdate {
 	constructor() {
@@ -48,8 +54,12 @@ class NpmUpdate {
 	}
 
 	getJson(url) {
+		// El módulo va por protocolo: con `https` fijo, un GLASSNOTE_REGISTRY en http
+		// —el registry local de scripts/local-registry.js— moría en ERR_INVALID_PROTOCOL
+		// y la variable no servía para probar el auto-update.
+		const client = String(url).startsWith('http://') ? http : https;
 		return new Promise((resolve) => {
-			const req = https.get(url, { headers: { accept: 'application/json' } }, (res) => {
+			const req = client.get(url, { headers: { accept: 'application/json' } }, (res) => {
 				if (res.statusCode !== 200) {
 					res.resume();
 					console.error(`[update] HTTP ${res.statusCode} en ${url}`);
@@ -130,13 +140,27 @@ class NpmUpdate {
 		console.log(`[update] ${this.currentVersion} → ${version}: actualizando y reiniciando`);
 
 		const cli = path.join(npmMode.PACKAGE_ROOT, 'bin', 'glassnote.js');
-		// electron sabe hacer de node con ELECTRON_RUN_AS_NODE: así el ayudante no
-		// depende de que haya un `node` en el PATH de la sesión gráfica.
+
+		// Un node de fuera del paquete es lo que hace que esto funcione en Windows: el
+		// ayudante no puede tener abierto ninguno de los archivos que npm va a borrar.
+		const nodeBinary = npmMode.resolveNodeBinary(process.execPath);
 		const env = Object.assign({}, process.env, {
-			ELECTRON_RUN_AS_NODE: '1',
 			GLASSNOTE_INSTALL_MODE: 'npm-global',
 			PATH: `${npmMode.BIN_DIR}${path.delimiter}${process.env.PATH || ''}`,
 		});
+		if (nodeBinary) {
+			delete env.ELECTRON_RUN_AS_NODE;
+			console.log(`[update] ayudante: ${nodeBinary}`);
+		} 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
+			// que npm no pueda y falle. Queda dicho en el log para que se vea por qué.
+			env.ELECTRON_RUN_AS_NODE = '1';
+			console.error(
+				'[update] no encuentro un node fuera del paquete; uso electron como node ' +
+					'(en Windows esto suele hacer fallar la actualización)'
+			);
+		}
 
 		// 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
@@ -150,10 +174,12 @@ class NpmUpdate {
 		}
 
 		try {
+			// cwd fuera del paquete: en Windows no se puede borrar un directorio que es
+			// el cwd de un proceso vivo, y ese proceso sería justamente el actualizador.
 			const child = spawn(
-				process.execPath,
+				nodeBinary || process.execPath,
 				[cli, 'update', version, '--relaunch', '--wait', '4000'],
-				{ detached: true, stdio: ['ignore', salida, salida], env }
+				{ detached: true, stdio: ['ignore', salida, salida], env, cwd: os.tmpdir() }
 			);
 			child.unref();
 		} catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {