@glassnote/client 2.4.0

package/bin/glassnote.js

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+// glassnote — instalador y lanzador del cliente por npm/npx.
+//
+//   npx @glassnote/client            corre el cliente una vez (nada queda instalado)
+//   npx @glassnote/client install    lo instala de verdad y deja el comando `glassnote`
+//   glassnote update         actualiza a la última publicada
+//   glassnote uninstall      quita autoarranque, ~/.glassnote y la línea del rc
+//
+// Sin instaladores nativos, sin firmas y sin tiendas: npm baja el binario de electron
+// por su cuenta (no pasa por el navegador, así que macOS no le pone quarantine y
+// Gatekeeper no lo bloquea) y el cliente se ejecuta con ese electron.
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+
+const mode = require('../npmMode');
+const pkg = require('../package.json');
+
+const IS_WIN = process.platform === 'win32';
+const NPM_CMD = IS_WIN ? 'npm.cmd' : 'npm';
+const MARK_A = '# >>> glassnote >>>';
+const MARK_B = '# <<< glassnote <<<';
+
+// El PATH que se le da a npm lleva delante nuestro bin: si install.sh tuvo que bajar
+// Node, sus enlaces viven ahí y de otro modo npm no existiría para este proceso.
+function npmEnv() {
+	return Object.assign({}, process.env, {
+		PATH: `${mode.BIN_DIR}${path.delimiter}${process.env.PATH || ''}`,
+	});
+}
+
+// Sueño síncrono sin dependencias: el ayudante de actualización tiene que esperar a que
+// la app termine de cerrarse antes de que npm le reemplace los archivos.
+function sleepSync(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+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á.
+const step = (msg) => console.log(`  · ${msg}`);
+const fail = (msg) => {
+	console.error(`glassnote: ${msg}`);
+	process.exit(1);
+};
+
+// ── electron ────────────────────────────────────────────────────────────────────────
+function electronPath() {
+	let binary;
+	try {
+		binary = require('electron');
+	} catch (error) {
+		fail(
+			'no encuentro electron.\n' +
+				'  Si instalaste con --ignore-scripts, el binario no se descargó. Reinstalá sin esa bandera:\n' +
+				`  npx ${mode.PKG_NAME} install`
+		);
+	}
+	if (typeof binary !== 'string' || !fs.existsSync(binary)) {
+		fail('electron está instalado pero su binario no se descargó. Reinstalá el paquete.');
+	}
+	return binary;
+}
+
+function launchArgs(binary) {
+	const flags = mode.sandboxFlags(binary);
+	if (flags.includes('--no-sandbox') && !warnedNoSandbox) {
+		warnedNoSandbox = true;
+		console.error(
+			'glassnote: arrancando SIN sandbox de Chromium (esta máquina no permite otra cosa\n' +
+				'  para una instalación sin root). Para recuperarlo, una sola vez:  glassnote fix-sandbox'
+		);
+	}
+	return [mode.PACKAGE_ROOT].concat(flags);
+}
+
+let warnedNoSandbox = false;
+
+function launch({ detach = false, extra = [] } = {}) {
+	const binary = electronPath();
+	const args = launchArgs(binary).concat(extra);
+	const env = Object.assign({}, process.env, {
+		// El modo se marca aquí, no se adivina desde el main: sobrevive a symlinks.
+		GLASSNOTE_INSTALL_MODE: mode.detect(),
+		GLASSNOTE_CLI: path.join(__dirname, 'glassnote.js'),
+	});
+	// Si veníamos corriendo como node dentro de electron, hay que quitarlo o el cliente
+	// arrancaría otra vez como node y no abriría ninguna ventana.
+	delete env.ELECTRON_RUN_AS_NODE;
+
+	if (mode.isEphemeral()) {
+		log('Corriendo por npx: nada queda instalado y no se registra el arranque automático.');
+		log(`Para instalarlo de verdad:  npx ${mode.PKG_NAME} install`);
+	}
+
+	if (detach) {
+		const child = spawn(binary, args, { detached: true, stdio: 'ignore', env });
+		child.unref();
+		return 0;
+	}
+
+	const child = spawnSync(binary, args, { stdio: 'inherit', env });
+	if (child.error) fail(`no se pudo arrancar el cliente: ${child.error.message}`);
+	if (child.status !== 0 && process.platform === 'linux') {
+		console.error(
+			'\nSi falló por librerías del sistema, en Debian/Ubuntu suelen faltar:\n' +
+				'  sudo apt-get install -y libgtk-3-0 libnss3 libasound2 libxss1 libgbm1\n' +
+				'En un servidor sin escritorio el cliente no puede correr: necesita sesión gráfica.'
+		);
+	}
+	return child.status === null ? 1 : child.status;
+}
+
+// ── PATH ────────────────────────────────────────────────────────────────────────────
+function addToPathUnix() {
+	const line = `export PATH="${mode.BIN_DIR}:$PATH"`;
+	// Los rc del shell interactivo primero. `.profile` SOLO si no hay ninguno: escribir
+	// en los dos deja el mismo directorio dos veces en el PATH.
+	let rcs = [path.join(os.homedir(), '.bashrc'), path.join(os.homedir(), '.zshrc')].filter((rc) =>
+		fs.existsSync(rc)
+	);
+	if (rcs.length === 0) rcs = [path.join(os.homedir(), '.profile')];
+
+	const touched = [];
+	for (const rc of rcs) {
+		let content = '';
+		try {
+			content = fs.readFileSync(rc, 'utf8');
+		} catch (error) {
+			content = '';
+		}
+		if (content.includes(MARK_A)) continue; // idempotente
+		fs.appendFileSync(rc, `\n${MARK_A}\n${line}\n${MARK_B}\n`);
+		touched.push(rc);
+	}
+	return { touched, line };
+}
+
+function addToPathWindows() {
+	// Nada de `setx`: trunca el PATH a 1024 caracteres y se come el de la gente.
+	const ps = [
+		"$dir = '" + mode.BIN_DIR.replace(/'/g, "''") + "'",
+		"$cur = [Environment]::GetEnvironmentVariable('Path','User')",
+		"if ($null -eq $cur) { $cur = '' }",
+		"if (($cur -split ';') -notcontains $dir) {",
+		"  $new = if ($cur.Trim() -eq '') { $dir } else { $cur.TrimEnd(';') + ';' + $dir }",
+		"  [Environment]::SetEnvironmentVariable('Path', $new, 'User')",
+		"  Write-Output 'added'",
+		'} else { Write-Output "present" }',
+	].join('; ');
+	const res = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps], {
+		encoding: 'utf8',
+	});
+	const added = res.status === 0 && String(res.stdout).includes('added');
+	return { touched: added ? ['PATH de usuario (sin administrador)'] : [], line: mode.BIN_DIR };
+}
+
+function removeFromPathUnix() {
+	const rcs = [
+		path.join(os.homedir(), '.bashrc'),
+		path.join(os.homedir(), '.zshrc'),
+		path.join(os.homedir(), '.profile'),
+	];
+	const touched = [];
+	for (const rc of rcs) {
+		if (!fs.existsSync(rc)) continue;
+		const content = fs.readFileSync(rc, 'utf8');
+		if (!content.includes(MARK_A)) continue;
+		// Solo se borra lo que está entre NUESTROS marcadores; el resto no se toca.
+		const cleaned = content.replace(
+			new RegExp(`\\n?${MARK_A}[\\s\\S]*?${MARK_B}\\n?`, 'g'),
+			'\n'
+		);
+		fs.writeFileSync(rc, cleaned);
+		touched.push(rc);
+	}
+	return touched;
+}
+
+function removeFromPathWindows() {
+	// Simétrico a addToPathWindows: si install lo agrega con SetEnvironmentVariable,
+	// uninstall lo quita igual. Decirle al usuario que lo borre a mano dejaba una
+	// entrada muerta en el PATH de todo el mundo que desinstalara.
+	const ps = [
+		"$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 ';'",
+		'if ($new -ne $cur) {',
+		"  [Environment]::SetEnvironmentVariable('Path', $new, 'User')",
+		"  Write-Output 'removed'",
+		"} else { Write-Output 'absent' }",
+	].join('; ');
+	const res = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps], {
+		encoding: 'utf8',
+	});
+	return res.status === 0 && String(res.stdout).includes('removed');
+}
+
+// ── autoarranque ────────────────────────────────────────────────────────────────────
+// autoStart.js lo escribe la app al arrancar; para quitarlo desde el CLI se reusa la
+// misma clase (carga electron de forma perezosa, así funciona bajo node puro).
+function removeAutoStart() {
+	try {
+		const AutoStart = require('../autoStart');
+		new AutoStart().removeAutoStart();
+		return true;
+	} catch (error) {
+		console.error(`  no se pudo limpiar el autoarranque: ${error.message}`);
+		return false;
+	}
+}
+
+// ── comandos ────────────────────────────────────────────────────────────────────────
+// `glassnote install` acepta una versión (`2.3.0`, `latest`) o directamente un spec de
+// npm: un .tgz, una ruta local o una URL. Lo segundo es lo que permite probar un paquete
+// antes de publicarlo y lo que hace falta si algún día esto vive en un registry privado.
+// Del DISCO, no con require(): cuando el paquete se actualiza a sí mismo, este proceso
+// ya tiene cargado su propio package.json y require() lo devolvería de la caché — un
+// update correcto informaba la versión ANTERIOR y parecía fallido.
+function installedVersion() {
+	try {
+		const file = path.join(mode.INSTALLED_PACKAGE_DIR, 'package.json');
+		return JSON.parse(fs.readFileSync(file, 'utf8')).version;
+	} catch (error) {
+		return 'desconocida';
+	}
+}
+
+function toSpec(arg) {
+	if (!arg || arg === 'latest') return `${mode.PKG_NAME}@latest`;
+	const looksLikeSpec =
+		arg.endsWith('.tgz') ||
+		arg.startsWith('.') ||
+		arg.startsWith('/') ||
+		arg.startsWith('file:') ||
+		arg.includes('://') ||
+		arg.startsWith('@');
+	return looksLikeSpec ? arg : `${mode.PKG_NAME}@${arg}`;
+}
+
+function cmdInstall(args) {
+	const version = args.find((a) => !a.startsWith('-')) || 'latest';
+	const noPath = args.includes('--no-path');
+	const noStart = args.includes('--no-start');
+
+	const spec = toSpec(version);
+	log(`glassnote — instalando ${spec}`);
+	fs.mkdirSync(mode.NPM_PREFIX, { recursive: true });
+	fs.mkdirSync(mode.BIN_DIR, { recursive: true });
+
+	// 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(),
+	});
+	if (res.status !== 0) fail('npm no pudo instalar el paquete (ver el error de arriba).');
+
+	if (!fs.existsSync(mode.INSTALLED_PACKAGE_DIR)) {
+		fail(`npm terminó pero no encuentro ${mode.INSTALLED_PACKAGE_DIR}`);
+	}
+
+	// Un solo directorio en el PATH, con enlaces a lo instalado.
+	if (!IS_WIN) {
+		const target = path.join(mode.NPM_PREFIX, 'bin', mode.BIN_NAME);
+		const link = path.join(mode.BIN_DIR, mode.BIN_NAME);
+		if (fs.existsSync(target)) {
+			step(`enlazando ${mode.BIN_NAME} en ${mode.BIN_DIR}`);
+			try {
+				fs.unlinkSync(link);
+			} catch (error) {
+				/* no existía */
+			}
+			fs.symlinkSync(target, link);
+		}
+	}
+
+	let pathInfo = { touched: [], line: '' };
+	if (!noPath) {
+		pathInfo = IS_WIN ? addToPathWindows() : addToPathUnix();
+		if (pathInfo.touched.length) step(`agregado al PATH en: ${pathInfo.touched.join(' ')}`);
+	}
+
+	log('');
+	log(`Instalado: ${mode.PKG_NAME} v${installedVersion()} en ${mode.HOME_DIR}`);
+	if (pathInfo.touched.length) {
+		log(`Una terminal NUEVA ya lo encuentra. En esta:`);
+		log(IS_WIN ? `  set PATH=${mode.BIN_DIR};%PATH%` : `  export PATH="${mode.BIN_DIR}:$PATH"`);
+	} else if (!noPath) {
+		log('Tu PATH ya lo tenía.');
+	} else {
+		log('No toqué tu PATH. Agregá esta línea a la config de tu shell:');
+		log(IS_WIN ? `  ${mode.BIN_DIR}` : `  export PATH="${mode.BIN_DIR}:$PATH"`);
+	}
+	log('Para actualizar más adelante: glassnote update (o correr esto mismo otra vez).');
+	log('');
+
+	if (noStart) {
+		log('Arrancalo cuando quieras:  glassnote');
+		return 0;
+	}
+
+	// Se arranca desprendido: es una app de bandeja, no una herramienta de terminal.
+	// Al arrancar, la app se registra sola en el autoarranque del usuario.
+	step('arrancando el cliente en segundo plano (queda en la bandeja del sistema)');
+	const binary = path.join(mode.INSTALLED_PACKAGE_DIR, 'bin', 'glassnote.js');
+	const child = spawn(process.execPath, [binary, 'start', '--detach'], {
+		detached: true,
+		stdio: 'ignore',
+		env: process.env,
+	});
+	child.unref();
+	log('Listo. Ícono en la bandeja; se abrirá solo en los próximos arranques.');
+	return 0;
+}
+
+function cmdUpdate(args) {
+	if (mode.isEphemeral()) {
+		log('Estás corriendo por npx: npx ya baja la última versión cada vez.');
+		log(`Para dejarlo instalado:  npx ${mode.PKG_NAME} install`);
+		return 0;
+	}
+
+	// `--wait` y `--relaunch` los usa la app al auto-actualizarse: espera a que el
+	// cliente termine de cerrarse (en Windows npm no puede tocar un .exe en marcha) y
+	// lo vuelve a abrir al terminar.
+	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);
+	const version = positional[0] || 'latest';
+
+	if (waitMs > 0) sleepSync(waitMs);
+
+	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(),
+	});
+	if (res.status !== 0) {
+		if (relaunch) {
+			// Falló la actualización: al menos el cliente vuelve. Quedarse sin app por
+			// un npm que no pudo con la red es peor que seguir en la versión vieja.
+			console.error('glassnote: la actualización falló; reabriendo la versión instalada.');
+			launch({ detach: true });
+		}
+		fail('npm no pudo actualizar el paquete.');
+	}
+
+	log(`Actualizado a v${installedVersion()}.`);
+	if (relaunch) {
+		launch({ detach: true });
+		return 0;
+	}
+	log('Reiniciá el cliente para aplicarlo.');
+	return 0;
+}
+
+function cmdUninstall() {
+	log('glassnote — desinstalando');
+	step('quitando el autoarranque');
+	removeAutoStart();
+
+	if (!IS_WIN) {
+		const touched = removeFromPathUnix();
+		if (touched.length) step(`línea del PATH quitada de: ${touched.join(' ')}`);
+	} else if (removeFromPathWindows()) {
+		step('quitado del PATH de usuario (las terminales ya abiertas siguen con el viejo)');
+	} else {
+		step('el PATH de usuario ya no tenía la entrada');
+	}
+
+	if (fs.existsSync(mode.HOME_DIR)) {
+		step(`borrando ${mode.HOME_DIR}`);
+		fs.rmSync(mode.HOME_DIR, { recursive: true, force: true });
+	}
+	log('');
+	log('Desinstalado. Tus datos y notas siguen donde estaban:');
+	log(`  ${userDataDir()}`);
+	log('Borralos a mano si también querés perderlos.');
+	return 0;
+}
+
+function userDataDir() {
+	const base =
+		process.env.APPDATA ||
+		(process.platform === 'darwin'
+			? path.join(os.homedir(), 'Library', 'Application Support')
+			: path.join(os.homedir(), '.config'));
+	return path.join(base, 'glassnote');
+}
+
+// Deja chrome-sandbox como Chromium lo quiere: root:root y setuid. Es lo ÚNICO que
+// necesita permisos de administrador en toda la instalación, es opcional, y se pide
+// explícitamente — no a espaldas del usuario durante un `install`.
+function cmdFixSandbox() {
+	if (process.platform !== 'linux') {
+		log('Solo hace falta en Linux; en Windows y macOS el sandbox ya funciona.');
+		return 0;
+	}
+	const binary = electronPath();
+	const sandbox = mode.chromeSandboxPath(binary);
+	if (!fs.existsSync(sandbox)) fail(`no encuentro ${sandbox}`);
+	if (mode.sandboxIsSetuidRoot(binary)) {
+		log('Ya está bien configurado: chrome-sandbox es setuid root.');
+		return 0;
+	}
+	log(`Hace falta sudo una vez para:  chown root:root && chmod 4755 ${sandbox}`);
+	const res = spawnSync(
+		'sudo',
+		['sh', '-c', `chown root:root "${sandbox}" && chmod 4755 "${sandbox}"`],
+		{ stdio: 'inherit' }
+	);
+	if (res.status !== 0) fail('no se pudo cambiar el permiso (¿sudo cancelado?).');
+	log('Listo. El cliente ya arranca con el sandbox de Chromium.');
+	log('Ojo: hay que repetirlo tras cada actualización, porque npm reinstala el binario.');
+	return 0;
+}
+
+function cmdStatus() {
+	let electronVersion = 'no instalado';
+	try {
+		electronVersion = require('electron/package.json').version;
+	} catch (error) {
+		/* sin electron */
+	}
+	let autoStartOn = 'desconocido';
+	try {
+		autoStartOn = new (require('../autoStart'))().isAutoStartConfigured() ? 'sí' : 'no';
+	} catch (error) {
+		/* ignore */
+	}
+	log(`glassnote v${pkg.version}`);
+	log(`  modo:            ${mode.detect()}`);
+	log(`  paquete:         ${mode.PACKAGE_ROOT}`);
+	log(`  electron:        ${electronVersion}`);
+	log(`  home:            ${mode.HOME_DIR}`);
+	log(`  datos:           ${userDataDir()}`);
+	log(`  autoarranque:    ${autoStartOn}`);
+	if (process.platform === 'linux') {
+		let sandboxState = 'sin electron';
+		try {
+			const binary = require('electron');
+			const flags = mode.sandboxFlags(binary);
+			sandboxState = flags.length === 0 ? 'setuid root (completo)' : `degradado (${flags.join(' ')})`;
+		} catch (error) {
+			/* sin electron */
+		}
+		log(`  sandbox:         ${sandboxState}`);
+	}
+	return 0;
+}
+
+function cmdHelp() {
+	log(`glassnote v${pkg.version} — cliente de escritorio
+
+  npx @glassnote/client         corre el cliente sin instalar nada
+  npx @glassnote/client install lo instala bajo ~/.glassnote y deja el comando
+  glassnote                     arranca el cliente
+  glassnote start --detach      lo arranca y libera la terminal
+  glassnote update [version]    actualiza (por defecto, la última)
+  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
+
+Banderas de install:
+  --no-path       no toca el rc; imprime la línea para pegarla
+  --no-start      instala y no arranca el cliente
+`);
+	return 0;
+}
+
+function main() {
+	const argv = process.argv.slice(2);
+	const cmd = argv[0];
+	const rest = argv.slice(1);
+
+	if (cmd === '--version' || cmd === '-v') {
+		log(pkg.version);
+		return 0;
+	}
+	if (cmd === '--help' || cmd === '-h' || cmd === 'help') return cmdHelp();
+
+	switch (cmd) {
+		case undefined:
+		case 'start':
+			return launch({
+				detach: rest.includes('--detach') || rest.includes('-d'),
+				extra: rest.filter((a) => a !== '--detach' && a !== '-d'),
+			});
+		case 'install':
+			return cmdInstall(rest);
+		case 'update':
+		case 'upgrade':
+			return cmdUpdate(rest);
+		case 'uninstall':
+		case 'remove':
+			return cmdUninstall();
+		case 'status':
+		case 'doctor':
+			return cmdStatus();
+		case 'fix-sandbox':
+			return cmdFixSandbox();
+		default:
+			if (cmd.startsWith('-')) {
+				// Banderas sueltas van al cliente: `glassnote --no-sandbox`
+				return launch({ extra: argv });
+			}
+			console.error(`glassnote: comando desconocido "${cmd}"\n`);
+			cmdHelp();
+			return 2;
+	}
+}
+
+process.exit(main());