@danieltmn/openbridge 0.3.0 → 0.5.0

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,12 +241,12 @@ 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,
@@ -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');
@@ -594,8 +600,8 @@ async function cmdLogs(argv) {
 // ---------------------------------------------------------------------------
 async function cmdBridge(argv) {
     const { flags } = parseArgs(argv);
-    if (!paths.exists()) {
-        console.error('No hay configuracion en ' + paths.home() + '. Corre primero: openbridge init');
+    if (!fs.existsSync(paths.configPath())) {
+        console.error('No hay configuracion de puente en ' + paths.home() + '. Corre primero: openbridge join <url> o openbridge init');
         return 1;
     }
     // Permite apuntar a otro hub sin editar config.json a mano.
@@ -614,6 +620,41 @@ async function cmdBridge(argv) {
     return new Promise((resolve) => child.on('exit', (code) => resolve(code || 0)));
 }
 
+// ---------------------------------------------------------------------------
+// join: esta PC se suma como puente de un hub (otra PC con `openbridge server`).
+// Guarda la URL/token/identidad en config.json y arranca el puente.
+// ---------------------------------------------------------------------------
+async function cmdJoin(argv) {
+    const { flags, _ } = parseArgs(argv);
+    const url = String(_[0] || flags.api || '').trim();
+    if (!url || !/^https?:\/\//i.test(url)) {
+        console.error('Uso: openbridge join <url-del-hub> [--token <t>] [--id <pc>] [--name "<nombre>"] [--no-start]');
+        console.error('Ej.:  openbridge join https://mi-pc.trycloudflare.com --token <t> --id pc2 --name "PC oficina"');
+        return 1;
+    }
+    paths.ensureDirs();
+    const cfg = config.readBridge();
+    cfg.apiUrl = url.replace(/\/+$/, '');
+    if (typeof flags.token === 'string') cfg.apiToken = flags.token;
+    if (typeof flags.id === 'string') cfg.bridgeId = sanitizeId(flags.id);
+    else if (!cfg.bridgeId) cfg.bridgeId = sanitizeId(os.hostname());
+    if (typeof flags.name === 'string' && flags.name.trim()) cfg.bridgeName = flags.name.trim().slice(0, 40);
+    else if (!cfg.bridgeName) cfg.bridgeName = cfg.bridgeId;
+    config.writeBridge(cfg);
+
+    console.log('Puente vinculado al hub: ' + cfg.apiUrl);
+    console.log('  id     : ' + cfg.bridgeId);
+    console.log('  nombre : ' + cfg.bridgeName);
+    if (!cfg.apiToken) console.log('aviso: sin token (--token). Solo sirve si el hub no exige token del puente.');
+    if (flags['no-start']) {
+        console.log('Arrancalo cuando quieras con: openbridge bridge');
+        return 0;
+    }
+    console.log('');
+    console.log('Arrancando el puente (Ctrl+C para salir)...');
+    return cmdBridge([]);
+}
+
 // ---------------------------------------------------------------------------
 // import / reset (datos)
 // ---------------------------------------------------------------------------
@@ -693,23 +734,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
 // ---------------------------------------------------------------------------
@@ -818,6 +950,53 @@ async function cmdDoctor() {
     return ok ? 0 : 1;
 }
 
+// ---------------------------------------------------------------------------
+// update: compara con npm y, con --yes, actualiza la instalacion global.
+// ---------------------------------------------------------------------------
+function npmRun(args) {
+    return spawnSync('npm', args, { encoding: 'utf8', shell: process.platform === 'win32', windowsHide: true });
+}
+
+async function cmdUpdate(argv) {
+    const { flags } = parseArgs(argv);
+    const tag = (typeof flags.tag === 'string' && flags.tag) ? flags.tag : 'latest';
+    const pkg = '@danieltmn/openbridge';
+    const spec = pkg + '@' + tag;
+    console.log('Version actual: ' + VERSION);
+
+    const view = npmRun(['view', spec, 'version', '--json']);
+    let latest = '';
+    try { latest = String(JSON.parse(view.stdout)).trim(); } catch (e) { latest = String(view.stdout || '').trim().replace(/"/g, ''); }
+    if (view.status !== 0 || !/^\d+\.\d+\.\d+/.test(latest)) {
+        console.error('No se pudo consultar npm (' + tag + '): ' + ((view.stderr || '').trim() || 'revisa tu conexion'));
+        return 1;
+    }
+    console.log('Disponible (' + tag + '): ' + latest);
+    if (latest === VERSION) {
+        console.log('Ya estas en la ultima version.');
+        return 0;
+    }
+    if (flags.check) {
+        console.log('Hay una version nueva. Corre: openbridge update --yes');
+        return 0;
+    }
+    if (!flags.yes && !flags.y) {
+        console.log('');
+        console.log('Para actualizar ahora:');
+        console.log('  openbridge update --yes        (o)  npm i -g ' + spec);
+        return 0;
+    }
+
+    console.log('Actualizando a ' + spec + '...');
+    const r = spawnSync('npm', ['i', '-g', spec], { stdio: 'inherit', shell: process.platform === 'win32', windowsHide: true });
+    if (r.status !== 0) {
+        console.error('La actualizacion fallo. Proba a mano: npm i -g ' + spec);
+        return 1;
+    }
+    console.log('Listo. Reinicia el server para usar la version nueva: openbridge stop && openbridge server');
+    return 0;
+}
+
 // ---------------------------------------------------------------------------
 function usage() {
     console.log('OpenBridge ' + VERSION + ' — tu opencode en el celular, sin hosting');
@@ -826,17 +1005,20 @@ 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('  join      Vincula esta PC como puente de un hub (<url> --token --id --name)');
     console.log('  import    Trae data/ de OpenConex (<data-dir> [--force])');
     console.log('  reset     Borra todos los chats/datos (--session <id> --yes)');
     console.log('  autostart Instala/quita el arranque automatico (install|remove)');
     console.log('  doctor    Verifica Node, opencode, configuracion y puerto');
+    console.log('  update    Busca una version nueva en npm (--yes para actualizar)');
     console.log('');
     console.log('Opciones comunes: --dir <ruta>  (casa portable; default: directorio actual)');
     console.log('init: --workspace --name --id --port --password --tunnel --domain --yes --force');
@@ -858,6 +1040,7 @@ 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();
@@ -865,10 +1048,12 @@ async function main(argv) {
         case 'tunnel': return cmdTunnel(args.slice(1));
         case 'logs': return cmdLogs(args.slice(1));
         case 'bridge': return cmdBridge(args.slice(1));
+        case 'join': return cmdJoin(args.slice(1));
         case 'import': return cmdImport(args.slice(1));
         case 'reset': return cmdReset(args.slice(1));
         case 'autostart': return cmdAutostart(args.slice(1));
         case 'doctor': return cmdDoctor();
+        case 'update': return cmdUpdate(args.slice(1));
         case 'version': case '-v': case '--version': console.log(VERSION); return 0;
         case 'help': case '-h': case '--help': usage(); return 0;
         default:

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,
 };