@glassnote/client 2.4.0

package/npmMode.js

@@ -0,0 +1,139 @@
+// Detección del modo de instalación y rutas del instalador npm/npx.
+//
+// Este archivo lo cargan DOS procesos distintos: el CLI (`bin/glassnote.js`, node puro)
+// y el main de electron. Por eso no puede requerir 'electron' ni nada de electron.
+//
+// Modos:
+//   'packaged'   instalador nativo (NSIS/DMG) — la vía vieja, en deprecación
+//   'npm-global' instalado con `glassnote install` bajo ~/.glassnote (la vía oficial)
+//   'npx'        corriendo desde la caché de npx, sin instalar: efímero
+//   'source'     repo clonado, `npm start` de toda la vida
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const PKG_NAME = '@glassnote/client';
+// El comando NO se llama como el paquete: npm crea el shim con el nombre del bin, así
+// que se instala con 'npx @glassnote/client' y lo que queda en el PATH es 'glassnote'.
+// Todo lo que sea una ruta o un enlace usa BIN_NAME; lo que hable con npm, PKG_NAME.
+const BIN_NAME = 'glassnote';
+const PACKAGE_ROOT = __dirname;
+
+// Todo vive bajo un solo directorio: desinstalar es borrarlo y quitar la línea del rc.
+const HOME_DIR = process.env.GLASSNOTE_HOME || path.join(os.homedir(), '.glassnote');
+const NPM_PREFIX = path.join(HOME_DIR, 'npm');
+
+// En Windows npm deja los shims (.cmd/.ps1) en la RAÍZ del prefix, no en prefix/bin.
+// En Linux/macOS usamos un bin propio con symlinks: es LO ÚNICO que se mete al PATH,
+// así la línea del rc no cambia aunque cambie lo de dentro.
+const BIN_DIR = process.platform === 'win32' ? NPM_PREFIX : path.join(HOME_DIR, 'bin');
+
+// Dónde npm deja el paquete al instalarlo con --prefix (difiere por plataforma).
+const INSTALLED_PACKAGE_DIR =
+	process.platform === 'win32'
+		? path.join(NPM_PREFIX, 'node_modules', PKG_NAME)
+		: path.join(NPM_PREFIX, 'lib', 'node_modules', PKG_NAME);
+
+function realpath(p) {
+	try {
+		return fs.realpathSync(p);
+	} catch (error) {
+		return p;
+	}
+}
+
+function isInside(child, parent) {
+	const rel = path.relative(realpath(parent), realpath(child));
+	return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function detect() {
+	// El CLI marca el modo al lanzar electron: es la señal más fiable porque sobrevive
+	// a symlinks y a que npm mueva el paquete de sitio.
+	if (process.env.GLASSNOTE_INSTALL_MODE) return process.env.GLASSNOTE_INSTALL_MODE;
+
+	// Los builds nativos van dentro de resources/app(.asar); nunca en node_modules.
+	const segments = PACKAGE_ROOT.split(path.sep);
+	if (segments.includes('app.asar') || segments.includes('resources')) return 'packaged';
+	if (!segments.includes('node_modules')) return 'source';
+	// La caché de npx: efímera, no tiene sentido auto-actualizarse ahí.
+	if (segments.includes('_npx') || PACKAGE_ROOT.includes('.npm/_npx')) return 'npx';
+	if (isInside(PACKAGE_ROOT, NPM_PREFIX)) return 'npm-global';
+	return 'npm-global';
+}
+
+// ── El sandbox de Chromium en Linux ────────────────────────────────────────────────
+//
+// Instalar sin root tiene un precio en Linux: `chrome-sandbox` tiene que ser setuid root
+// y npm no puede dejarlo así. Chromium entonces ABORTA al arrancar (no arranca degradado,
+// se muere), y ese es exactamente el fallo que se ve al correr el cliente por npx.
+//
+// Orden de preferencia, de más a menos seguro:
+//   1. chrome-sandbox setuid root  → nada que añadir (lo pone `glassnote fix-sandbox`)
+//   2. namespaces de usuario sin privilegios → --disable-setuid-sandbox (sigue habiendo
+//      sandbox, solo que el de namespaces)
+//   3. ni eso → --no-sandbox, que es correr sin sandbox y hay que decirlo
+//
+// Ubuntu 24.04+ cae en el caso 3 aunque el kernel soporte namespaces: AppArmor los
+// restringe a binarios con perfil (apparmor_restrict_unprivileged_userns=1).
+function readProc(file) {
+	try {
+		return fs.readFileSync(file, 'utf8').trim();
+	} catch (error) {
+		return null;
+	}
+}
+
+function userNamespacesUsable() {
+	if (readProc('/proc/sys/kernel/unprivileged_userns_clone') === '0') return false;
+	if (readProc('/proc/sys/user/max_user_namespaces') === '0') return false;
+	if (readProc('/proc/sys/kernel/apparmor_restrict_unprivileged_userns') === '1') return false;
+	return true;
+}
+
+function chromeSandboxPath(electronBinary) {
+	return path.join(path.dirname(electronBinary), 'chrome-sandbox');
+}
+
+function sandboxIsSetuidRoot(electronBinary) {
+	try {
+		const st = fs.statSync(chromeSandboxPath(electronBinary));
+		return st.uid === 0 && (st.mode & 0o4000) !== 0;
+	} catch (error) {
+		return false;
+	}
+}
+
+// Devuelve las banderas con las que hay que arrancar electron en esta máquina.
+function sandboxFlags(electronBinary) {
+	if (process.env.GLASSNOTE_NO_SANDBOX === '1') return ['--no-sandbox'];
+	if (process.platform !== 'linux') return [];
+	// Como root no hay sandbox de usuario posible.
+	if (typeof process.getuid === 'function' && process.getuid() === 0) return ['--no-sandbox'];
+	if (sandboxIsSetuidRoot(electronBinary)) return [];
+	if (userNamespacesUsable()) return ['--disable-setuid-sandbox'];
+	return ['--no-sandbox'];
+}
+
+const isNpmMode = () => detect() === 'npm-global' || detect() === 'npx';
+const isEphemeral = () => detect() === 'npx';
+const isGlobalInstall = () => detect() === 'npm-global';
+
+module.exports = {
+	PKG_NAME,
+	BIN_NAME,
+	PACKAGE_ROOT,
+	HOME_DIR,
+	NPM_PREFIX,
+	BIN_DIR,
+	INSTALLED_PACKAGE_DIR,
+	detect,
+	sandboxFlags,
+	sandboxIsSetuidRoot,
+	chromeSandboxPath,
+	userNamespacesUsable,
+	isNpmMode,
+	isEphemeral,
+	isGlobalInstall,
+	isInside,
+};

package/npmUpdate.js

@@ -0,0 +1,152 @@
+// Auto-actualización cuando el cliente se instaló por npm (`glassnote install`).
+//
+// Sustituye a autoupdate.js — que baja un .exe/.dmg de S3 y lo ejecuta — por lo único
+// que hace falta aquí: `npm install -g glassnote@<version>` contra el registry.
+//
+// El npm NO se corre desde dentro de la app en marcha: en Windows el electron.exe que
+// se está ejecutando está bloqueado y npm no puede reemplazarlo. Se lanza un ayudante
+// desprendido, la app se cierra, el ayudante actualiza y la vuelve a abrir. Igual en las
+// tres plataformas, así no hay una rama por sistema operativo que solo se pruebe en uno.
+const https = require('https');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const userData = require('./userData');
+const npmMode = require('./npmMode');
+const packageJson = require('./package.json');
+
+const REGISTRY = process.env.GLASSNOTE_REGISTRY || 'https://registry.npmjs.org';
+const CHECK_DELAY_MS = 5000;
+const CHECK_INTERVAL_MS = 3 * 60 * 60 * 1000; // cada 3 horas, como el updater viejo
+
+class NpmUpdate {
+	constructor() {
+		this.currentVersion = packageJson.version;
+		this.updateInterval = null;
+		this.updating = false;
+	}
+
+	start() {
+		// Por npx no se actualiza nada: la caché es efímera y npx ya baja la última
+		// versión en cada corrida. Actualizar ahí sería instalar por la espalda algo
+		// que el usuario pidió explícitamente NO instalar.
+		if (!npmMode.isGlobalInstall()) {
+			console.log(`[update] modo ${npmMode.detect()}: auto-actualización desactivada`);
+			return;
+		}
+
+		setTimeout(() => this.checkForUpdates(), CHECK_DELAY_MS);
+		this.updateInterval = setInterval(() => this.checkForUpdates(), CHECK_INTERVAL_MS);
+	}
+
+	stop() {
+		if (this.updateInterval) {
+			clearInterval(this.updateInterval);
+			this.updateInterval = null;
+		}
+	}
+
+	getJson(url) {
+		return new Promise((resolve) => {
+			const req = https.get(url, { headers: { accept: 'application/json' } }, (res) => {
+				if (res.statusCode !== 200) {
+					res.resume();
+					console.error(`[update] HTTP ${res.statusCode} en ${url}`);
+					return resolve(null);
+				}
+				let body = '';
+				res.setEncoding('utf8');
+				res.on('data', (chunk) => (body += chunk));
+				res.on('end', () => {
+					try {
+						resolve(JSON.parse(body));
+					} catch (error) {
+						console.error('[update] respuesta del registry ilegible:', error.message);
+						resolve(null);
+					}
+				});
+			});
+			req.setTimeout(15000, () => {
+				req.destroy();
+				resolve(null);
+			});
+			req.on('error', (error) => {
+				console.error('[update] error consultando el registry:', error.message);
+				resolve(null);
+			});
+		});
+	}
+
+	async checkForUpdates() {
+		if (this.updating) return;
+		try {
+			// Mismos nombres que el updater viejo, incluida la errata 'lastest', para no
+			// romper los userData que ya están en la calle.
+			const desiredVersion = userData.get('desiredVersion') || 'lastest';
+			if (!desiredVersion) return;
+
+			const isLatest = desiredVersion === 'lastest' || desiredVersion === 'latest';
+			const target = isLatest ? 'latest' : desiredVersion;
+			const meta = await this.getJson(`${REGISTRY}/${npmMode.PKG_NAME}/${target}`);
+			if (!meta || !meta.version) return;
+
+			if (isLatest) {
+				if (compareVersions(this.currentVersion, meta.version) < 0) {
+					this.applyUpdate(meta.version);
+				}
+			} else if (this.currentVersion !== meta.version) {
+				this.applyUpdate(meta.version);
+			}
+		} catch (error) {
+			console.error('[update] error comprobando actualizaciones:', error.message);
+		}
+	}
+
+	applyUpdate(version) {
+		if (this.updating) return;
+		this.updating = true;
+		this.stop();
+		console.log(`[update] ${this.currentVersion} → ${version}: actualizando y reiniciando`);
+
+		const cli = path.join(npmMode.PACKAGE_ROOT, 'bin', 'glassnote.js');
+		// electron sabe hacer de node con ELECTRON_RUN_AS_NODE: así el ayudante no
+		// depende de que haya un `node` en el PATH de la sesión gráfica.
+		const env = Object.assign({}, process.env, {
+			ELECTRON_RUN_AS_NODE: '1',
+			GLASSNOTE_INSTALL_MODE: 'npm-global',
+			PATH: `${npmMode.BIN_DIR}${path.delimiter}${process.env.PATH || ''}`,
+		});
+
+		try {
+			const child = spawn(
+				process.execPath,
+				[cli, 'update', version, '--relaunch', '--wait', '4000'],
+				{ detached: true, stdio: 'ignore', env }
+			);
+			child.unref();
+		} catch (error) {
+			console.error('[update] no se pudo lanzar el actualizador:', error.message);
+			this.updating = false;
+			return;
+		}
+
+		// La app se va: el ayudante espera unos segundos justamente para que ya no esté
+		// cuando npm reemplace los archivos.
+		const { app } = require('electron');
+		setTimeout(() => app.quit(), 500);
+	}
+}
+
+function compareVersions(a, b) {
+	const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+	const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const x = pa[i] || 0;
+		const y = pb[i] || 0;
+		if (x > y) return 1;
+		if (x < y) return -1;
+	}
+	return 0;
+}
+
+module.exports = NpmUpdate;

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "@glassnote/client",
+  "version": "2.4.0",
+  "description": "GlassNote — cliente de escritorio de notas superpuestas. Se instala con npx, sin instaladores nativos ni firmas.",
+  "main": "main.js",
+  "publishConfig": {
+    "_notes": "Un paquete con scope se publica RESTRICTED por defecto: sin esto el publish falla, o peor, queda privado (plan pago).",
+    "access": "public"
+  },
+  "bin": {
+    "glassnote": "bin/glassnote.js"
+  },
+  "author": "GlassNote Team",
+  "license": "UNLICENSED",
+  "logRenderer": true,
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "files": [
+    "bin/",
+    "images/",
+    "main.js",
+    "preload.js",
+    "autoStart.js",
+    "autoupdate.js",
+    "autoupdate_renderer.js",
+    "npmMode.js",
+    "npmUpdate.js",
+    "localserver.js",
+    "logUtilities.js",
+    "userData.js",
+    "INSTALACION.md",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/glassnote.js",
+    "build": "electron-builder",
+    "build-mac": "electron-builder --mac",
+    "build-installer": "electron-builder --win --publish=never",
+    "dev": "concurrently \"npm run watch-renderer\" \"nodemon --watch . --ext html,js,ts,vue --exec electron .\"",
+    "watch": "concurrently \"npm run watch-renderer\" \"nodemon --watch . --ext html,js,ts,vue --exec electron .\"",
+    "build-renderer": "cd glassnote-renderer && npm run build",
+    "watch-renderer": "cd glassnote-renderer && npm run build:watch",
+    "install-local": "node bin/glassnote.js install",
+    "sync-installers": "node scripts/sync-installers.js",
+    "local-registry": "node scripts/local-registry.js",
+    "prepublishOnly": "node scripts/check-publish.js",
+    "start-electron": "electron ."
+  },
+  "keywords": [
+    "glassnote",
+    "overlay",
+    "notes",
+    "electron",
+    "desktop",
+    "npx",
+    "tray"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@intermarkec/intermarkec/glassnote-electron.git"
+  },
+  "dependencies": {
+    "@glassnote/renderer": "2.0.9",
+    "cors": "^2.8.5",
+    "electron": "^29.4.6",
+    "express": "^4.18.2",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "concurrently": "^8.2.2",
+    "electron-builder": "^26.0.12",
+    "electron-packager": "^17.1.2",
+    "nodemon": "^3.1.10",
+    "puppeteer": "^24.37.5"
+  },
+  "build": {
+    "appId": "com.glassnote.app",
+    "productName": "glassnote",
+    "directories": {
+      "output": "installer"
+    },
+    "files": [
+      "**/*",
+      "!**/node_modules/*/{CHANGELOG.md,README.md,README,readme.md,readme}",
+      "!**/node_modules/*/{test,__tests__,tests,powered-test,example,examples}",
+      "!**/node_modules/*.d.ts",
+      "!**/node_modules/.bin",
+      "!**/*.{iml,o,hprof,orig,pyc,pyo,rbc,swp,csproj,sln,xproj}",
+      "!.editorconfig",
+      "!**/._*",
+      "!**/{.DS_Store,.git,.hg,.svn,CVS,RCS,SCCS,.gitignore,.gitattributes}",
+      "!**/{__pycache__,thumbs.db,.flowconfig,.idea,.vs,.nyc_output}",
+      "!**/{appveyor.yml,.travis.yml,circle.yml}",
+      "!**/{npm-debug.log,yarn.lock,.yarn-integrity,.yarn-metadata.json}"
+    ],
+    "mac": {
+      "category": "public.app-category.productivity",
+      "target": {
+        "target": "dmg",
+        "arch": "universal"
+      },
+      "icon": "images/icon-512.png",
+      "identity": "HHBGJVD63U",
+      "hardenedRuntime": true,
+      "gatekeeperAssess": true,
+      "entitlements": "entitlements.mac.plist",
+      "entitlementsInherit": "entitlements.mac.plist"
+    },
+    "dmg": {
+      "sign": true,
+      "contents": [
+        {
+          "x": 110,
+          "y": 150,
+          "type": "file"
+        },
+        {
+          "x": 340,
+          "y": 150,
+          "type": "link",
+          "path": "/Applications"
+        }
+      ],
+      "background": "images/dmg-background.png",
+      "window": {
+        "x": 400,
+        "y": 100,
+        "width": 800,
+        "height": 600
+      }
+    },
+    "artifactName": "glassnote-installer-${version}.${ext}"
+  },
+  "build_notes": "DEPRECADO desde 2026-09-05: los instaladores nativos (NSIS/DMG, eSigner, notarizacion) ya no son la via oficial. La instalacion soportada es `npx @glassnote/client install`. Esta configuracion se conserva solo para builds heredados."
+}

package/preload.js

@@ -0,0 +1,148 @@
+const { contextBridge, ipcRenderer } = require('electron');
+const os = require('os');
+
+// Expose protected methods that allow the renderer process to use
+// the ipcRenderer without exposing the entire object
+contextBridge.exposeInMainWorld('electronAPI', {
+  // IPC communication methods
+  send: (channel, data) => {
+    // Whitelist channels
+    const validChannels = [
+      'set-ignore-events-true',
+      'set-ignore-events-false',
+      'get-user-data',
+      'set-user-data',
+      'remove-user-data',
+      'check-code-visible-response',
+      'show-window',
+      'hide-window',
+      'show-config-menu',
+      'open-external',
+      'open-external-browser',
+      'open-registration-window'
+    ];
+    if (validChannels.includes(channel)) {
+      ipcRenderer.send(channel, data);
+    }
+  },
+  
+  // External browser methods
+  openExternal: (url) => {
+    ipcRenderer.send('open-external', url);
+  },
+  
+  openExternalBrowser: (url) => {
+    ipcRenderer.send('open-external-browser', url);
+  },
+  
+  openRegistrationWindow: (url) => {
+    ipcRenderer.send('open-registration-window', url);
+  },
+  
+  receive: (channel, func) => {
+      // Whitelist channels
+      const validChannels = [
+        'app-data',
+        'user-data',
+        'servers-list',
+        'show-code',
+        'hide-code',
+        'check-code-visible',
+        'user-data-response',
+        'show-config-menu'
+      ];
+      if (validChannels.includes(channel)) {
+        // Remove existing listener first to prevent duplicates
+        ipcRenderer.removeAllListeners(channel);
+        // Deliberately strip event as it includes `sender`
+        ipcRenderer.on(channel, (event, ...args) => func(...args));
+      }
+    },
+  
+  // OS information (limited exposure)
+  getOSInfo: () => {
+    return {
+      platform: os.platform(),
+      networkInterfaces: () => {
+        const interfaces = os.networkInterfaces();
+        const result = {};
+        for (const [name, iface] of Object.entries(interfaces)) {
+          result[name] = iface.filter(i => i.family === 'IPv4' && !i.internal)
+                             .map(i => i.address);
+        }
+        return result;
+      }
+    };
+  },
+  
+  // Remove all listeners for a channel
+  removeAllListeners: (channel) => {
+    ipcRenderer.removeAllListeners(channel);
+  },
+  
+  // Window control convenience methods
+  showWindow: () => {
+    ipcRenderer.send('show-window');
+  },
+  
+  hideWindow: () => {
+    ipcRenderer.send('hide-window');
+  },
+  
+  // UserData operations
+  getUserData: (key, nestedKey) => {
+    return new Promise((resolve, reject) => {
+      ipcRenderer.once('user-data-response', (event, response) => {
+        
+        if (response.success) {
+          // Handle IPC serialization issues - sometimes objects get lost
+          if (response.value === undefined || response.value === null) {
+            
+            // Try to get the value directly from main process via another IPC call
+            ipcRenderer.send('get-user-data-direct', { key, nestedKey });
+            ipcRenderer.once('user-data-direct-response', (event, directResponse) => {
+              if (directResponse.success) {
+                // Parse the JSON string back to object
+                const parsedValue = directResponse.value ? JSON.parse(directResponse.value) : null;
+                resolve(parsedValue);
+              } else {
+                resolve(null);
+              }
+            });
+          } else {
+            resolve(response.value);
+          }
+        } else {
+          reject(new Error(response.error || 'Failed to get user data'));
+        }
+      });
+      ipcRenderer.send('get-user-data', { key, nestedKey });
+    });
+  },
+  
+  setUserData: (key, nestedKey, value) => {
+    return new Promise((resolve, reject) => {
+      ipcRenderer.once('user-data-response', (event, response) => {
+        if (response.success) {
+          resolve(response.value);
+        } else {
+          reject(new Error(response.error || 'Failed to set user data'));
+        }
+      });
+      ipcRenderer.send('set-user-data', { key, nestedKey, value });
+    });
+  },
+  
+  removeUserData: (key, nestedKey) => {
+    return new Promise((resolve, reject) => {
+      ipcRenderer.once('user-data-response', (event, response) => {
+        if (response.success) {
+          resolve(true);
+        } else {
+          reject(new Error(response.error || 'Failed to remove user data'));
+        }
+      });
+      ipcRenderer.send('remove-user-data', { key, nestedKey });
+    });
+  }
+});