@glassnote/client 2.4.9 → 2.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.9",
+  "version": "2.4.10",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -32,6 +32,7 @@
     "rendererPaths.js",
     "npmMode.js",
     "npmUpdate.js",
+    "versionReport.js",
     "localserver.js",
     "logUtilities.js",
     "userData.js",

package/versionReport.js

@@ -0,0 +1,156 @@
+// El cliente le dice a la API qué versión corre, y se lleva de vuelta la que debería
+// correr. Un solo viaje para las dos cosas.
+//
+// Por qué hace falta: hasta ahora la API no sabía la versión de ningún equipo. Un cliente
+// que no se actualiza se ve exactamente igual que uno al día, y por eso la
+// auto-actualización pudo estar rota en Windows durante meses sin que nadie lo notara.
+//
+// Y de paso cierra `desiredVersion`, que estaba muerto: la API lo tiene en la base y lo
+// empuja por websocket, pero el renderer nunca lo guardó, así que fijar la versión de un
+// equipo no hacía nada. Viniendo en la respuesta de este reporte, se cierra el circuito
+// sin tocar el renderer —cuyo código, además, no vive en este repo—.
+const http = require('http');
+const https = require('https');
+
+const userData = require('./userData');
+const packageJson = require('./package.json');
+
+const DELAY_MS = 15000; // después del arranque, sin competir con la carga del renderer
+const INTERVALO_MS = 6 * 60 * 60 * 1000;
+const TIMEOUT_MS = 10000;
+
+class VersionReport {
+	constructor() {
+		this.timer = null;
+	}
+
+	start() {
+		setTimeout(() => this.reportar(), DELAY_MS);
+		this.timer = setInterval(() => this.reportar(), INTERVALO_MS);
+	}
+
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+
+	// Los servidores se guardan como URLs de websocket (ws://, wss://). La API HTTP vive
+	// en el mismo origen, así que basta con quedarse con el origen y cambiar el esquema.
+	origenes() {
+		let servers = [];
+		try {
+			servers = userData.get('servers') || [];
+		} catch (error) {
+			return [];
+		}
+		if (!Array.isArray(servers)) return [];
+
+		const vistos = new Set();
+		for (const server of servers) {
+			if (typeof server !== 'string' || !server.trim()) continue;
+			try {
+				const url = new URL(server.trim());
+				const esquema = url.protocol === 'wss:' || url.protocol === 'https:' ? 'https:' : 'http:';
+				vistos.add(`${esquema}//${url.host}`);
+			} catch (error) {
+				/* una entrada mal formada no puede tumbar al resto */
+			}
+		}
+		return Array.from(vistos);
+	}
+
+	post(origen, cuerpo) {
+		return new Promise((resolve) => {
+			let url;
+			try {
+				url = new URL('/devices/report-version', origen);
+			} catch (error) {
+				return resolve(null);
+			}
+			const datos = Buffer.from(JSON.stringify(cuerpo));
+			const cliente = url.protocol === 'https:' ? https : http;
+			const req = cliente.request(
+				url,
+				{
+					method: 'POST',
+					headers: {
+						'content-type': 'application/json',
+						'content-length': datos.length,
+					},
+				},
+				(res) => {
+					let body = '';
+					res.setEncoding('utf8');
+					res.on('data', (chunk) => (body += chunk));
+					res.on('end', () => {
+						if (res.statusCode < 200 || res.statusCode >= 300) {
+							console.warn(`[version] ${origen} respondió ${res.statusCode}`);
+							return resolve(null);
+						}
+						try {
+							resolve(JSON.parse(body));
+						} catch (error) {
+							resolve(null);
+						}
+					});
+				}
+			);
+			req.setTimeout(TIMEOUT_MS, () => {
+				req.destroy();
+				resolve(null);
+			});
+			// Un equipo sin red, o con la API caída, es lo normal en este parque: se
+			// registra en el log y se reintenta en el ciclo siguiente. Nunca rompe la app.
+			req.on('error', (error) => {
+				console.warn(`[version] no se pudo reportar a ${origen}: ${error.message}`);
+				resolve(null);
+			});
+			req.end(datos);
+		});
+	}
+
+	async reportar() {
+		let uuid;
+		try {
+			uuid = userData.getUUID();
+		} catch (error) {
+			return;
+		}
+		const origenes = this.origenes();
+		if (origenes.length === 0) return;
+
+		const cuerpo = { uuid, version: packageJson.version };
+		for (const origen of origenes) {
+			const respuesta = await this.post(origen, cuerpo);
+			if (respuesta && typeof respuesta.desiredVersion === 'string') {
+				this.guardarDesiredVersion(respuesta.desiredVersion);
+				// Con el primer servidor que conteste alcanza: todos miran la misma base.
+				return;
+			}
+		}
+	}
+
+	// Se escribe solo si cambió: userData reescribe el archivo entero en cada set.
+	guardarDesiredVersion(valor) {
+		const limpio = valor.trim();
+		// Acotado a lo que el updater sabe interpretar. Cualquier otra cosa se ignora en
+		// vez de guardarse: un valor raro acá deja al equipo sin actualizarse y sin decir
+		// por qué, que es exactamente el fallo del que venimos.
+		const aceptable = limpio === 'lastest' || limpio === 'latest' || /^\d+\.\d+\.\d+/.test(limpio);
+		if (!aceptable) {
+			console.warn(`[version] desiredVersion ignorado por ilegible: ${JSON.stringify(limpio)}`);
+			return;
+		}
+		try {
+			if (userData.get('desiredVersion') === limpio) return;
+			console.log(`[version] desiredVersion: ${limpio}`);
+			userData.set('desiredVersion', limpio);
+		} catch (error) {
+			console.error('[version] no se pudo guardar desiredVersion:', error.message);
+		}
+	}
+}
+
+module.exports = VersionReport;