@glassnote/client 2.4.9 → 2.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.9",
+  "version": "2.4.11",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -32,9 +32,11 @@
     "rendererPaths.js",
     "npmMode.js",
     "npmUpdate.js",
+    "versionReport.js",
     "localserver.js",
     "logUtilities.js",
     "userData.js",
+    "pairing.js",
     "INSTALACION.md",
     "README.md"
   ],
@@ -53,7 +55,9 @@
     "prepublishOnly": "node scripts/check-publish.js",
     "start-electron": "electron .",
     "test-update": "node scripts/test-update.js",
-    "test": "node scripts/test-update.js"
+    "test-pairing": "node scripts/test-pairing.js",
+    "test-cli": "node scripts/test-cli.js",
+    "test": "node scripts/test-cli.js && node scripts/test-pairing.js && node scripts/test-update.js"
   },
   "keywords": [
     "glassnote",

package/pairing.js

@@ -0,0 +1,338 @@
+// Emparejamiento desatendido: el equipo se da de alta solo con la API key de la
+// organizacion, sin que nadie mire la pantalla.
+//
+// El emparejamiento de siempre es a dos manos: el cliente muestra un keycode y una
+// persona lo escribe en la web. Para un equipo esta bien. Para trescientos —una cadena
+// que abre locales, un parque que se reinstala entero— no es un flujo, es una tarde
+// entera y un error de tipeo cada veinte equipos. Aca el instalador ya trae la API key
+// de la organizacion, asi que el propio cliente pide su alta a la API y se guarda el
+// token con el que se conecta. La instalacion termina con el equipo ya en el tablero.
+//
+// Vive fuera de bin/glassnote.js a proposito: decidir QUE se le pide a la API es una
+// funcion pura y se puede comprobar en cualquier maquina; hacerlo de verdad, no.
+'use strict';
+
+const os = require('os');
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const API_URL_POR_DEFECTO = 'https://glassnoteapi.intermark.ec';
+const TIMEOUT_MS = 20000;
+
+// Un solo sitio donde vive la correspondencia bandera <-> variable de entorno. Las
+// variables existen porque un despliegue por GPO o por MDM muchas veces no puede pasar
+// argumentos, pero si puede poner entorno.
+const OPCIONES = [
+	{ clave: 'orgId', banderas: ['--org-id', '--organization-id'], env: 'GLASSNOTE_ORG_ID' },
+	{ clave: 'apiKey', banderas: ['--api-key', '--apikey'], env: 'GLASSNOTE_API_KEY' },
+	{ clave: 'deviceName', banderas: ['--device-name', '--name'], env: 'GLASSNOTE_DEVICE_NAME' },
+	{ clave: 'userName', banderas: ['--user-name', '--owner-name', '--owner'], env: 'GLASSNOTE_USER_NAME' },
+	{ clave: 'apiUrl', banderas: ['--api-url'], env: 'GLASSNOTE_API_URL' },
+	{ clave: 'wsUrl', banderas: ['--ws-url', '--server'], env: 'GLASSNOTE_WS_URL' },
+];
+
+// Acepta `--org-id 55` y `--org-id=55`: los dos aparecen en los scripts de despliegue que
+// escribe la gente, y fallar por la forma del signo igual es una perdida de tiempo.
+function leerOpciones(args, env) {
+	const argv = Array.isArray(args) ? args : [];
+	const entorno = env || {};
+	const opciones = {};
+
+	for (const { clave, banderas, env: nombreEnv } of OPCIONES) {
+		let valor;
+		for (let i = 0; i < argv.length; i++) {
+			const a = argv[i];
+			const conIgual = banderas.find((b) => a.startsWith(`${b}=`));
+			if (conIgual) {
+				valor = a.slice(conIgual.length + 1);
+				continue;
+			}
+			if (banderas.includes(a) && i + 1 < argv.length && !argv[i + 1].startsWith('-')) {
+				valor = argv[i + 1];
+			}
+		}
+		if (valor === undefined && entorno[nombreEnv]) valor = entorno[nombreEnv];
+		if (valor !== undefined) opciones[clave] = String(valor).trim();
+	}
+
+	return opciones;
+}
+
+// ¿Pidieron emparejar? Basta con que venga la API key: sin ella no hay nada que hacer, y
+// con ella el resto tiene valores por defecto razonables.
+function pidenEmparejar(opciones) {
+	return !!(opciones && opciones.apiKey);
+}
+
+// El nombre por defecto es el del equipo, no uno generico. En un despliegue masivo el
+// mismo comando corre en todas las maquinas: si el nombre no sale del propio equipo, el
+// tablero termina con trescientos "Unnamed Device" y hay que renombrarlos a mano, que es
+// justo el trabajo que esto viene a evitar.
+function nombrePorDefecto() {
+	try {
+		return os.hostname();
+	} catch (error) {
+		return '';
+	}
+}
+
+function usuarioPorDefecto() {
+	try {
+		return os.userInfo().username;
+	} catch (error) {
+		return '';
+	}
+}
+
+function ipsLocales() {
+	const ips = [];
+	try {
+		const interfaces = os.networkInterfaces();
+		for (const nombre of Object.keys(interfaces)) {
+			for (const iface of interfaces[nombre] || []) {
+				if (!iface.internal && iface.address) ips.push(iface.address);
+			}
+		}
+	} catch (error) {
+		/* sin red que enumerar: se manda vacio */
+	}
+	return ips;
+}
+
+// Lo que se le manda a POST /devices/enroll. Separado del envio para poder comprobarlo.
+function cuerpoDeAlta(opciones, uuid) {
+	return {
+		organizationId: opciones.orgId,
+		uuid,
+		name: opciones.deviceName || nombrePorDefecto() || uuid,
+		ownerName: opciones.userName || usuarioPorDefecto() || undefined,
+		os: process.platform,
+		localIps: JSON.stringify(ipsLocales()),
+	};
+}
+
+function urlDeAlta(opciones) {
+	const base = (opciones.apiUrl || API_URL_POR_DEFECTO).replace(/\/+$/, '');
+	return `${base}/devices/enroll`;
+}
+
+function postJson(url, headers, cuerpo) {
+	return new Promise((resolve, reject) => {
+		let destino;
+		try {
+			destino = new URL(url);
+		} catch (error) {
+			return reject(new Error(`la URL de la API no es valida: ${url}`));
+		}
+
+		const datos = Buffer.from(JSON.stringify(cuerpo), 'utf8');
+		const transporte = destino.protocol === 'http:' ? http : https;
+		const req = transporte.request(
+			destino,
+			{
+				method: 'POST',
+				headers: Object.assign(
+					{
+						'content-type': 'application/json',
+						'content-length': datos.length,
+					},
+					headers
+				),
+			},
+			(res) => {
+				const trozos = [];
+				res.on('data', (t) => trozos.push(t));
+				res.on('end', () => {
+					const texto = Buffer.concat(trozos).toString('utf8');
+					let json = null;
+					try {
+						json = JSON.parse(texto);
+					} catch (error) {
+						/* la API contesto algo que no es JSON; se conserva el texto */
+					}
+					resolve({ status: res.statusCode, json, texto });
+				});
+			}
+		);
+
+		req.setTimeout(TIMEOUT_MS, () => {
+			req.destroy(new Error(`la API no contesto en ${TIMEOUT_MS / 1000} segundos`));
+		});
+		req.on('error', reject);
+		req.end(datos);
+	});
+}
+
+// La API contesta el error dentro del JSON y `message` puede ser texto o lista (las
+// validaciones de Nest vienen en lista). Un instalador que dice "fallo con 403" y nada
+// mas obliga a abrir el codigo; se saca el motivo de donde este.
+function motivoDelError(respuesta) {
+	const m = respuesta.json && respuesta.json.message;
+	let motivo = '';
+	if (Array.isArray(m)) motivo = m.join('; ');
+	else if (typeof m === 'string') motivo = m;
+
+	// Cuando el guard rechaza la clave, Nest contesta su "Forbidden resource" generico,
+	// que no le dice nada a quien esta desplegando. El unico motivo posible aca es la
+	// clave, asi que se dice cual es.
+	if (respuesta.status === 401 || (respuesta.status === 403 && /forbidden resource/i.test(motivo))) {
+		return 'la API key no es valida o ya expiro';
+	}
+
+	if (motivo) return motivo;
+	if (respuesta.texto) return respuesta.texto.slice(0, 300);
+	return `la API contesto ${respuesta.status}`;
+}
+
+/**
+ * Da de alta el equipo y deja escrito en el archivo de usuario todo lo que la app
+ * necesita para conectarse sola en el primer arranque: el servidor y su token.
+ *
+ * `userData` entra por parametro y no por require: este archivo se carga desde el CLI,
+ * que corre tambien donde el arbol de dependencias esta a medias.
+ */
+async function emparejar(opciones, userData) {
+	if (!opciones.apiKey) throw new Error('falta la API key de la organizacion (--api-key)');
+	if (!opciones.orgId) throw new Error('falta el id de la organizacion (--org-id)');
+
+	const uuid = userData.deviceUUID();
+	const respuesta = await postJson(
+		urlDeAlta(opciones),
+		{ 'x-api-key': opciones.apiKey },
+		cuerpoDeAlta(opciones, uuid)
+	);
+
+	if (respuesta.status !== 200 && respuesta.status !== 201) {
+		throw new Error(motivoDelError(respuesta));
+	}
+
+	const datos = respuesta.json || {};
+	if (!datos.refreshToken) {
+		throw new Error('la API acepto el alta pero no devolvio token');
+	}
+
+	const server = servidorEfectivo(opciones, datos.server);
+	guardarAlta(userData, datos, server);
+
+	return {
+		uuid,
+		deviceId: datos.deviceId,
+		organizationId: datos.organizationId,
+		name: datos.name,
+		server,
+		servidorAnunciado: datos.server || '',
+		servidorForzado: !!opciones.wsUrl,
+		mismoOrigenQueLaApi: mismoOrigen(urlDeAlta(opciones), server),
+		yaEstaba: !!datos.alreadyEnrolled,
+	};
+}
+
+/**
+ * A que websocket se conecta el equipo.
+ *
+ * Normalmente lo decide la API, no el instalador: el token que acaba de emitir solo vale
+ * en SU websocket, asi que apuntar a otro sitio solo consigue un equipo dado de alta que
+ * no conecta. Por eso para hablar con otro servidor lo que se cambia es `--api-url`, y el
+ * websocket viene de vuelta solo.
+ *
+ * El override existe para el unico caso que eso no cubre: que la API anuncie una
+ * direccion a la que el equipo no llega —una IP de LAN detras de un NAT, un proxy inverso
+ * publicado con otro nombre, DNS partido—. Ahi el alta sale bien y los trescientos
+ * equipos guardan una URL muerta, sin ninguna senal en el momento de instalar. Lo
+ * correcto es arreglar WEBSOCKET_URL en la API; esto es la salida cuando no se puede.
+ */
+function servidorEfectivo(opciones, servidorDeLaApi) {
+	const forzado = (opciones.wsUrl || '').trim();
+	if (forzado) {
+		if (!/^wss?:\/\//i.test(forzado)) {
+			throw new Error(`--ws-url tiene que empezar por ws:// o wss:// (llego "${forzado}")`);
+		}
+		return forzado;
+	}
+	if (!servidorDeLaApi) {
+		throw new Error(
+			'la API no devolvio websocket (le falta WEBSOCKET_URL); se puede forzar con --ws-url'
+		);
+	}
+	return servidorDeLaApi;
+}
+
+// El cliente saca el origen HTTP de la API a partir de esta misma URL de websocket
+// (cambiandole el esquema), asi que cuando el host no coincide con el de --api-url hay
+// algo raro y conviene decirlo. No es un error: un despliegue puede separarlos a
+// proposito.
+function mismoOrigen(urlApi, urlWebsocket) {
+	try {
+		return new URL(urlApi).host === new URL(urlWebsocket).host;
+	} catch (error) {
+		return true; // si no se puede comparar, no se avisa de nada
+	}
+}
+
+// Se escribe exactamente lo mismo que dejaba el emparejamiento por keycode, y por las
+// mismas claves: para la app las dos altas son indistinguibles, asi que no hay un segundo
+// camino de conexion que mantener.
+function guardarAlta(userData, datos, servidor) {
+	// El servidor va aparte del resto de la respuesta porque puede venir forzado desde la
+	// linea de comandos. Y tiene que ser EL MISMO en las tres claves: la app busca el
+	// token por la URL con la que se conecta, asi que guardarlo bajo otra lo deja
+	// arrancando y sin sesion, que es un fallo mudo.
+	const server = servidor || datos.server;
+
+	const servers = userData.get('servers');
+	const lista = Array.isArray(servers) ? servers.slice() : [];
+	if (!lista.includes(server)) lista.push(server);
+	userData.set('servers', lista);
+
+	userData.set('refreshTokens', server, datos.refreshToken);
+	if (datos.refreshTokenHash) {
+		userData.set('refreshTokenHashes', server, datos.refreshTokenHash);
+	}
+
+	// El token de acceso viejo pertenece al alta anterior: si se queda, la app intenta
+	// conectarse con el antes que con el refresh nuevo y le rebota.
+	const accessTokens = userData.get('accessTokens');
+	if (accessTokens && typeof accessTokens === 'object' && accessTokens[server]) {
+		userData.remove('accessTokens', server);
+	}
+}
+
+// Todas las banderas de emparejamiento llevan valor. El CLI lo necesita para no
+// confundir ese valor con un argumento suelto: `install --org-id 55` no instala la
+// version "55".
+const BANDERAS_CON_VALOR = OPCIONES.reduce((todas, o) => todas.concat(o.banderas), []);
+
+// El primer argumento suelto, saltando banderas y los valores que se llevan. Sin esto,
+// `glassnote install --api-key abc` intentaba instalar la version "abc".
+function argumentoPosicional(args) {
+	const argv = Array.isArray(args) ? args : [];
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a.startsWith('-')) {
+			if (BANDERAS_CON_VALOR.includes(a)) i++; // el valor va aparte, se salta
+			continue;
+		}
+		return a;
+	}
+	return undefined;
+}
+
+module.exports = {
+	API_URL_POR_DEFECTO,
+	BANDERAS_CON_VALOR,
+	argumentoPosicional,
+	OPCIONES,
+	leerOpciones,
+	pidenEmparejar,
+	cuerpoDeAlta,
+	urlDeAlta,
+	motivoDelError,
+	guardarAlta,
+	servidorEfectivo,
+	mismoOrigen,
+	emparejar,
+	nombrePorDefecto,
+	usuarioPorDefecto,
+	ipsLocales,
+};

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;