@glassnote/client 2.4.10 → 2.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glassnote/client",
-  "version": "2.4.10",
+  "version": "2.4.12",
   "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
   "main": "main.js",
   "publishConfig": {
@@ -30,12 +30,14 @@
     "autoupdate.js",
     "autoupdate_renderer.js",
     "rendererPaths.js",
+    "linuxCursor.js",
     "npmMode.js",
     "npmUpdate.js",
     "versionReport.js",
     "localserver.js",
     "logUtilities.js",
     "userData.js",
+    "pairing.js",
     "INSTALACION.md",
     "README.md"
   ],
@@ -54,7 +56,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",
@@ -70,7 +74,7 @@
     "url": "git+ssh://git@intermarkec/intermarkec/glassnote-electron.git"
   },
   "dependencies": {
-    "@glassnote/renderer": "2.0.9",
+    "@glassnote/renderer": "2.0.11",
     "cors": "^2.8.5",
     "electron": "^29.4.6",
     "express": "^4.18.2",

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/rendererPaths.js

@@ -10,6 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const userData = require('./userData');
 
 // 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
@@ -59,4 +60,59 @@ function compareRendererVersions(a, b) {
 	return 0;
 }
 
-module.exports = { baselineRendererDir, rendererVersionFrom, compareRendererVersions };
+// Cual de los dos renderers se usa de verdad, con el mismo criterio para el que lo carga
+// y para el que solo quiere mostrar la version. Si fueran dos calculos, el numero del menu
+// terminaria mintiendo el dia que uno de los dos cambie.
+//
+//   - userData: lo que bajo el auto-update de S3. Es el canal EN CALIENTE: una version
+//     nueva llega ahi sin republicar el cliente ni tocar el binario.
+//   - baseline: el renderer que viaja con la instalacion, lo que ve un equipo recien
+//     instalado antes de su primer update en caliente.
+//
+// Gana la version mas alta venga de donde venga; si empatan gana userData. Pero una
+// fuente sin HTML no se puede cargar, asi que en ese caso se cae a la otra: la version
+// que se informa es la que de verdad esta corriendo, no la que gano la comparacion.
+function resolverRenderer() {
+	const fuentes = [
+		{
+			nombre: 'userData',
+			dir: path.join(userData.getUserDataDir(), 'renderer'),
+			htmls: ['glassnote.html'], // userData siempre usa glassnote.html
+		},
+		{
+			nombre: 'baseline',
+			dir: baselineRendererDir(),
+			htmls: ['glassnote.html', 'index.html'],
+		},
+	].map((fuente) => {
+		let htmlPath = null;
+		for (const archivo of fuente.htmls) {
+			const posible = path.join(fuente.dir, archivo);
+			if (fs.existsSync(posible)) {
+				htmlPath = posible;
+				break;
+			}
+		}
+		return { ...fuente, version: rendererVersionFrom(fuente.dir), htmlPath };
+	});
+
+	const [enCaliente, baseline] = fuentes;
+	const gana = compareRendererVersions(enCaliente.version, baseline.version) < 0 ? baseline : enCaliente;
+	const otra = gana === enCaliente ? baseline : enCaliente;
+
+	return { elegida: gana.htmlPath ? gana : otra.htmlPath ? otra : null, fuentes };
+}
+
+// La version del renderer que esta corriendo, o null si no hay ninguno cargable.
+function rendererVersionActiva() {
+	const { elegida } = resolverRenderer();
+	return elegida ? elegida.version : null;
+}
+
+module.exports = {
+	baselineRendererDir,
+	rendererVersionFrom,
+	compareRendererVersions,
+	resolverRenderer,
+	rendererVersionActiva,
+};