@danieltmn/openbridge 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,52 @@ Todos los cambios relevantes de OpenBridge. Formato basado en
 [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/) y
 [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.5.0] - 2026-09-14
+
+### Agregado
+
+- Comando `openbridge update` (compara con npm; `--yes` actualiza la instalacion
+  global).
+- Comando `openbridge join <url>` para sumar una PC como puente de un hub:
+  persiste `apiUrl`/`apiToken`/`bridgeId` y arranca el puente (`--no-start` solo
+  guarda).
+- `npm run lint` (`scripts/lint.mjs`): `node --check` sobre todo el JS; corre en
+  CI.
+- Test end-to-end del puente con `opencode` mockeado (`test/bridge.test.js`) y
+  tests del CLI (`test/cli.test.js`).
+- **MCP**: vista en la web y comando de chat `/mcp` que muestran los servidores
+  MCP de opencode y su estado (`opencode mcp list`); comando de puente
+  `mcp_list`.
+- `CONTRIBUTING.md`.
+
+### Cambiado
+
+- Claves internas `ocx_*` renombradas a `ob_*` con migracion automatica
+  (localStorage y cookie de tema). Se mantienen como compatibilidad el env
+  `OPENCONEX_HOME` y el bin `openconex` (deprecados).
+- `config.command` puede apuntar a un script de Node (`.js`/`.mjs`/`.cjs`): se
+  ejecuta con el `node` actual (wrappers propios y pruebas con CLI simulado).
+
+## [0.4.0] - 2026-09-14
+
+### Agregado
+
+- **Multiusuario** con roles `admin`/`user`: login con usuario + contrasena,
+  sesion ligada al usuario y a la version de contrasena, rate limit por
+  IP+usuario, y comando CLI `users`
+  (`list`/`add`/`remove`/`passwd`/`role`/`disable`/`enable`); `passwd --user`.
+- Gate server-side: `session_delete` y los comandos mutantes del puente
+  (procesos, tuneles, revertir) solo para `admin`; la web oculta esos controles.
+- **Autor** en cada mensaje (auditoria) y muestra del usuario en el sidebar.
+- **Content-Security-Policy** y `Secure` de cookie solo desde loopback
+  (`trust proxy` explicito).
+
+### Cambiado
+
+- La sesion se invalida al cambiar la contrasena (`pv`); los usuarios
+  deshabilitados no pueden entrar.
+- `app.json` migra el `username`/`password` legado a `users[]`.
+
 ## [0.3.0] - 2026-09-13
 
 ### Cambios

package/README.md

@@ -44,9 +44,9 @@ openbridge server
 ```
 
 Al arrancar (queda en segundo plano) imprime el **estado con la URL pública**
-(`https://….tunnelmole.net/chat.php`): abríla desde el celular y logueate con el
-usuario (`admin`) y la contraseña que elegiste en `init`. Para correrlo en
-primer plano usá `openbridge server --stream`; para detenerlo, `openbridge stop`.
+(`https://….tunnelmole.net/chat.php`): abríla desde el celular y logueate con tu
+usuario y contraseña. Para correrlo en primer plano usá
+`openbridge server --stream`; para detenerlo, `openbridge stop`.
 
 ### Opciones de `init`
 
@@ -55,7 +55,8 @@ primer plano usá `openbridge server --stream`; para detenerlo, `openbridge stop
 --name "PC 1"        nombre visible de esta computadora
 --id pc1             identificador corto (default: derivado del nombre)
 --port 8799          puerto local
---password <clave>   contraseña de acceso
+--password <clave>   contraseña del admin inicial
+--user <nombre>      nombre del admin inicial (default: admin)
 --tunnel <prov>      tunnelmole | ngrok | cloudflare | none
 --domain <host>      dominio fijo del túnel (ngrok)
 --yes                sin preguntas (usa defaults)
@@ -63,12 +64,25 @@ primer plano usá `openbridge server --stream`; para detenerlo, `openbridge stop
 --dir <ruta>         casa portable (default: directorio actual)
 ```
 
+## Actualizar
+
+```bash
+npm i -g @danieltmn/openbridge@latest     # o: npx @danieltmn/openbridge@latest …
+```
+
+La configuración y los datos en `.openbridge/` se **migran solos**: el layout
+viejo (archivos sueltos) pasa a `.openbridge/`, y el `username`/`password` de una
+instalación de un solo usuario se convierte en el **primer admin** de `users[]`
+(con la misma contraseña). Por el cambio de formato de sesión, **hay que volver a
+iniciar sesión** una vez; los chats, carpetas, túnel y push se conservan.
+
 ## Comandos
 
 | Comando | Qué hace |
 |---|---|
 | `openbridge init` | Configura la casa (workspace, contraseña, túnel, puerto) |
-| `openbridge passwd` | Cambia la contraseña de acceso (detiene el server si corre) |
+| `openbridge passwd` | Cambia la contraseña de acceso (`--user <nombre>`; detiene el server si corre) |
+| `openbridge users` | Usuarios y roles: `list`, `add`, `remove`, `passwd`, `role`, `disable`, `enable` |
 | `openbridge server` | Arranca app + puente + túnel en **segundo plano** y muestra el estado (`--stream` = primer plano) |
 | `openbridge stop` | Detiene el server y su árbol de procesos |
 | `openbridge status` | Estado, URL, puente en línea y chats |
@@ -76,10 +90,12 @@ primer plano usá `openbridge server --stream`; para detenerlo, `openbridge stop
 | `openbridge tunnel` | Muestra o cambia el proveedor de túnel y su dominio fijo (`--domain`) |
 | `openbridge logs` | Logs (`--follow`, `--server`, `--bridge`) |
 | `openbridge bridge` | Corre **solo** el puente (`--api --token --id --name`) |
+| `openbridge join` | Vincula esta PC como puente de un hub (`<url> --token --id --name`) |
 | `openbridge import` | Trae `data/` de OpenConex (`<data-dir> [--force]`) |
 | `openbridge reset` | Borra chats/datos (`--session <id>`, `--yes`) |
 | `openbridge autostart` | Arranque automático (`install`/`remove`) |
 | `openbridge doctor` | Verifica Node, opencode, configuración y puerto |
+| `openbridge update` | Busca una versión nueva en npm (`--yes` para actualizar) |
 
 ## Casa portable
 
@@ -89,7 +105,7 @@ Todo vive dentro de **`.openbridge/`** en el directorio donde corrés `init`
 ```
 .openbridge/
   config.json    config del puente (apiUrl, token, workspace, bridgeId…)
-  app.json       config de la app (usuario, contraseña, VAPID, puerto, túnel)
+  app.json       config de la app (usuarios, token, VAPID, puerto, túnel)
   folders.json   lista blanca de carpetas que se ven desde el celular
   data/          sesiones, mensajes, catálogo, registro de puentes, push
   logs/          server.log y bridge.log
@@ -99,47 +115,115 @@ Movés la carpeta a donde quieras y sigue funcionando (es portable). Si venías
 de una versión anterior con los archivos sueltos, se **migran solos** a
 `.openbridge/` la primera vez que corras un comando.
 
-## Varias computadoras
+## Varias computadoras (hub + remotas)
+
+La PC **hub** corre la app y el túnel; las demás PCs corren solo el **puente** y
+apuntan al hub. En el sidebar de la web elegís qué PC usar y ves sus proyectos y
+chats.
+
+Ejemplo concreto:
+
+1. En el **hub** (tiene la app y la URL pública):
+   ```bash
+   openbridge init
+   openbridge server        # muestra estado, URL y QR
+   openbridge status        # volvés a ver la URL cuando quieras
+   ```
+2. Copiá el **token del puente** del hub: `.openbridge/app.json` → `bridgeToken`.
+3. En la **PC 2** (remota):
+   ```bash
+   openbridge join https://tu-url-publica --token <bridgeToken> --id pc2 --name "PC 2"
+   # guarda la config y arranca el puente; con --no-start solo guarda
+   ```
+   (equivale a `openbridge bridge --api … --token … --id … --name …`, pero
+   persiste la config para no repetir flags)
+4. Abrí la URL del hub desde el celular: en el sidebar aparecen **PC 1** y
+   **PC 2** para alternar.
+
+El puente remoto solo necesita salida a internet hacia el hub; no abre puertos ni
+túnel propio. Para que arranque solo en cada PC: `openbridge autostart install`.
 
-El hub (la PC con la app) puede atender **varias PCs** a la vez:
-
-- En la PC "hub": `openbridge init` + `openbridge server` (queda la app + túnel).
-- En otra PC: `openbridge init` y luego `openbridge bridge --api <url-del-hub>
-  --token <token> --id pc2 --name "PC 2"` (sin editar `config.json` a mano).
+## Túnel y URL estable
 
-En el sidebar de la web elegís qué PC usar y ves sus proyectos y chats.
+Proveedores (`--tunnel` o `openbridge tunnel <prov>`): `tunnelmole` (gratis, sin
+cuenta), `ngrok` (cuenta + authtoken; admite **dominio fijo**) y `cloudflare`
+(quick tunnel). Ver/cambiar sin reconfigurar todo:
 
-## Túnel y URL estable
+```bash
+openbridge tunnel                                   # estado actual
+openbridge tunnel ngrok --domain mi-pc.ngrok.app    # URL fija (recomendado)
+openbridge stop && openbridge server                # reiniciar para aplicar
+```
 
-Proveedores soportados (`--tunnel`): `tunnelmole` (gratis, sin cuenta),
-`ngrok` (cuenta + authtoken; admite dominio fijo con `--domain` en
-`app.json`) y `cloudflare` (quick tunnel de `cloudflared`). Con URL
-**aleatoria**, la suscripción push no persiste entre reinicios (el push está
-atado al origen). Para PWA/push estables conviene ngrok con dominio fijo o
-Cloudflare con dominio propio.
+Con URL **aleatoria** la PWA y el push no persisten entre reinicios (están atados
+al origen). Para una URL estable usá ngrok con dominio fijo (o un named tunnel de
+Cloudflare). Escaneá el QR de `openbridge status`/`openbridge qr` para abrirla en
+el celular.
 
 ## Avisos push
 
-Las claves VAPID se generan solas en `init`. Con URL de túnel **aleatoria**, la
-suscripción push no persiste entre reinicios (el push está atado al origen). Para
-una URL fija hace falta un proveedor con dominio estable (ngrok/Cloudflare).
+Las claves VAPID se generan solas en `init`. Con URL de túnel aleatoria la
+suscripción no persiste entre reinicios (el push está atado al origen); la app la
+vuelve a registrar cuando la abrís en la URL nueva. Para que sea estable, usá una
+URL fija (ngrok con `--domain`).
+
+## MCP
+
+La web tiene una vista **mcp** y el chat acepta `/mcp`: muestran los servidores
+MCP de opencode y su estado (`opencode mcp list`). El comando corre en la PC del
+puente, así que refleja la configuración de opencode de esa computadora.
 
 ## Seguridad
 
-- La app escucha solo en `127.0.0.1`; el túnel la expone.
-- Login con contraseña (scrypt) + CSRF y rate limit (5 intentos); token del
-  puente autogenerado.
+- La app escucha **solo en `127.0.0.1`**; el túnel la expone a internet.
+- Login con **usuario y contraseña** (scrypt), cookie firmada `HttpOnly` +
+  `SameSite=Lax`, **CSRF** y **rate limit** (5 intentos / 15 min por IP+usuario);
+  token del puente autogenerado.
+- La cookie usa `Secure` cuando el pedido llega por HTTPS **desde loopback** (el
+  túnel); no se confía en `X-Forwarded-Proto` de otros orígenes.
+- Respuestas con `Content-Security-Policy` (orígenes externos, frames y objetos
+  bloqueados), `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY` y
+  `Referrer-Policy: no-referrer`.
 - El túnel es **público mientras corre**: detenelo (`openbridge stop`) cuando no
-  lo uses.
+  lo uses y mantené la contraseña fuerte.
+
+## Usuarios y roles
+
+Cada persona entra con **usuario y contraseña**. Hay dos roles:
+
+- **admin**: todo (crear/borrar chats, revertir cambios, procesos, túneles y
+  administrar usuarios).
+- **user**: chat, archivos, cambios y búsqueda; no puede borrar chats, revertir
+  cambios ni correr procesos/túneles.
+
+Se administran desde la PC con la CLI (los cambios requieren reiniciar el server):
+
+```bash
+openbridge users list
+openbridge users add ana --role user --password <clave>
+openbridge users passwd ana
+openbridge users role ana admin
+openbridge users disable ana      # enable para reactivar
+openbridge users remove ana
+openbridge passwd --user admin    # cambia la clave de un usuario
+```
+
+`init --user <nombre>` crea el admin inicial. La contraseña se guarda con scrypt,
+y cambiar una clave **invalida las sesiones abiertas** de ese usuario. El último
+admin no se puede borrar, degradar ni deshabilitar. Cada mensaje guarda **quién
+lo envió** (se ve en el chat).
 
 ## Estado
 
 Proyecto en desarrollo. Ya funciona: `init`, `server` (segundo plano; `--stream`
-en primer plano), `stop`, `status`, `logs` (`--follow`), `bridge` (con flags),
-`passwd`, `import`, `reset`, `autostart`, `doctor`, login con rate limit, API
-completa, SSE, catálogo por PC, Web Push y túnel (TunnelMole/ngrok/cloudflare).
-Tests en `npm test`. Pendiente: re-suscripción push al cambiar la URL y más
-cobertura end-to-end.
+en primer plano), `stop`, `status`, `qr`, `tunnel`, `logs` (`--follow`), `bridge`
+(con flags), `passwd`, `users`, `import`, `reset`, `autostart`, `doctor`; login
+**multiusuario** con roles `admin`/`user` y rate limit; API completa y SSE;
+catálogo por PC; Web Push; túnel (TunnelMole/ngrok/cloudflare); y en la web: chat
+con streaming, adjuntar imagen, dictado por voz, plantillas de prompts,
+tokens/contexto y **costo** por sesión, vista de archivos, vista de **cambios**
+(git status/diff) con **revertir**, búsqueda global, sesiones de opencode y
+**autor** en cada mensaje. Tests en `npm test` (28).
 
 ## Licencia
 

package/docs/ARCHITECTURE.md

@@ -19,18 +19,20 @@ el estado); `--stream` lo deja en primer plano.
 | Ruta | Responsabilidad |
 |---|---|
 | `bin/openbridge.js` | Entrada CLI + guard de Node. |
-| `src/cli.js` | Comandos (`init`, `passwd`, `server`, `stop`, `status`, `logs`, `bridge`, `import`, `reset`, `autostart`, `doctor`). |
+| `src/cli.js` | Comandos (`init`, `passwd`, `users`, `server`, `stop`, `status`, `qr`, `tunnel`, `logs`, `bridge`, `join`, `import`, `reset`, `autostart`, `doctor`, `update`). |
 | `src/paths.js` | Casa portable: ubicacion de `config.json`, `app.json`, `data/`, `logs/`. |
-| `src/config.js` | Lectura/escritura de config, hash scrypt, VAPID. |
-| `src/auth.js` | Cookie de sesion firmada, CSRF, remember-me, rate limit, token del puente. |
+| `src/config.js` | Lectura/escritura de config, hash scrypt, **usuarios/roles**, VAPID. |
+| `src/auth.js` | Cookie de sesion firmada, CSRF, remember-me, **roles**, rate limit, token del puente. |
 | `src/log.js` | Log a consola + `logs/server.log`. |
 | `src/push.js` | Web Push (VAPID + `web-push`). |
+| `src/qr.js` | Generador QR propio (terminal/SVG), sin dependencias. |
 | `src/tunnel/` | Proveedores de tunel enchufables. |
-| `src/web/server.js` | Servidor HTTP, estaticos, seguridad. |
-| `src/web/routes.js` | Router de paginas y API (`?action=...`), compatible con `app.js`/`bridge.js`. |
+| `src/web/server.js` | Servidor HTTP, estaticos, cabeceras de seguridad (CSP). |
+| `src/web/routes.js` | Router de paginas y API (`?action=...`), gate de roles, compatible con `app.js`/`bridge.js`. |
 | `src/web/assets/` | Frontend (`app.js`, temas, iconos, service worker, manifest). |
 | `src/store/` | Store JSON con mutex por archivo y escritura atomica. |
-| `src/bridge/bridge.js` | Puente: sincroniza catalogo, hace poll y ejecuta opencode. |
+| `src/bridge/bridge.js` | Puente: sincroniza catalogo, hace poll y ejecuta opencode; comandos fs/proc/tunel/git. |
+| `scripts/release.mjs` | Release local (fuera del paquete npm): version, changelog, tag, push y publish. |
 
 ## Casa portable
 
@@ -53,7 +55,8 @@ OpenBridge. La CLI pasa la **base** (`--dir`/cwd) al puente via
 
 ## Flujo de un mensaje
 
-1. El celular envia `?action=send` (con CSRF) -> `src/web/routes.js`.
+1. El celular envia `?action=send` (con CSRF) -> `src/web/routes.js`; el mensaje
+   se guarda con el **autor** de la sesion.
 2. El mensaje queda `pending` en `data/messages-<id>.json`.
 3. El puente hace `poll`, reclama el mensaje y corre
    `opencode run --model <m> [--session <id>]`.
@@ -62,16 +65,58 @@ OpenBridge. La CLI pasa la **base** (`--dir`/cwd) al puente via
 
 ## Multi-PC
 
-El hub corre la app; cada PC corre `openbridge bridge` apuntando al hub
-(`apiUrl` + `apiToken` + `bridgeId`). El catalogo se guarda por PC
-(`data/catalog-<id>.json`) y el sidebar permite elegir que PC usar.
+El hub corre la app; cada PC corre `openbridge bridge` (o `openbridge join <url>`,
+que persiste `apiUrl` + `apiToken` + `bridgeId`) apuntando al hub. El catalogo se
+guarda por PC (`data/catalog-<id>.json`) y el sidebar permite elegir que PC usar.
+
+`config.command` es el CLI a ejecutar (default `opencode`). Si apunta a un script
+de Node (`.js`/`.mjs`/`.cjs`) el puente lo corre con el `node` actual, lo que
+permite wrappers propios y las pruebas con un opencode simulado.
+
+## Usuarios y roles
+
+`app.json` guarda `users[]` (`id`, `name`, `role`, `password` scrypt, `pv`,
+`disabled`). El modelo viejo de un `username`/`password` se migra solo a
+`users[0]` (admin).
+
+- La sesion (cookie firmada) guarda el `id` del usuario y su `pv`; el **rol se lee
+  siempre del server** en cada request. Cambiar la contrasena sube `pv` e invalida
+  las sesiones abiertas; un usuario `disabled` no entra.
+- Roles: `admin` (todo) y `user` (chat/lectura). El gate es **server-side** en
+  `routes.js`; la UI solo oculta los controles.
+- Rate limit de login por IP+usuario y error generico (no filtra si el usuario
+  existe; corre scrypt igual contra un hash dummy).
+- Cada mensaje guarda `author` (quien lo envio); la respuesta hereda el autor del
+  pedido.
+
+## Comandos del puente
+
+La web encola comandos (`?action=run_oc`) que el puente reclama por el poll y
+resuelve (los resultados vuelven por `command_done`/`fs_result`). Sirve tanto en
+local como en remoto:
+
+- Lectura: `models`, `session_list`, `session_info`, `opencode_version`,
+  `fs_list`, `fs_read`, `proc_list`, `proc_log`, `tunnel_list`, `git_status`,
+  `git_diff`.
+- Mutantes (solo `admin`): `proc_start`, `proc_stop`, `tunnel_start`,
+  `tunnel_stop`, `git_checkout`.
+
+Las rutas se validan contra el workspace (`procResolveFolder`/`resolveInWorkspace`)
+y los argumentos con una whitelist (`OC_ALLOWED`).
 
 ## Decisiones
 
 - **Stateless sessions**: la cookie se firma con HMAC; no hay store de sesiones.
+  El `id`+`pv` del usuario van en el payload y el rol se resuelve en cada request.
+- **Multiusuario con roles**: `admin`/`user`, gate server-side; el ultimo admin no
+  se puede borrar, degradar ni deshabilitar.
 - **Escritura atomica + mutex**: `tmp` + `rename` y una cola por archivo evitan
   corrupciones con polls concurrentes.
 - **Sin dependencias de framework**: HTTP nativo de Node; la unica dependencia
-  es `web-push`.
+  es `web-push`. El QR se genera con codigo propio (`src/qr.js`).
+- **Cabeceras de seguridad**: CSP restrictiva; permite scripts/estilos inline
+  porque los templates los usan.
+- **Cola de comandos del puente**: un solo canal (poll) para fs, procesos,
+  tuneles y git, valido igual en local y remoto.
 - **Proveedores de tunel detras de una interfaz**: `startTunnel(port, provider)`
   devuelve `{ url, provider, pid, stop }`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/openbridge",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Tu opencode en el celular, sin hosting: corre la app, el puente y un tunel publico desde tu PC.",
   "type": "commonjs",
   "author": "tamnora",
@@ -43,6 +43,7 @@
   "scripts": {
     "start": "node bin/openbridge.js server",
     "test": "node --test",
+    "lint": "node scripts/lint.mjs",
     "release": "node scripts/release.mjs",
     "release:dry": "node scripts/release.mjs --dry-run",
     "prepublishOnly": "npm test"

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

@@ -412,6 +412,21 @@ function parseShimExe(shimPath, shimDir) {
     return exe;
 }
 
+// Si `command` apunta a un script de Node (.js/.mjs/.cjs) lo ejecutamos con el
+// node actual. Permite wrappers propios (p. ej. un runner que filtra logs) y
+// que las pruebas usen un opencode simulado sin depender del PATH.
+function isNodeScriptCommand(cmd) {
+    return /\.(c|m)?js$/i.test(String(cmd || '').trim());
+}
+
+function commandSpec(args) {
+    const cmd = config.command;
+    if (isNodeScriptCommand(cmd)) {
+        return { cmd: process.execPath, argv: [path.resolve(cmd)].concat(args) };
+    }
+    return { cmd: resolveCommand(), argv: args };
+}
+
 // ---------------------------------------------------------------------------
 // Ejecutar comandos auxiliares de opencode
 // ---------------------------------------------------------------------------
@@ -457,9 +472,9 @@ function runCmd(bin, args, opts) {
 
 function runCli(args, opts) {
     return new Promise((resolve) => {
-        const cmd = resolveCommand();
+        const spec = commandSpec(args);
         const timeoutMs = Math.max((opts && opts.timeout) || 0, 0);
-        const child = spawn(cmd, args, {
+        const child = spawn(spec.cmd, spec.argv, {
             cwd: (opts && opts.cwd) || undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: process.env,
@@ -511,9 +526,9 @@ function runCli(args, opts) {
 // Resolución: { ok, code, text, reasoning, killed, canceled, sessionID, errorText }.
 function streamCli(args, opts, onPartial) {
     return new Promise((resolve) => {
-        const cmd = resolveCommand();
+        const spec = commandSpec(args);
         const timeoutMs = Math.max((opts && opts.timeout) || 0, 0);
-        const child = spawn(cmd, args, {
+        const child = spawn(spec.cmd, spec.argv, {
             cwd: (opts && opts.cwd) || undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: process.env,
@@ -834,7 +849,7 @@ async function runOpencode(msg, onPartial) {
         try {
             const mime = msg.img.slice(5, msg.img.indexOf(';'));
             const ext = { 'image/png': '.png', 'image/jpeg': '.jpg', 'image/webp': '.webp', 'image/gif': '.gif' }[mime] || '.png';
-            imgPath = path.join(os.tmpdir(), 'ocx-img-' + msg.session_id + '-' + msg.id + ext);
+            imgPath = path.join(os.tmpdir(), 'ob-img-' + msg.session_id + '-' + msg.id + ext);
             fs.writeFileSync(imgPath, Buffer.from(msg.img.slice(msg.img.indexOf(',') + 1), 'base64'));
             log('imagen adjunta: ' + Math.round(fs.statSync(imgPath).size / 1024) + ' KB para el mensaje #' + msg.id);
         } catch (e) {
@@ -975,6 +990,16 @@ async function runMessage(msg) {
         return { text: '', opencodeSession: null, done: true };
     }
 
+    if (name === 'mcp') {
+        log('comando /mcp');
+        const r = await runCli(['mcp', 'list'], { timeout: 30000 });
+        const text = r.ok
+            ? (r.text || 'No hay servidores MCP configurados.')
+            : 'No se pudieron listar los MCP: ' + (r.text || ('exit ' + r.code));
+        await respondSimple(msg, text, false);
+        return { text: '', opencodeSession: null, done: true };
+    }
+
     if (name === 'workspace') {
         log('comando /workspace');
         const ws = config.workspace ? path.resolve(config.workspace) : '';
@@ -1014,6 +1039,7 @@ async function runMessage(msg) {
             + '• /compact, /resumen, /summarize — liberar contexto\n'
             + '• /models [filtro] — proveedores disponibles o búsqueda de modelos\n'
             + '• /agents — listar agentes disponibles\n'
+            + '• /mcp — servidores MCP de opencode y su estado\n'
             + '• /folders, /carpetas, /dirs — listar carpetas del workspace\n'
             + '• /workspace — mostrar el espacio de trabajo\n'
             + '• /status, /estado — estado del puente\n'
@@ -2115,6 +2141,19 @@ async function handleCommand(cmd) {
         await handleFsCommand(cmd);
         return;
     }
+    // Servidores MCP de opencode: se devuelve JSON con la salida cruda para que
+    // la web la muestre en el panel.
+    if (cmd.name === 'mcp_list') {
+        const r = await runCli(['mcp', 'list'], { timeout: 30000 });
+        await api('command_done', {
+            id: cmd.id,
+            ok: r.ok,
+            text: JSON.stringify({ output: r.text || '', ok: r.ok }),
+            error: r.ok ? '' : ('exit ' + r.code),
+        }, cmd._t);
+        log('comando #' + cmd.id + ' mcp_list (ok=' + r.ok + ')');
+        return;
+    }
     // Cambios git del proyecto (status/diff/revertir).
     if (cmd.name === 'git_status' || cmd.name === 'git_diff' || cmd.name === 'git_checkout') {
         await handleGitCommand(cmd);