@danieltmn/openbridge 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+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.1.0] - 2026-09-11
+
+Primera version publicada. Paquete npm **`@danieltmn/openbridge`** y repo
+**`tamnora/openbridge`** en GitHub (el nombre `openbridge` a secas esta bloqueado
+por npm por similitud con `open-bridge`).
+
+### Agregado
+
+- CLI: `init`, `passwd`, `server`, `stop`, `status`, `logs`, `bridge`, `import`,
+  `reset`, `autostart`, `doctor`, `version`, `help`.
+- Casa portable en `<base>/.openbridge/` (`config.json`, `app.json`,
+  `folders.json`, `data/`, `logs/`), con **migracion automatica** del layout
+  viejo.
+- Store JSON (`src/store/`) con mutex por archivo y escritura atomica.
+- Auth: cookie de sesion firmada, CSRF, remember-me, token del puente (scrypt) y
+  **rate limit / lockout** de login (5 intentos, 15 min).
+- Server web (`src/web/`): router, templates, estaticos, SSE y API completa
+  compatible con `app.js`/`bridge.js`; logs reales a `logs/server.log`.
+- Web Push (`src/push.js`): VAPID + `web-push`.
+- Tuneles enchufables: `tunnelmole`, `ngrok` y `cloudflare`.
+- `openbridge server` en segundo plano (muestra el estado al levantar);
+  `--stream` para primer plano. `--detach` se mantiene como alias.
+- `bridge --api --token --id --name` para apuntar a otro hub sin editar
+  `config.json`.
+- `import <data-dir>` (trae `data/` de OpenConex), `reset`
+  (`--session <id>` / `--yes`) y `autostart install|remove` (Windows/Linux/macOS).
+- `logs --follow`, `logs --server` y `logs --bridge`.
+- Consumo de **tokens y capacidad de contexto** por sesion (sidebar, encabezado,
+  statusbar y franja de trabajo); el puente sincroniza `models_ctx` desde
+  `opencode models --verbose`.
+- Indicador KITT con bordes y estela luminosa.
+- Guard de Node < 18 con mensaje amigable.
+- Tests con `node --test` (store, auth, API, `safeJoinWorkspace`, migracion) y
+  CI en Windows/Linux/macOS.
+- `docs/ARCHITECTURE.md`, `CHANGELOG.md`, `AGENTS.md`, README y LICENSE.
+
+### Cambiado
+
+- **Login solo con contrasena**: se quito el campo de usuario (es un unico
+  `admin`).
+- `init --force` y `passwd` detienen un server en ejecucion antes de reescribir
+  la config, para no dejar la contrasena vieja en memoria.
+- `init`: contrasena oculta al escribir, resumen con credenciales/URL, validacion
+  del proveedor de tunel y exclusion de `.openbridge/` en el escaneo.
+- `status`: muestra puente en linea y cantidad de chats.
+- `stop`: mata el arbol completo de procesos (Windows `taskkill /T`; POSIX grupo
+  detached).
+- Mensaje claro cuando el puerto esta ocupado.
+
+### Corregido
+
+- El servidor ya no falla en silencio: los errores y los 4xx/5xx van a
+  `logs/server.log`.
+- Evita anidar `.openbridge/.openbridge` y valida la instancia ya corriendo.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenBridge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# OpenBridge
+
+[![npm](https://img.shields.io/npm/v/@danieltmn/openbridge.svg)](https://www.npmjs.com/package/@danieltmn/openbridge)
+[![CI](https://github.com/tamnora/openbridge/actions/workflows/ci.yml/badge.svg)](https://github.com/tamnora/openbridge/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/@danieltmn/openbridge.svg)](LICENSE)
+
+Tu **opencode** en el celular, **sin hosting**: corre la app, el puente y un
+túnel público desde tu PC. El celular entra por la URL del túnel y vos manejás
+opencode (tus carpetas, modelos y chats) desde donde estés.
+
+> Proyecto nuevo e independiente, portado a **Node** desde OpenConex (PHP).
+> Ya no hace falta subir nada a un hosting ni depender de uno.
+
+## Cómo funciona
+
+```
+[Celular] ──► URL del túnel ──► App Node en tu PC ──► .openbridge/data/ (JSON)
+                                      │
+                                      └──► bridge (Node) ──► opencode run
+```
+
+- **Un solo runtime: Node 18+.** La app web, la API, los datos y el puente viven
+  en el mismo proceso/hogar.
+- **opencode** es el único requisito externo (el motor que responde).
+- **Túnel** con TunnelMole (gratis, sin cuenta), ngrok o Cloudflare para exponer
+  la app a internet.
+
+## Requisitos
+
+- [Node.js](https://nodejs.org) 18 o superior.
+- `opencode` instalado y autenticado: `npm i -g opencode-ai`.
+
+## Instalación
+
+```bash
+# opción 1: sin instalar nada (npx)
+npx @danieltmn/openbridge init      # asistente: workspace, contraseña, túnel, puerto
+npx @danieltmn/openbridge server    # arranca en segundo plano y muestra el estado/URL
+
+# opción 2: instalar global
+npm i -g @danieltmn/openbridge
+openbridge init
+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`.
+
+### Opciones de `init`
+
+```
+--workspace <ruta>   carpeta de trabajo (donde están tus proyectos)
+--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
+--tunnel <prov>      tunnelmole | ngrok | cloudflare | none
+--yes                sin preguntas (usa defaults)
+--force              reconfigura aunque ya exista
+--dir <ruta>         casa portable (default: directorio actual)
+```
+
+## 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 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 |
+| `openbridge logs` | Logs (`--follow`, `--server`, `--bridge`) |
+| `openbridge bridge` | Corre **solo** el puente (`--api --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 |
+
+## Casa portable
+
+Todo vive dentro de **`.openbridge/`** en el directorio donde corrés `init`
+(o `--dir` / `OPENBRIDGE_HOME`):
+
+```
+.openbridge/
+  config.json    config del puente (apiUrl, token, workspace, bridgeId…)
+  app.json       config de la app (usuario, contraseña, 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
+```
+
+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
+
+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).
+
+En el sidebar de la web elegís qué PC usar y ves sus proyectos y chats.
+
+## Túnel y URL estable
+
+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.
+
+## 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).
+
+## 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.
+- El túnel es **público mientras corre**: detenelo (`openbridge stop`) cuando no
+  lo uses.
+
+## 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.
+
+## Licencia
+
+MIT.

package/bin/openbridge.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+'use strict';
+
+const major = parseInt(process.versions.node.split('.')[0], 10);
+if (major < 18) {
+    console.error('OpenBridge requiere Node 18 o superior (tenes ' + process.versions.node + ').');
+    console.error('Actualizalo en https://nodejs.org');
+    process.exit(1);
+}
+
+const cli = require('../src/cli');
+
+cli.main(process.argv.slice(2))
+    .then((code) => { if (typeof code === 'number') process.exitCode = code; })
+    .catch((e) => {
+        console.error('error: ' + ((e && e.message) || e));
+        process.exitCode = 1;
+    });

package/docs/ARCHITECTURE.md

@@ -0,0 +1,77 @@
+# Arquitectura de OpenBridge
+
+## Vision general
+
+```
+[Celular] -- HTTPS --> [Tunel] --> [App Node: src/web] -- JSON --> [.openbridge/data/]
+                                        |
+                                        +--> [Puente: src/bridge] -- CLI --> [opencode]
+```
+
+Un unico runtime (**Node 18+**). La app web, la API y los datos viven en el
+mismo proceso; el puente es un proceso hijo que ejecuta `opencode run` en las
+carpetas del workspace. El tunel (TunnelMole/ngrok/cloudflared) expone la app
+local a internet. `openbridge server` arranca todo en segundo plano (y muestra
+el estado); `--stream` lo deja en primer plano.
+
+## Modulos
+
+| 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/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/log.js` | Log a consola + `logs/server.log`. |
+| `src/push.js` | Web Push (VAPID + `web-push`). |
+| `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/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. |
+
+## Casa portable
+
+La "base" es el directorio de `init` (o `--dir` / `OPENBRIDGE_HOME`). Todos los
+archivos de OpenBridge viven dentro de `<base>/.openbridge/`:
+
+```
+config.json    config del puente
+app.json       config de la app (password, token, VAPID, puerto, tunel)
+folders.json   lista blanca de carpetas
+data/          sesiones, mensajes, catalogos por PC, registro de puentes, push
+logs/          server.log, bridge.log
+runtime.json   estado del server en ejecucion (pid, URL, hijos)
+```
+
+`paths.migrate()` mueve automaticamente el layout viejo (archivos sueltos en la
+base) a `.openbridge/`; `data/` y `logs/` solo se mueven si tienen marcas de
+OpenBridge. La CLI pasa la **base** (`--dir`/cwd) al puente via
+`OPENBRIDGE_HOME`, y el puente le agrega `.openbridge`.
+
+## Flujo de un mensaje
+
+1. El celular envia `?action=send` (con CSRF) -> `src/web/routes.js`.
+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>]`.
+4. La salida se publica con `respond_partial` (streaming) y `respond`.
+5. El server empuja un Web Push y el celular refresca por SSE/poll.
+
+## 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.
+
+## Decisiones
+
+- **Stateless sessions**: la cookie se firma con HMAC; no hay store de sesiones.
+- **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`.
+- **Proveedores de tunel detras de una interfaz**: `startTunnel(port, provider)`
+  devuelve `{ url, provider, pid, stop }`.

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@danieltmn/openbridge",
+  "version": "0.1.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",
+  "license": "MIT",
+  "homepage": "https://github.com/tamnora/openbridge#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tamnora/openbridge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tamnora/openbridge/issues"
+  },
+  "keywords": [
+    "opencode",
+    "openbridge",
+    "tunnel",
+    "remote",
+    "mobile",
+    "pwa",
+    "cli",
+    "tunnelmole",
+    "ngrok",
+    "cloudflare"
+  ],
+  "bin": {
+    "openbridge": "bin/openbridge.js",
+    "openconex": "bin/openbridge.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "docs/ARCHITECTURE.md",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/openbridge.js server",
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "web-push": "^3.6.7"
+  }
+}

package/src/auth.js

@@ -0,0 +1,204 @@
+'use strict';
+
+/**
+ * Autenticacion web: cookie de sesion firmada (stateless), CSRF, "mantener
+ * sesion" y token del puente. Sin dependencias externas.
+ */
+
+const crypto = require('node:crypto');
+const config = require('./config');
+
+const SESSION_COOKIE = 'ob_session';
+const REMEMBER_COOKIE = 'ob_remember';
+const REMEMBER_DAYS = 30;
+
+function b64url(buf) {
+    return Buffer.from(buf).toString('base64url');
+}
+function sign(data, secret) {
+    return crypto.createHmac('sha256', secret).update(data).digest('base64url');
+}
+function safeEqual(a, b) {
+    const ba = Buffer.from(String(a));
+    const bb = Buffer.from(String(b));
+    if (ba.length !== bb.length) return false;
+    return crypto.timingSafeEqual(ba, bb);
+}
+
+function parseCookies(header) {
+    const out = {};
+    const raw = String(header || '');
+    for (const part of raw.split(';')) {
+        const i = part.indexOf('=');
+        if (i < 0) continue;
+        const k = part.slice(0, i).trim();
+        const v = part.slice(i + 1).trim();
+        if (k) out[k] = decodeURIComponent(v);
+    }
+    return out;
+}
+
+function isSecure(req) {
+    const proto = req.headers['x-forwarded-proto'];
+    return proto === 'https';
+}
+
+function serializeCookie(name, value, req, maxAge) {
+    const parts = [name + '=' + encodeURIComponent(value), 'Path=/', 'HttpOnly', 'SameSite=Lax'];
+    if (isSecure(req)) parts.push('Secure');
+    if (typeof maxAge === 'number') parts.push('Max-Age=' + maxAge);
+    return parts.join('; ');
+}
+
+// ---------------------------------------------------------------------------
+// Sesion
+// ---------------------------------------------------------------------------
+function makeSession(app, username, csrf, exp) {
+    const payload = b64url(JSON.stringify({ u: username, c: csrf, e: exp }));
+    return payload + '.' + sign(payload, app.csrfSecret);
+}
+function readSession(app, req) {
+    const cookies = parseCookies(req.headers.cookie);
+    const raw = cookies[SESSION_COOKIE];
+    if (!raw) return null;
+    const dot = raw.lastIndexOf('.');
+    if (dot < 0) return null;
+    const payload = raw.slice(0, dot);
+    const sig = raw.slice(dot + 1);
+    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;
+}
+function currentCsrf(app, req) {
+    const s = readSession(app, req);
+    return s ? s.c : '';
+}
+function requireLogin(app, req, res) {
+    const s = readSession(app, req);
+    if (!s) { json(res, 401, { ok: false, error: 'No autorizado' }); return null; }
+    return s;
+}
+function requireCsrf(app, req, res) {
+    const s = readSession(app, req);
+    const given = String(req.headers['x-csrf'] || '').trim();
+    if (!s || given === '' || !safeEqual(s.c, given)) {
+        json(res, 403, { ok: false, error: 'Sesion expirada, recarga la pagina.' });
+        return null;
+    }
+    return s;
+}
+
+function startSession(app, req, res, username) {
+    const csrf = crypto.randomBytes(16).toString('hex');
+    const exp = Math.floor(Date.now() / 1000) + REMEMBER_DAYS * 86400;
+    const token = makeSession(app, username, csrf, exp);
+    res.setHeader('Set-Cookie', [
+        serializeCookie(SESSION_COOKIE, token, req, REMEMBER_DAYS * 86400),
+        serializeCookie(REMEMBER_COOKIE, makeRemember(app, username), req, REMEMBER_DAYS * 86400),
+    ]);
+    return csrf;
+}
+function endSession(req, res) {
+    res.setHeader('Set-Cookie', [
+        serializeCookie(SESSION_COOKIE, '', req, 0),
+        serializeCookie(REMEMBER_COOKIE, '', req, 0),
+    ]);
+}
+
+function makeRemember(app, username) {
+    const exp = Math.floor(Date.now() / 1000) + REMEMBER_DAYS * 86400;
+    const payload = username + '|' + exp;
+    return b64url(payload) + '.' + sign(payload, app.csrfSecret);
+}
+// Re-autentica desde la cookie remember si la sesion se perdio.
+function rememberAutoLogin(app, req, res) {
+    if (readSession(app, req)) return false;
+    const cookies = parseCookies(req.headers.cookie);
+    const raw = cookies[REMEMBER_COOKIE];
+    if (!raw) return false;
+    const dot = raw.lastIndexOf('.');
+    if (dot < 0) return false;
+    const payload = raw.slice(0, dot);
+    const sig = raw.slice(dot + 1);
+    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 (!safeEqual(sign(payload, app.csrfSecret), sig)) return false;
+    startSession(app, req, res, user);
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Rate limit / lockout de login (en memoria: el server es un solo proceso)
+// ---------------------------------------------------------------------------
+const LOGIN_MAX_ATTEMPTS = 5;
+const LOGIN_WINDOW_MS = 15 * 60 * 1000;
+const LOGIN_LOCK_MS = 15 * 60 * 1000;
+const loginAttempts = new Map();
+
+function clientKey(req) {
+    const xff = String(req.headers['x-forwarded-for'] || '').split(',')[0].trim();
+    const ip = xff || (req.socket && req.socket.remoteAddress) || 'desconocido';
+    return String(ip);
+}
+function pruneLoginAttempts(now) {
+    for (const [key, st] of loginAttempts) {
+        if (!st.lockUntil && now - st.first > LOGIN_WINDOW_MS) loginAttempts.delete(key);
+    }
+}
+// Segundos restantes de bloqueo (0 = puede intentar).
+function loginLockRemaining(req) {
+    const now = Date.now();
+    pruneLoginAttempts(now);
+    const st = loginAttempts.get(clientKey(req));
+    if (!st || !st.lockUntil) return 0;
+    const left = st.lockUntil - now;
+    return left > 0 ? Math.ceil(left / 1000) : 0;
+}
+function loginRecordFailure(req) {
+    const now = Date.now();
+    const key = clientKey(req);
+    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));
+}
+
+// ---------------------------------------------------------------------------
+// Token del puente
+// ---------------------------------------------------------------------------
+function checkBridgeToken(app, req) {
+    let given = String(req.headers['x-bridge-token'] || '').trim();
+    if (given === '') {
+        try {
+            const u = new URL(req.url, 'http://localhost');
+            given = String(u.searchParams.get('token') || '').trim();
+        } catch (e) { /* nada */ }
+    }
+    if (given === '' || !app.bridgeToken) return false;
+    return safeEqual(app.bridgeToken, given);
+}
+
+function json(res, code, data) {
+    res.statusCode = code;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(data));
+}
+
+module.exports = {
+    SESSION_COOKIE, REMEMBER_COOKIE,
+    parseCookies, serializeCookie, isSecure,
+    makeSession, readSession, currentCsrf, requireLogin, requireCsrf,
+    startSession, endSession, rememberAutoLogin,
+    loginLockRemaining, loginRecordFailure, loginClear,
+    checkBridgeToken, safeEqual, json,
+};