@danieltmn/openbridge 0.2.0 → 0.4.0

package/src/auth.js

@@ -38,8 +38,16 @@ function parseCookies(header) {
     return out;
 }
 
+// Detras del tunel el server recibe los pedidos desde loopback (el tunel corre
+// en la misma maquina y reenvia a 127.0.0.1). Solo en ese caso confiamos en
+// X-Forwarded-Proto: un cliente que llegara directo por la red no puede forzar
+// el flag Secure de la cookie. Sin info de socket (tests), se confia.
 function isSecure(req) {
-    const proto = req.headers['x-forwarded-proto'];
+    if (req.socket && req.socket.encrypted) return true;
+    const remote = req.socket && req.socket.remoteAddress;
+    const loopback = !remote || remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+    if (!loopback) return false;
+    const proto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim().toLowerCase();
     return proto === 'https';
 }
 
@@ -51,10 +59,10 @@ function serializeCookie(name, value, req, maxAge) {
 }
 
 // ---------------------------------------------------------------------------
-// Sesion
+// Sesion (ligada al id del usuario; el rol se lee siempre del server)
 // ---------------------------------------------------------------------------
-function makeSession(app, username, csrf, exp) {
-    const payload = b64url(JSON.stringify({ u: username, c: csrf, e: exp }));
+function makeSession(app, user, csrf, exp) {
+    const payload = b64url(JSON.stringify({ u: user.id, pv: parseInt(user.pv, 10) || 1, c: csrf, e: exp }));
     return payload + '.' + sign(payload, app.csrfSecret);
 }
 function readSession(app, req) {
@@ -68,8 +76,11 @@ function readSession(app, req) {
     if (!safeEqual(sign(payload, app.csrfSecret), sig)) return null;
     let data;
     try { data = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8')); } catch (e) { return null; }
-    if (!data || data.u !== app.username || typeof data.e !== 'number' || data.e < Math.floor(Date.now() / 1000)) return null;
-    return data;
+    if (!data || typeof data.e !== 'number' || data.e < Math.floor(Date.now() / 1000)) return null;
+    const user = config.userById(app, data.u);
+    if (!user || user.disabled) return null;
+    if ((parseInt(user.pv, 10) || 1) !== (parseInt(data.pv, 10) || 1)) return null;
+    return { id: user.id, name: user.name, role: user.role, u: user.id, c: data.c, e: data.e };
 }
 function currentCsrf(app, req) {
     const s = readSession(app, req);
@@ -80,6 +91,14 @@ function requireLogin(app, req, res) {
     if (!s) { json(res, 401, { ok: false, error: 'No autorizado' }); return null; }
     return s;
 }
+// Exige que el usuario tenga uno de los roles indicados.
+function requireRole(app, req, res, roles) {
+    const s = readSession(app, req);
+    if (!s) { json(res, 401, { ok: false, error: 'No autorizado' }); return null; }
+    const allowed = Array.isArray(roles) ? roles : [roles];
+    if (!allowed.includes(s.role)) { json(res, 403, { ok: false, error: 'Permiso insuficiente' }); return null; }
+    return s;
+}
 function requireCsrf(app, req, res) {
     const s = readSession(app, req);
     const given = String(req.headers['x-csrf'] || '').trim();
@@ -90,13 +109,13 @@ function requireCsrf(app, req, res) {
     return s;
 }
 
-function startSession(app, req, res, username) {
+function startSession(app, req, res, user) {
     const csrf = crypto.randomBytes(16).toString('hex');
     const exp = Math.floor(Date.now() / 1000) + REMEMBER_DAYS * 86400;
-    const token = makeSession(app, username, csrf, exp);
+    const token = makeSession(app, user, csrf, exp);
     res.setHeader('Set-Cookie', [
         serializeCookie(SESSION_COOKIE, token, req, REMEMBER_DAYS * 86400),
-        serializeCookie(REMEMBER_COOKIE, makeRemember(app, username), req, REMEMBER_DAYS * 86400),
+        serializeCookie(REMEMBER_COOKIE, makeRemember(app, user), req, REMEMBER_DAYS * 86400),
     ]);
     return csrf;
 }
@@ -107,9 +126,9 @@ function endSession(req, res) {
     ]);
 }
 
-function makeRemember(app, username) {
+function makeRemember(app, user) {
     const exp = Math.floor(Date.now() / 1000) + REMEMBER_DAYS * 86400;
-    const payload = username + '|' + exp;
+    const payload = user.id + '|' + exp + '|' + (parseInt(user.pv, 10) || 1);
     return b64url(payload) + '.' + sign(payload, app.csrfSecret);
 }
 // Re-autentica desde la cookie remember si la sesion se perdio.
@@ -125,10 +144,12 @@ function rememberAutoLogin(app, req, res) {
     let plain;
     try { plain = Buffer.from(payload, 'base64url').toString('utf8'); } catch (e) { return false; }
     const parts = plain.split('|');
-    if (parts.length !== 2) return false;
-    const [user, exp] = parts;
-    if (user !== app.username || !/^\d+$/.test(exp) || parseInt(exp, 10) < Math.floor(Date.now() / 1000)) return false;
+    if (parts.length !== 3) return false;
+    const [uid, exp, pv] = parts;
+    if (!/^\d+$/.test(exp) || parseInt(exp, 10) < Math.floor(Date.now() / 1000)) return false;
     if (!safeEqual(sign(payload, app.csrfSecret), sig)) return false;
+    const user = config.userById(app, uid);
+    if (!user || user.disabled || (parseInt(user.pv, 10) || 1) !== (parseInt(pv, 10) || 1)) return false;
     startSession(app, req, res, user);
     return true;
 }
@@ -141,10 +162,10 @@ const LOGIN_WINDOW_MS = 15 * 60 * 1000;
 const LOGIN_LOCK_MS = 15 * 60 * 1000;
 const loginAttempts = new Map();
 
-function clientKey(req) {
+function clientKey(req, user) {
     const xff = String(req.headers['x-forwarded-for'] || '').split(',')[0].trim();
     const ip = xff || (req.socket && req.socket.remoteAddress) || 'desconocido';
-    return String(ip);
+    return String(ip) + '|' + String(user || '').trim().toLowerCase();
 }
 function pruneLoginAttempts(now) {
     for (const [key, st] of loginAttempts) {
@@ -152,25 +173,25 @@ function pruneLoginAttempts(now) {
     }
 }
 // Segundos restantes de bloqueo (0 = puede intentar).
-function loginLockRemaining(req) {
+function loginLockRemaining(req, user) {
     const now = Date.now();
     pruneLoginAttempts(now);
-    const st = loginAttempts.get(clientKey(req));
+    const st = loginAttempts.get(clientKey(req, user));
     if (!st || !st.lockUntil) return 0;
     const left = st.lockUntil - now;
     return left > 0 ? Math.ceil(left / 1000) : 0;
 }
-function loginRecordFailure(req) {
+function loginRecordFailure(req, user) {
     const now = Date.now();
-    const key = clientKey(req);
+    const key = clientKey(req, user);
     let st = loginAttempts.get(key);
     if (!st || (!st.lockUntil && now - st.first > LOGIN_WINDOW_MS)) st = { count: 0, first: now, lockUntil: 0 };
     st.count++;
     if (st.count >= LOGIN_MAX_ATTEMPTS) st.lockUntil = now + LOGIN_LOCK_MS;
     loginAttempts.set(key, st);
 }
-function loginClear(req) {
-    loginAttempts.delete(clientKey(req));
+function loginClear(req, user) {
+    loginAttempts.delete(clientKey(req, user));
 }
 
 // ---------------------------------------------------------------------------
@@ -197,7 +218,7 @@ function json(res, code, data) {
 module.exports = {
     SESSION_COOKIE, REMEMBER_COOKIE,
     parseCookies, serializeCookie, isSecure,
-    makeSession, readSession, currentCsrf, requireLogin, requireCsrf,
+    makeSession, readSession, currentCsrf, requireLogin, requireRole, requireCsrf,
     startSession, endSession, rememberAutoLogin,
     loginLockRemaining, loginRecordFailure, loginClear,
     checkBridgeToken, safeEqual, json,

package/src/bridge/bridge.js

@@ -12,7 +12,7 @@
  */
 'use strict';
 
-const { spawn } = require('node:child_process');
+const { spawn, spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -1549,6 +1549,77 @@ async function handleFsCommand(cmd) {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Cambios del proyecto (git status / git diff) para revisar lo que tocó el
+// agente desde el celular. Corre git en la carpeta de la sesión (validada
+// dentro del workspace, igual que proc_start).
+// ---------------------------------------------------------------------------
+function parseGitStatus(text) {
+    const files = [];
+    let branch = '';
+    for (const line of String(text).split('\n')) {
+        if (line === '') continue;
+        if (line.startsWith('## ')) { branch = line.slice(3).trim(); continue; }
+        const status = line.slice(0, 2).trim() || '?';
+        let p = line.slice(3);
+        const arrow = p.indexOf(' -> ');
+        if (arrow >= 0) p = p.slice(arrow + 4);
+        files.push({ status, path: p });
+    }
+    return { branch, files };
+}
+
+function gitIn(folder, args, timeout = 30000) {
+    const r = spawnSync('git', ['-C', folder].concat(args), {
+        encoding: 'utf8',
+        timeout,
+        windowsHide: true,
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    if (r.error) throw new Error(r.error.message || 'no se pudo ejecutar git');
+    const text = String(r.stdout || '');
+    return { code: r.status, text, err: String(r.stderr || '').trim() };
+}
+
+async function handleGitCommand(cmd) {
+    let folder;
+    try { folder = procResolveFolder(cmd.args && cmd.args[0]); }
+    catch (e) {
+        await api('command_done', { id: cmd.id, ok: false, text: '', error: e.message }, cmd._t);
+        return;
+    }
+    try {
+        if (cmd.name === 'git_status') {
+            const r = gitIn(folder, ['status', '--porcelain=v1', '-b', '--untracked-files=all']);
+            if (r.code !== 0) throw new Error(r.err || 'no es un repositorio git');
+            await api('command_done', { id: cmd.id, ok: true, text: JSON.stringify(parseGitStatus(r.text)), error: '' }, cmd._t);
+        } else if (cmd.name === 'git_checkout') {
+            // Revierte cambios de archivos RASTREADOS dentro de la carpeta de la
+            // sesion. Sin 2do argumento revierte todo (`.`); con argumento,
+            // solo ese archivo relativo (sin `..` ni rutas absolutas).
+            let target = (cmd.args && cmd.args.length > 1) ? String(cmd.args[1]) : '.';
+            if (target !== '.') {
+                if (path.isAbsolute(target) || target.split(/[\\/]/).includes('..')) {
+                    throw new Error('ruta invalida');
+                }
+            }
+            const r = gitIn(folder, ['checkout', '--', target]);
+            if (r.code !== 0) throw new Error(r.err || 'no se pudo revertir');
+            await api('command_done', { id: cmd.id, ok: true, text: JSON.stringify({ reverted: target }), error: '' }, cmd._t);
+        } else {
+            // diff HEAD: cambios preparados + sin preparar. `fs_result` admite
+            // respuestas mas grandes que command_done (8000 car.).
+            const r = gitIn(folder, ['--no-pager', 'diff', 'HEAD', '--no-color', '--no-ext-diff', '--no-renames']);
+            if (r.code !== 0) throw new Error(r.err || 'no es un repositorio git');
+            await api('fs_result', { id: cmd.id, ok: true, text: JSON.stringify({ diff: r.text }), error: '' }, cmd._t);
+        }
+        log('git ' + cmd.name + ' ok en ' + folder);
+    } catch (e) {
+        await api('command_done', { id: cmd.id, ok: false, text: '', error: e.message }, cmd._t);
+        log('git ' + cmd.name + ' error: ' + e.message);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Procesa comandos read-only encolados por la web.
 // ---------------------------------------------------------------------------
@@ -2044,6 +2115,11 @@ async function handleCommand(cmd) {
         await handleFsCommand(cmd);
         return;
     }
+    // Cambios git del proyecto (status/diff/revertir).
+    if (cmd.name === 'git_status' || cmd.name === 'git_diff' || cmd.name === 'git_checkout') {
+        await handleGitCommand(cmd);
+        return;
+    }
     // Túneles también son del puente (procesos de esta PC).
     if (cmd.name === 'tunnel_start') { await tunnelStart(cmd); return; }
     if (cmd.name === 'tunnel_stop') { await tunnelStop(cmd); return; }

package/src/cli.js

@@ -183,6 +183,12 @@ async function cmdInit(argv) {
         console.log('Usa --force para reconfigurar (se pisan config.json/app.json).');
         return 0;
     }
+    if (paths.exists() && flags.force) {
+        const prev = config.readApp();
+        if ((prev.users || []).length > 1) {
+            console.log('aviso: --force deja un unico usuario admin; se pierden los demas usuarios.');
+        }
+    }
 
     if (stopRunningServer()) {
         console.log('Habia un server corriendo; lo detuve para reconfigurar (reinicialo con `openbridge server`).');
@@ -235,16 +241,16 @@ async function cmdInit(argv) {
         bridgeId: id,
         bridgeName: name,
     };
+    const adminName = flags.user || 'admin';
     const appCfg = {
         ...config.DEFAULT_APP,
         port,
         host: '127.0.0.1',
-        username: flags.user || 'admin',
-        password: config.hashPassword(password),
+        users: [config.makeUser(adminName, password, 'admin')],
         csrfSecret,
         bridgeToken,
         vapid,
-        tunnel: { provider, domain: '' },
+        tunnel: { provider, domain: flags.domain ? String(flags.domain) : '' },
     };
     config.writeBridge(bridgeCfg);
     config.writeApp(appCfg);
@@ -259,7 +265,7 @@ async function cmdInit(argv) {
     console.log('  workspace : ' + workspace);
     console.log('  puente    : ' + id + ' (' + name + ')');
     console.log('  URL local : http://127.0.0.1:' + port + '/chat.php');
-    console.log('  usuario   : ' + appCfg.username);
+    console.log('  usuario   : ' + adminName);
     console.log('  contrasena: ' + password + (generated ? '  (generada)' : ''));
     console.log('  tunel     : ' + provider);
     console.log('  carpetas  : ' + folders.length + ' en folders.json');
@@ -488,6 +494,51 @@ async function cmdQr() {
     return 0;
 }
 
+// Muestra o cambia el proveedor de tunel (y su dominio fijo) sin reconfigurar
+// todo. Cambiar el proveedor requiere reiniciar el server.
+async function cmdTunnel(argv) {
+    const { flags, _ } = parseArgs(argv);
+    if (!paths.exists()) {
+        console.error('No hay configuracion. Corre primero: openbridge init');
+        return 1;
+    }
+    const app = config.readApp();
+    const cur = app.tunnel || { provider: 'tunnelmole', domain: '' };
+    const arg = String(_[0] || '').toLowerCase();
+
+    if (arg === '' || arg === 'status' || arg === 'show') {
+        const rt = readRuntime();
+        const running = rt && pidAlive(rt.pid);
+        console.log('proveedor : ' + (cur.provider || 'tunnelmole'));
+        console.log('dominio   : ' + (cur.domain || '(aleatorio)'));
+        console.log('estado    : ' + (running ? 'corriendo' : 'detenido'));
+        if (running && rt.publicUrl) console.log('publico   : ' + rt.publicUrl);
+        return 0;
+    }
+
+    let provider = arg;
+    if (provider === 'cloudflared') provider = 'cloudflare';
+    if (!['tunnelmole', 'ngrok', 'cloudflare', 'none'].includes(provider)) {
+        console.error('Proveedor desconocido: ' + arg + ' (usar tunnelmole|ngrok|cloudflare|none)');
+        return 1;
+    }
+    const domain = flags.domain !== undefined ? String(flags.domain).trim() : String(cur.domain || '');
+    app.tunnel = { provider, domain };
+    config.writeApp(app);
+    console.log('Tunel configurado: ' + provider + (domain ? '  (dominio ' + domain + ')' : ''));
+    if (provider === 'ngrok' && !domain) {
+        console.log('aviso: ngrok sin dominio fijo da URL aleatoria; pasá --domain <sub.ngrok.app> para una estable.');
+    }
+    if (provider === 'cloudflare' && domain) {
+        console.log('aviso: el quick tunnel de cloudflared ignora el dominio (URL aleatoria).');
+    }
+    const rt = readRuntime();
+    if (rt && pidAlive(rt.pid)) {
+        console.log('Hay un server corriendo: reinicialo para aplicar (openbridge stop && openbridge server).');
+    }
+    return 0;
+}
+
 async function cmdLogs(argv) {
     const { flags } = parseArgs(argv);
     const n = parseInt(flags.n || '40', 10) || 40;
@@ -648,23 +699,114 @@ async function cmdPasswd(argv) {
         return 1;
     }
     const app = config.readApp();
+    const name = String(flags.user || (app.users[0] && app.users[0].name) || 'admin');
+    const user = config.findUser(app, name);
+    if (!user) {
+        console.error('Usuario no encontrado: ' + name);
+        return 1;
+    }
     const interactive = !flags.yes && process.stdin.isTTY;
     let password = flags.password || '';
-    if (!password && interactive) password = await askHidden('Nueva contrasena (enter = generar): ');
+    if (!password && interactive) password = await askHidden('Nueva contrasena para "' + name + '" (enter = generar): ');
     let generated = false;
     if (!password) {
         password = config.randomToken(12);
         generated = true;
     }
     if (stopRunningServer()) console.log('Habia un server corriendo; lo detuve para aplicar el cambio.');
-    app.password = config.hashPassword(password);
+    user.password = config.hashPassword(password);
+    user.pv = (parseInt(user.pv, 10) || 1) + 1; // invalida las sesiones abiertas
     config.writeApp(app);
-    console.log('Contrasena actualizada para "' + app.username + '".');
+    console.log('Contrasena actualizada para "' + user.name + '".');
     console.log('  contrasena: ' + password + (generated ? '  (generada)' : ''));
     console.log('  volve a arrancar: openbridge server');
     return 0;
 }
 
+// ---------------------------------------------------------------------------
+// users: administracion de usuarios y roles (solo desde la CLI local)
+// ---------------------------------------------------------------------------
+async function cmdUsers(argv) {
+    const { flags, _ } = parseArgs(argv);
+    if (!paths.exists()) {
+        console.error('No hay configuracion en ' + paths.home() + '. Corre primero: openbridge init');
+        return 1;
+    }
+    const app = config.readApp();
+    const sub = String(_[0] || 'list').toLowerCase();
+    const name = _[1] || flags.name;
+
+    const persist = (msg) => {
+        if (stopRunningServer()) console.log('Habia un server corriendo; lo detuve para aplicar el cambio.');
+        config.writeApp(app);
+        console.log(msg);
+        console.log('  volve a arrancar: openbridge server');
+    };
+
+    if (sub === 'list' || sub === 'ls') {
+        const users = app.users || [];
+        if (!users.length) { console.log('(sin usuarios)'); return 0; }
+        for (const u of users) {
+            console.log((u.disabled ? 'x' : 'o') + '  ' + u.name.padEnd(16) + '[' + u.role + ']');
+        }
+        return 0;
+    }
+
+    if (sub === 'add') {
+        if (!config.userValidName(name)) { console.error('Nombre invalido (letras, numeros, . _ -; 1-32).'); return 1; }
+        if (config.findUser(app, name)) { console.error('Ya existe el usuario "' + name + '".'); return 1; }
+        let password = flags.password || '';
+        if (!password && process.stdin.isTTY) password = await askHidden('Contrasena para "' + name + '" (enter = generar): ');
+        let generated = false;
+        if (!password) { password = config.randomToken(12); generated = true; }
+        const role = config.USER_ROLES.includes(flags.role) ? flags.role : 'user';
+        app.users.push(config.makeUser(name, password, role));
+        persist('Usuario "' + name + '" agregado [' + role + '].');
+        console.log('  contrasena: ' + password + (generated ? '  (generada)' : ''));
+        return 0;
+    }
+
+    if (sub === 'remove' || sub === 'del' || sub === 'rm') {
+        const user = config.findUser(app, name);
+        if (!user) { console.error('Usuario no encontrado: ' + name); return 1; }
+        if (user.role === 'admin' && config.adminCount(app) <= 1) { console.error('No podes borrar al ultimo admin.'); return 1; }
+        app.users = app.users.filter((u) => u.id !== user.id);
+        persist('Usuario "' + user.name + '" borrado.');
+        return 0;
+    }
+
+    if (sub === 'passwd' || sub === 'password') {
+        if (!name) { console.error('Uso: openbridge users passwd <nombre> [--password <clave>]'); return 1; }
+        const extra = ['--user', name];
+        if (flags.password) extra.push('--password', String(flags.password));
+        return cmdPasswd(extra);
+    }
+
+    if (sub === 'role') {
+        const user = config.findUser(app, name);
+        if (!user) { console.error('Usuario no encontrado: ' + name); return 1; }
+        const role = String(_[2] || flags.role || '').toLowerCase();
+        if (!config.USER_ROLES.includes(role)) { console.error('Rol invalido (admin|user).'); return 1; }
+        if (user.role === 'admin' && role !== 'admin' && config.adminCount(app) <= 1) { console.error('No podes quitarle el admin al ultimo admin.'); return 1; }
+        user.role = role;
+        persist('Rol de "' + user.name + '" -> ' + role + '.');
+        return 0;
+    }
+
+    if (sub === 'disable' || sub === 'enable') {
+        const user = config.findUser(app, name);
+        if (!user) { console.error('Usuario no encontrado: ' + name); return 1; }
+        const disabled = sub === 'disable';
+        if (disabled && user.role === 'admin' && config.adminCount(app) <= 1) { console.error('No podes deshabilitar al ultimo admin.'); return 1; }
+        user.disabled = disabled;
+        persist('Usuario "' + user.name + '" ' + (disabled ? 'deshabilitado' : 'habilitado') + '.');
+        return 0;
+    }
+
+    console.error('Uso: openbridge users [list|add|remove|passwd|role|disable|enable] [nombre] [--role admin|user] [--password <clave>]');
+    return 1;
+}
+
 // ---------------------------------------------------------------------------
 // autostart
 // ---------------------------------------------------------------------------
@@ -781,10 +923,12 @@ function usage() {
     console.log('');
     console.log('  init      Configura la casa (workspace, contrasena, tunel)');
     console.log('  server    Arranca en segundo plano (muestra el estado al levantar)');
-    console.log('  passwd    Cambia la contrasena de acceso (--password <clave>)');
+    console.log('  passwd    Cambia la contrasena de acceso (--user <nombre> --password <clave>)');
+    console.log('  users     Usuarios y roles (list|add|remove|passwd|role|disable|enable)');
     console.log('  stop      Detiene el server en segundo plano');
     console.log('  status    Estado del server, puente y chats');
     console.log('  qr        Muestra la URL (publica o local) como QR para el celular');
+    console.log('  tunnel    Muestra o cambia el proveedor de tunel (tunnelmole|ngrok|cloudflare|none) [--domain]');
     console.log('  logs      Ultimas lineas de los logs (--follow --server --bridge)');
     console.log('  bridge    Corre solo el puente (--api --token --id --name)');
     console.log('  import    Trae data/ de OpenConex (<data-dir> [--force])');
@@ -793,7 +937,7 @@ function usage() {
     console.log('  doctor    Verifica Node, opencode, configuracion y puerto');
     console.log('');
     console.log('Opciones comunes: --dir <ruta>  (casa portable; default: directorio actual)');
-    console.log('init: --workspace --name --id --port --password --tunnel --yes --force');
+    console.log('init: --workspace --name --id --port --password --tunnel --domain --yes --force');
     console.log('server: --port --no-tunnel --stream   (sin --stream corre en segundo plano)');
 }
 
@@ -812,10 +956,12 @@ async function main(argv) {
     switch (cmd) {
         case 'init': return cmdInit(args.slice(1));
         case 'passwd': case 'password': return cmdPasswd(args.slice(1));
+        case 'users': case 'user': return cmdUsers(args.slice(1));
         case 'server': case 'start': return cmdServer(args.slice(1));
         case 'stop': return cmdStop();
         case 'status': return cmdStatus();
         case 'qr': return cmdQr();
+        case 'tunnel': return cmdTunnel(args.slice(1));
         case 'logs': return cmdLogs(args.slice(1));
         case 'bridge': return cmdBridge(args.slice(1));
         case 'import': return cmdImport(args.slice(1));

package/src/config.js

@@ -27,14 +27,17 @@ const DEFAULT_APP = {
     port: 8799,
     host: '127.0.0.1',
     baseUrl: '',
-    username: 'admin',
-    password: null,          // { algo, salt, hash, keylen }
+    username: 'admin',       // legado (migra a users[0])
+    password: null,          // legado (migra a users[0])
+    users: [],               // [{ id, name, role, password, pv, created, disabled }]
     csrfSecret: '',
     bridgeToken: '',
     vapid: { publicKey: '', privateKey: '' },
     tunnel: { provider: 'tunnelmole', domain: '' },
 };
 
+const USER_ROLES = ['admin', 'user'];
+
 function readJsonFile(file, fallback) {
     try {
         const raw = fs.readFileSync(file, 'utf8');
@@ -62,10 +65,17 @@ function readApp() {
     const data = { ...DEFAULT_APP, ...readJsonFile(paths.appConfigPath(), DEFAULT_APP) };
     data.vapid = { ...DEFAULT_APP.vapid, ...(data.vapid || {}) };
     data.tunnel = { ...DEFAULT_APP.tunnel, ...(data.tunnel || {}) };
+    normalizeApp(data);
     return data;
 }
 function writeApp(cfg) {
-    writeJsonFile(paths.appConfigPath(), cfg);
+    const out = { ...cfg };
+    // Una vez migrado a `users`, no dejamos la contrasena legado suelta.
+    if (Array.isArray(out.users) && out.users.length) {
+        delete out.username;
+        delete out.password;
+    }
+    writeJsonFile(paths.appConfigPath(), out);
 }
 
 function randomToken(bytes = 32) {
@@ -93,6 +103,65 @@ function verifyPassword(password, stored) {
     return crypto.timingSafeEqual(calc, expected);
 }
 
+// ---------------------------------------------------------------------------
+// Usuarios (multiusuario con roles admin|user). El modelo viejo de un solo
+// `username`+`password` se migra solo a `users[0]`.
+// ---------------------------------------------------------------------------
+function userValidName(name) {
+    return typeof name === 'string' && /^[A-Za-z0-9._-]{1,32}$/.test(name);
+}
+function makeUser(name, password, role = 'user') {
+    return {
+        id: 'u_' + crypto.randomBytes(6).toString('hex'),
+        name: String(name),
+        role: USER_ROLES.includes(role) ? role : 'user',
+        password: hashPassword(password),
+        pv: 1,
+        created: new Date().toISOString(),
+        disabled: false,
+    };
+}
+// Devuelve la lista de usuarios, sintetizando el admin legado si hace falta.
+function userList(app) {
+    if (app && Array.isArray(app.users) && app.users.length) return app.users;
+    if (app && app.password && app.password.hash) {
+        return [{
+            id: 'u1',
+            name: (typeof app.username === 'string' && app.username) ? app.username : 'admin',
+            role: 'admin',
+            password: app.password,
+            pv: 1,
+            created: '',
+            disabled: false,
+        }];
+    }
+    return [];
+}
+function normalizeApp(app) {
+    if (!app || typeof app !== 'object') return app;
+    if (!Array.isArray(app.users)) app.users = [];
+    app.users = app.users.filter((u) => u && typeof u === 'object' && typeof u.name === 'string' && u.password);
+    if (!app.users.length) {
+        const migrated = userList(app);
+        if (migrated.length) app.users = migrated;
+    }
+    return app;
+}
+function findUser(app, name) {
+    const n = String(name || '').trim().toLowerCase();
+    if (n === '') return null;
+    return userList(app).find((u) => String(u.name).toLowerCase() === n) || null;
+}
+function userById(app, id) {
+    return userList(app).find((u) => u.id === id) || null;
+}
+function verifyUserPassword(user, password) {
+    return !!user && verifyPassword(password, user.password);
+}
+function adminCount(app) {
+    return userList(app).filter((u) => u.role === 'admin' && !u.disabled).length;
+}
+
 // Claves VAPID (P-256) en el formato que espera web-push (base64url).
 function genVapid() {
     const webpush = require('web-push');
@@ -101,8 +170,9 @@ function genVapid() {
 }
 
 module.exports = {
-    DEFAULT_BRIDGE, DEFAULT_APP,
+    DEFAULT_BRIDGE, DEFAULT_APP, USER_ROLES,
     readBridge, writeBridge, readApp, writeApp,
     randomToken, hashPassword, verifyPassword, genVapid,
+    userValidName, makeUser, userList, normalizeApp, findUser, userById, verifyUserPassword, adminCount,
     readJsonFile, writeJsonFile,
 };