@glassnote/client 2.4.10 → 2.4.12

package/INSTALACION.md

@@ -41,6 +41,7 @@ que es justo lo que hace `glassnote uninstall`.
 | `glassnote start --detach` | lo arranca y libera la terminal |
 | `glassnote install [version]` | instala o reinstala (`latest` por defecto) |
 | `glassnote update [version]` | actualiza a la última publicada |
+| `glassnote pair` | da de alta el equipo con la API key de la organización |
 | `glassnote uninstall` | quita autoarranque, `~/.glassnote` y la línea del rc |
 | `glassnote status` | versión, modo, rutas, autoarranque y estado del sandbox |
 | `glassnote fix-sandbox` | (Linux) restaura el sandbox de Chromium; pide sudo una vez |
@@ -48,6 +49,89 @@ que es justo lo que hace `glassnote uninstall`.
 Banderas de `install`: `--no-path` (no toca el rc, imprime la línea) y `--no-start`
 (instala y no arranca).
 
+## Alta masiva: emparejar sin que nadie mire la pantalla
+
+El emparejamiento normal es a dos manos: el cliente muestra un código y una persona lo
+escribe en la web. Para un equipo está bien. Para trescientos —una cadena que abre
+locales, un parque que se reinstala entero— es una tarde entera y un error de tipeo cada
+veinte equipos.
+
+Con la **API key de la organización**, el equipo se da de alta solo durante la
+instalación. La API contesta con el servidor y el token, el instalador los deja escritos
+donde la app los busca, y el cliente arranca ya conectado.
+
+```sh
+# Linux / macOS — ojo con el `-s --`, es lo que hace que sh le pase las banderas al script
+curl -fsSL https://glassnote.intermark.ec/install.sh | sh -s -- \
+  --org-id 55 --api-key <clave> --device-name "Caja 01" --user-name "Santiago"
+```
+
+```powershell
+# Windows
+& ([scriptblock]::Create((irm https://glassnote.intermark.ec/install.ps1))) `
+  -OrgId 55 -ApiKey <clave> -DeviceName 'Caja 01' -UserName 'Santiago'
+```
+
+| bandera | variable de entorno | por defecto |
+|---|---|---|
+| `--org-id` | `GLASSNOTE_ORG_ID` | — (obligatoria) |
+| `--api-key` | `GLASSNOTE_API_KEY` | — (obligatoria) |
+| `--device-name` | `GLASSNOTE_DEVICE_NAME` | el hostname del equipo |
+| `--user-name` | `GLASSNOTE_USER_NAME` | el usuario del sistema |
+| `--api-url` | `GLASSNOTE_API_URL` | `https://glassnoteapi.intermark.ec` |
+| `--ws-url` | `GLASSNOTE_WS_URL` | el que anuncie la API |
+
+Las variables de entorno existen porque un despliegue por GPO o por MDM muchas veces no
+puede pasar argumentos pero sí poner entorno.
+
+### Otro servidor
+
+**El websocket no se elige en el instalador: lo decide la API que atiende el alta.** El
+token que emite sólo vale en su propio websocket, así que apuntar a otro sitio no daría
+un equipo conectado a otro servidor, daría un equipo dado de alta que no conecta. Para
+instalar contra otra API se cambia `--api-url` y el websocket viene de vuelta en la
+respuesta:
+
+```sh
+curl -fsSL https://glassnote.intermark.ec/install.sh | sh -s -- \
+  --api-url https://api.otrocliente.com --org-id 12 --api-key <clave>
+```
+
+Esa URL de websocket es además de donde el cliente saca el origen HTTP de la API para
+reportar su versión, así que es **el único dato de servidor** que el equipo guarda.
+
+`--ws-url` cubre el único caso que lo anterior no: que la API anuncie una dirección a la
+que el equipo no llega —una IP de LAN detrás de un NAT, un proxy inverso publicado con
+otro nombre, DNS partido—. Ahí el alta sale bien y los equipos guardan una URL muerta sin
+ninguna señal en el momento de instalar. Por eso, cuando el host que anuncia la API no es
+el mismo al que se pidió el alta, el instalador lo dice en pantalla. **Lo correcto es
+arreglar `WEBSOCKET_URL` en la API**; `--ws-url` es la salida cuando no se puede.
+
+```sh
+glassnote pair --org-id 12 --api-key <clave> \
+  --api-url https://api.cliente.local --ws-url wss://glassnote.cliente.com/ws
+```
+
+**El nombre por defecto es el del propio equipo, no uno genérico.** Es lo que hace que el
+*mismo* comando sirva para todo el parque: sin eso, el tablero termina con trescientos
+"Unnamed Device" y hay que renombrarlos a mano, que es justo el trabajo que esto viene a
+evitar.
+
+La API key se saca en la web, en las claves de la organización. **Da de alta equipos en
+esa organización**: es un secreto de despliegue, no algo que se reparta. Caduca a los 30
+días, lo que acota lo que se puede hacer con una que se filtre.
+
+Un equipo ya instalado se empareja sin reinstalar:
+
+```sh
+glassnote pair --org-id 55 --api-key <clave> --device-name "Caja 01"
+```
+
+Si el alta falla, el comando **sale con código distinto de cero** y dice por qué (la
+clave no sirve, la organización no es la de esa clave, el plan llegó a su tope de
+equipos). El cliente queda instalado igual: se reintenta con `glassnote pair`. Emparejar
+dos veces el mismo equipo no lo duplica ni gasta un cupo extra; solo le renueva el token.
+
 `install` y `update` también aceptan un *spec* de npm en vez de una versión: un `.tgz`,
 una ruta local o una URL. Es lo que permite probar un paquete antes de publicarlo:
 

package/bin/glassnote.js

@@ -17,6 +17,7 @@ const os = require('os');
 const { spawn, spawnSync } = require('child_process');
 
 const mode = require('../npmMode');
+const pairing = require('../pairing');
 const pkg = require('../package.json');
 
 const IS_WIN = process.platform === 'win32';
@@ -140,6 +141,78 @@ function esperarAQueCierre(maxMs) {
 	return false;
 }
 
+// Windows no deja reemplazar los archivos de un proceso vivo. Reinstalar encima del
+// cliente abierto muere con «EBUSY: resource busy or locked, rename ...\electron\dist\
+// icudtl.dat», y muere A MITAD: npm ya apartó parte del árbol viejo, así que la
+// instalación que había queda rota además de no haber instalado la nueva. Es el fallo
+// que se lleva puesto a cualquiera que corra el `irm | iex` una segunda vez, que es
+// justo lo que se le pide a la gente para actualizar.
+//
+// Se cierra por RUTA del ejecutable, nunca por nombre: "electron.exe" es también el
+// VS Code y el Slack de quien esté delante, y cerrarle eso para instalar esto sería
+// bastante peor que el fallo que se viene a arreglar. Sólo se toca lo que vive dentro
+// de ~/.glassnote, que es nuestro por definición.
+// El guion de PowerShell, aparte: decidir QUE se le pide al sistema es una funcion pura
+// y se puede comprobar desde cualquier maquina; matar procesos de verdad, no. Y la parte
+// que mas silenciosamente se rompe es justo esta, el entrecomillado de la ruta.
+//
+// Comillas SIMPLES de PowerShell: son literales y no interpretan la barra invertida. Con
+// comillas dobles habria que escapar, y una ruta escapada a la manera de JSON le llega a
+// PowerShell con las barras duplicadas y no coincide con nada: el filtro no encontraria
+// un solo proceso y el EBUSY volveria, mudo.
+//
+// El filtro apunta a `<home>\npm\node_modules`, NO a `<home>` entero. La diferencia no es
+// cosmetica: cuando el equipo no tenia Node, el instalador se baja el suyo a
+// `<home>\node-v20.18.1-win-x64\node.exe` —que es el caso normal en Windows— y ese
+// node.exe es el que esta ejecutando ESTE codigo. Filtrando por `<home>` el instalador se
+// mataba a si mismo a mitad, salia con codigo -1 y no instalaba nada. Se vio en la VM de
+// Windows el 2026-09-07; en Linux no pasa porque alli no hay nada que cerrar.
+//
+// Se excluye ademas el pid propio, por si algun dia el CLI viviera dentro de esa carpeta.
+// Donde viven los binarios del cliente YA INSTALADO. Es lo unico que npm va a
+// reemplazar, y por tanto lo unico que hay que cerrar.
+function rutaDelClienteInstalado() {
+	return path.join(mode.NPM_PREFIX, 'node_modules');
+}
+
+function guionCerrarCliente(raizDir, pidPropio) {
+	const raiz = `'${String(raizDir).replace(/'/g, "''")}'`;
+	const pid = Number(pidPropio) || 0;
+	return [
+		`$raiz = ${raiz}`,
+		`$yo = ${pid}`,
+		'$procs = @(Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $yo -and $_.ExecutablePath -and $_.ExecutablePath.StartsWith($raiz, [System.StringComparison]::OrdinalIgnoreCase) })',
+		'$procs | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }',
+		'Write-Output $procs.Count',
+	].join('; ');
+}
+
+function cerrarClienteWindows() {
+	if (!IS_WIN) return true; // en POSIX se puede reemplazar un archivo abierto
+
+	const res = spawnSync(
+		'powershell.exe',
+		['-NoProfile', '-NonInteractive', '-Command', guionCerrarCliente(rutaDelClienteInstalado(), process.pid)],
+		{ encoding: 'utf8', timeout: 20000 }
+	);
+
+	// Si PowerShell no está o falló, no se sigue a ciegas: se mira si el cliente
+	// contesta, que es la señal barata de que sigue vivo.
+	if (res.error || res.status !== 0) {
+		if (!clienteEnMarcha()) return true;
+		console.error('glassnote: no pude cerrar el cliente automáticamente.');
+		return false;
+	}
+
+	const cerrados = parseInt(String(res.stdout || '').trim(), 10) || 0;
+	if (cerrados === 0) return true;
+
+	step(`el cliente estaba abierto: cerrados ${cerrados} procesos suyos`);
+	// El proceso desaparece de la lista antes de que el SO suelte los handles de sus
+	// archivos, y npm necesita los handles, no la lista.
+	return esperarAQueCierre(15000);
+}
+
 const log = (...args) => console.log(...args);
 // Cada paso se dice EN CUANTO EMPIEZA: lo que hace que un instalador parezca colgado
 // no es que tarde, es que tarde sin decir en qué está.
@@ -464,16 +537,29 @@ function borrarAppMac() {
 	}
 }
 
-function cmdInstall(args) {
-	const version = args.find((a) => !a.startsWith('-')) || 'latest';
+async function cmdInstall(args) {
+	// El argumento suelto es la version, pero las banderas de emparejamiento traen valor
+	// propio: sin saltarlo, `install --api-key abc` intentaba instalar la version "abc".
+	const version = pairing.argumentoPosicional(args) || 'latest';
 	const noPath = args.includes('--no-path');
 	const noStart = args.includes('--no-start');
+	const emparejamiento = pairing.leerOpciones(args, process.env);
 
 	const spec = toSpec(version);
 	log(`glassnote — instalando ${spec}`);
 	fs.mkdirSync(mode.NPM_PREFIX, { recursive: true });
 	fs.mkdirSync(mode.BIN_DIR, { recursive: true });
 
+	// ANTES de que npm mueva un solo archivo: si el cliente está abierto, npm apartaría
+	// el árbol viejo a medias y dejaría rota la instalación que ya funcionaba.
+	if (!cerrarClienteWindows()) {
+		fail(
+			'el cliente sigue abierto y Windows no deja reemplazar sus archivos.\n' +
+				'  Cerralo desde el ícono de la bandeja (clic derecho → Salir) y volvé a correr esto.\n' +
+				'  No se tocó nada: la instalación que tenías sigue como estaba.'
+		);
+	}
+
 	// 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)`);
@@ -530,6 +616,14 @@ function cmdInstall(args) {
 	log('Para actualizar más adelante: glassnote update (o correr esto mismo otra vez).');
 	log('');
 
+	// Antes de arrancar: si la instalacion trae credenciales de organizacion, el equipo se
+	// da de alta ahora. Arrancarlo primero solo consigue que aparezca la pantalla del
+	// keycode un instante antes de quedar emparejado igual.
+	if (pairing.pidenEmparejar(emparejamiento)) {
+		const codigo = await emparejar(emparejamiento, { reciénInstalado: true });
+		if (codigo !== 0) return codigo;
+	}
+
 	if (noStart) {
 		log('Arrancalo cuando quieras:  glassnote');
 		return 0;
@@ -549,6 +643,66 @@ function cmdInstall(args) {
 	return 0;
 }
 
+// Alta desatendida contra la API. Devuelve codigo de salida y no lanza: un despliegue
+// masivo se guia por el codigo, no por lo que aparezca en pantalla.
+async function emparejar(opciones, { reciénInstalado = false } = {}) {
+	const userData = conUserData((u) => u);
+	if (!userData) {
+		console.error('glassnote: no pude leer los datos de usuario para emparejar.');
+		return 1;
+	}
+
+	step(`dando de alta el equipo en la organizacion ${opciones.orgId || '(sin id)'}`);
+
+	try {
+		const alta = await pairing.emparejar(opciones, userData);
+		log('');
+		log(
+			alta.yaEstaba
+				? 'El equipo ya estaba en la organizacion; se le renovo el token.'
+				: 'Equipo dado de alta.'
+		);
+		log(`  nombre:       ${alta.name}`);
+		log(`  organizacion: ${alta.organizationId}`);
+		log(`  servidor:     ${alta.server}${alta.servidorForzado ? ' (forzado con --ws-url)' : ''}`);
+		log(`  uuid:         ${alta.uuid}`);
+		log('');
+		// El equipo va a hablar SOLO con este websocket, y de él saca también el origen
+		// HTTP de la API. Si no es el mismo host al que se acaba de pedir el alta, la API
+		// está anunciando otra dirección: puede ser a propósito, o puede ser un
+		// WEBSOCKET_URL mal puesto que deja al parque entero conectando a la nada. Se
+		// dice acá, que es el único momento en que alguien está mirando.
+		if (!alta.mismoOrigenQueLaApi) {
+			log(`Ojo: la API contestó que el equipo se conecte a ${alta.servidorAnunciado || alta.server},`);
+			log('que no es el host al que le pediste el alta. Si el equipo no llega ahí, se');
+			log('arregla WEBSOCKET_URL en la API, o se fuerza acá con --ws-url.');
+			log('');
+		}
+		return 0;
+	} catch (error) {
+		console.error('');
+		console.error(`glassnote: no se pudo dar de alta el equipo: ${error.message}`);
+		if (reciénInstalado) {
+			console.error('El cliente quedó instalado igual. Cuando esto se resuelva:');
+		} else {
+			console.error('El equipo sigue como estaba. Para reintentar:');
+		}
+		console.error('  glassnote pair --org-id <id> --api-key <clave> --device-name <nombre>');
+		console.error('');
+		return 1;
+	}
+}
+
+async function cmdPair(args) {
+	const opciones = pairing.leerOpciones(args, process.env);
+	if (!pairing.pidenEmparejar(opciones)) {
+		console.error('glassnote pair: falta --api-key (o la variable GLASSNOTE_API_KEY).\n');
+		cmdHelp();
+		return 2;
+	}
+	return emparejar(opciones);
+}
+
 function cmdUpdate(args) {
 	if (mode.isEphemeral()) {
 		log('Estás corriendo por npx: npx ya baja la última versión cada vez.');
@@ -571,6 +725,16 @@ function cmdUpdate(args) {
 
 	if (waitMs > 0) esperarAQueCierre(waitMs);
 
+	// Sin `--wait` esto lo está corriendo una persona a mano, con el cliente abierto: el
+	// mismo EBUSY de Windows que en install, y con el mismo remedio.
+	else if (!cerrarClienteWindows()) {
+		fail(
+			'el cliente sigue abierto y Windows no deja reemplazar sus archivos.\n' +
+				'  Cerralo desde el ícono de la bandeja (clic derecho → Salir) y volvé a intentar.\n' +
+				'  No se tocó nada: la versión que tenías sigue como estaba.'
+		);
+	}
+
 	// 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 {
@@ -731,6 +895,7 @@ function cmdHelp() {
   glassnote                     arranca el cliente
   glassnote start --detach      lo arranca y libera la terminal
   glassnote update [version]    actualiza (por defecto, la última)
+  glassnote pair                da de alta el equipo con la API key de la organización
   glassnote uninstall           quita autoarranque, ~/.glassnote y la línea del rc
   glassnote status              versión, modo, rutas y estado del autoarranque
   glassnote fix-sandbox         (Linux) restaura el sandbox de Chromium; pide sudo una vez
@@ -738,6 +903,26 @@ function cmdHelp() {
 Banderas de install:
   --no-path       no toca el rc; imprime la línea para pegarla
   --no-start      instala y no arranca el cliente
+
+Emparejamiento desatendido (install y pair) — para dar de alta muchos equipos sin que
+nadie escriba el código en la web:
+  --org-id <id>        organización a la que entra el equipo
+  --api-key <clave>    API key de esa organización
+  --device-name <n>    nombre del equipo (por defecto, el hostname)
+  --user-name <n>      persona a cargo (por defecto, el usuario del sistema)
+  --api-url <url>      otra API (por defecto, ${pairing.API_URL_POR_DEFECTO})
+  --ws-url <url>       fuerza el websocket que guarda el equipo
+
+El websocket NO se elige acá: lo decide la API que atiende el alta, porque el token que
+emite sólo vale en el suyo. Para dar de alta contra otro servidor se cambia --api-url y el
+websocket viene de vuelta solo. --ws-url es para el caso en que la API anuncia una
+dirección a la que el equipo no llega (IP de LAN, proxy inverso con otro nombre).
+
+Las mismas se pueden pasar por entorno, para despliegues que no admiten argumentos:
+GLASSNOTE_ORG_ID, GLASSNOTE_API_KEY, GLASSNOTE_DEVICE_NAME, GLASSNOTE_USER_NAME,
+GLASSNOTE_API_URL, GLASSNOTE_WS_URL.
+
+  npx @glassnote/client install --org-id 55 --api-key abc123 --device-name "Caja 01"
 `);
 	return 0;
 }
@@ -762,6 +947,9 @@ function main() {
 			});
 		case 'install':
 			return cmdInstall(rest);
+		case 'pair':
+		case 'enroll':
+			return cmdPair(rest);
 		case 'update':
 		case 'upgrade':
 			return cmdUpdate(rest);
@@ -787,7 +975,20 @@ function main() {
 // Requerido desde un test, el archivo NO debe correr nada: solo expone las piezas que
 // se comprueban. Como CLI se comporta igual que siempre.
 if (require.main === module) {
-	process.exit(main());
+	// `install` y `pair` hablan con la API, asi que main() puede devolver una promesa.
+	// Salir con process.exit() sin esperarla cortaria el alta a la mitad.
+	const resultado = main();
+	if (resultado && typeof resultado.then === 'function') {
+		resultado.then(
+			(codigo) => process.exit(codigo),
+			(error) => {
+				console.error(`glassnote: ${error && error.message ? error.message : error}`);
+				process.exit(1);
+			}
+		);
+	} else {
+		process.exit(resultado);
+	}
 } else {
-	module.exports = { npmInvocation, npmEnv, toSpec };
+	module.exports = { npmInvocation, npmEnv, toSpec, guionCerrarCliente, cerrarClienteWindows };
 }

package/linuxCursor.js

@@ -0,0 +1,187 @@
+// Donde esta el mouse, preguntado directo al servidor X.
+//
+// Hace falta porque screen.getCursorScreenPoint() de Electron miente justo en el unico caso
+// que le importa a un overlay: mientras la ventana ignora el mouse (input shape de 1x1 px en
+// X11) Chromium no recibe un solo evento de puntero, y esa funcion devuelve para siempre la
+// ultima posicion que alcanzo a ver. Medido:
+//
+//   ventana ignorando   -> sigue al mouse   (cae al XQueryPointer del servidor)
+//   ventana clickeable  -> sigue al mouse   (le llegan eventos reales)
+//   vuelve a ignorar    -> CONGELADA en el ultimo punto que vio, para siempre
+//
+// O sea: funciona hasta la primera interaccion y despues miente. Ese es exactamente el
+// "andaba y dejo de andar" del passthrough en Linux.
+//
+// Asi que se le pregunta al servidor: XQueryPointer, opcode 38. Es protocolo binario a mano,
+// pero es protocolo congelado hace decadas y no arrastra ninguna dependencia nativa —que en
+// este cliente, que se instala con npx y sin compilador, no es un lujo sino un requisito—.
+// Si algo falla (Wayland, display por TCP, sin cookie) se devuelve null y quien llama se las
+// arregla con lo que tenga.
+'use strict';
+
+const net = require('net');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const OPCODE_QUERY_POINTER = 38;
+
+let socket = null;
+let ventanaRaiz = null;
+let ultimaPosicion = null;
+let consultaEnVuelo = false;
+let inutilizable = false;
+
+// El .Xauthority es una lista de bloques con largo de 2 bytes big-endian: familia, direccion,
+// numero de display, nombre del metodo y la cookie. Solo interesa la MIT-MAGIC-COOKIE-1 de
+// este display (o la que no fija display, que vale para todos).
+function leerCookie(numeroDisplay) {
+	const archivo = process.env.XAUTHORITY || path.join(os.homedir(), '.Xauthority');
+	let buf;
+	try {
+		buf = fs.readFileSync(archivo);
+	} catch (error) {
+		return null;
+	}
+
+	let i = 0;
+	const bloque = () => {
+		if (i + 2 > buf.length) return null;
+		const largo = buf.readUInt16BE(i);
+		i += 2;
+		if (i + largo > buf.length) return null;
+		const datos = buf.subarray(i, i + largo);
+		i += largo;
+		return datos;
+	};
+
+	while (i + 2 <= buf.length) {
+		i += 2; // familia
+		const direccion = bloque();
+		const numero = bloque();
+		const nombre = bloque();
+		const cookie = bloque();
+		if (!direccion || !numero || !nombre || !cookie) break;
+		if (nombre.toString() !== 'MIT-MAGIC-COOKIE-1') continue;
+		const suDisplay = numero.toString();
+		if (suDisplay === '' || suDisplay === String(numeroDisplay)) return { nombre, cookie };
+	}
+	return null;
+}
+
+const relleno = (largo) => (4 - (largo % 4)) % 4;
+
+function numeroDeDisplay() {
+	const display = process.env.DISPLAY || '';
+	// Solo sockets unix locales: ":0", ":0.0". Un display por TCP ("host:0") no se atiende.
+	const coincide = /^:(\d+)/.exec(display);
+	return coincide ? parseInt(coincide[1], 10) : null;
+}
+
+function conectar() {
+	const numero = numeroDeDisplay();
+	if (numero === null) {
+		inutilizable = true;
+		return;
+	}
+
+	const auth = leerCookie(numero) || { nombre: Buffer.alloc(0), cookie: Buffer.alloc(0) };
+	let cliente;
+	try {
+		cliente = net.connect(`/tmp/.X11-unix/X${numero}`);
+	} catch (error) {
+		inutilizable = true;
+		return;
+	}
+
+	cliente.on('error', () => {
+		inutilizable = true;
+		socket = null;
+		ventanaRaiz = null;
+	});
+	cliente.on('close', () => {
+		socket = null;
+		ventanaRaiz = null;
+		consultaEnVuelo = false;
+	});
+
+	cliente.once('connect', () => {
+		const largoNombre = auth.nombre.length;
+		const largoCookie = auth.cookie.length;
+		const inicio = Buffer.alloc(
+			12 + largoNombre + relleno(largoNombre) + largoCookie + relleno(largoCookie)
+		);
+		inicio.write('l', 0, 'ascii'); // little endian
+		inicio.writeUInt16LE(11, 2); // protocolo 11.0
+		inicio.writeUInt16LE(0, 4);
+		inicio.writeUInt16LE(largoNombre, 6);
+		inicio.writeUInt16LE(largoCookie, 8);
+		auth.nombre.copy(inicio, 12);
+		auth.cookie.copy(inicio, 12 + largoNombre + relleno(largoNombre));
+		cliente.write(inicio);
+
+		cliente.once('data', (respuesta) => {
+			if (respuesta[0] !== 1) {
+				// 0 = rechazado (cookie mala), 2 = pide mas autenticacion.
+				inutilizable = true;
+				cliente.destroy();
+				return;
+			}
+			// La ventana raiz esta despues del vendor y de los formatos de pixel, todos de
+			// largo variable: hay que saltearlos para llegar a la primera pantalla.
+			const largoVendor = respuesta.readUInt16LE(24);
+			const cantidadFormatos = respuesta[29];
+			const inicioPantallas = 40 + largoVendor + relleno(largoVendor) + 8 * cantidadFormatos;
+			if (inicioPantallas + 4 > respuesta.length) {
+				inutilizable = true;
+				cliente.destroy();
+				return;
+			}
+			ventanaRaiz = respuesta.readUInt32LE(inicioPantallas);
+			socket = cliente;
+
+			cliente.on('data', (paquete) => {
+				// Respuesta de QueryPointer: 32 bytes, root_x y root_y en 20 y 22.
+				if (paquete.length >= 32 && paquete[0] === 1) {
+					ultimaPosicion = { x: paquete.readInt16LE(20), y: paquete.readInt16LE(22) };
+				}
+				consultaEnVuelo = false;
+			});
+		});
+	});
+}
+
+// Pide la posicion al servidor y devuelve la ULTIMA que contesto: la respuesta llega por el
+// socket, no en el acto. Consultando a 30 Hz eso son 30 ms de atraso, que para decidir si el
+// cursor esta sobre un boton no se nota. Nunca hay mas de una consulta en vuelo: si el
+// servidor se atrasa, no se le encima una cola de pedidos que ya no le sirven a nadie.
+function posicion() {
+	if (inutilizable) return null;
+	if (!socket) {
+		conectar();
+		return ultimaPosicion;
+	}
+	if (!consultaEnVuelo) {
+		const pedido = Buffer.alloc(8);
+		pedido[0] = OPCODE_QUERY_POINTER;
+		pedido.writeUInt16LE(2, 2); // largo en palabras de 4 bytes
+		pedido.writeUInt32LE(ventanaRaiz, 4);
+		consultaEnVuelo = true;
+		try {
+			socket.write(pedido);
+		} catch (error) {
+			consultaEnVuelo = false;
+		}
+	}
+	return ultimaPosicion;
+}
+
+function detener() {
+	if (socket) socket.destroy();
+	socket = null;
+	ventanaRaiz = null;
+	ultimaPosicion = null;
+	consultaEnVuelo = false;
+}
+
+module.exports = { posicion, detener };