@danieltmn/openbridge 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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.3.0] - 2026-09-13
+
+### Cambios
+
+- web: revertir un archivo puntual desde la vista cambios
+- cli: comando tunnel (estado/cambio de proveedor y dominio fijo)
+- web: plantillas de prompts y boton de revertir cambios
+- web: vista de cambios del proyecto (git status/diff) via el puente
+- release: recupera flags que npm se queda (--yes, --tag, --dry-run, --preid)
+
+## [0.2.0] - 2026-09-13
+
+### Cambios
+
+- web: muestra el costo acumulado por sesion y total
+- cli: QR de la URL (init/status/server y comando qr)
+- web: dictado por voz en el compositor (Web Speech API)
+- release: exporta logica de version/changelog y agrega tests
+- release: proceso privado con guard de dueno, semver y dist-tags
+- UI: porcentaje de contexto, boton ver archivos y badge plan; refresco de tokens al responder
+
 ## [0.1.0] - 2026-09-11
 
 Primera version publicada. Paquete npm **`@danieltmn/openbridge`** y repo

package/README.md

@@ -1,143 +1,146 @@
-# 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.
+# 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
+--domain <host>      dominio fijo del túnel (ngrok)
+--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 qr` | Muestra la URL (pública o local) como QR para escanear desde el celular |
+| `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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/openbridge",
-  "version": "0.1.0",
+  "version": "0.3.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,8 +43,16 @@
   "scripts": {
     "start": "node bin/openbridge.js server",
     "test": "node --test",
+    "release": "node scripts/release.mjs",
+    "release:dry": "node scripts/release.mjs --dry-run",
     "prepublishOnly": "npm test"
   },
+  "release": {
+    "npmOwner": "danieltmn",
+    "gitRemote": "tamnora/openbridge",
+    "gitOwner": "tamnora",
+    "branch": "master"
+  },
   "publishConfig": {
     "access": "public"
   },

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; }
@@ -2194,6 +2270,14 @@ async function tick(opts) {
             } catch (e) {
                 log('error al publicar la respuesta #' + m.id + ': ' + e.message);
             }
+            // Refresca tokens/costo enseguida: el barrido solo corre cada 15 min.
+            if (r.opencodeSession && m._t) {
+                try {
+                    await refreshTokens(path.resolve(m.session.folder || ''), { id: r.opencodeSession }, m._t);
+                } catch (e) {
+                    log('aviso: no pude refrescar tokens de ' + r.opencodeSession + ': ' + e.message);
+                }
+            }
         }
         for (const f of folders) {
             await handleFolderRequest(f);

package/src/cli.js

@@ -10,6 +10,7 @@ const config = require('./config');
 const store = require('./store');
 const auth = require('./auth');
 const push = require('./push');
+const qr = require('./qr');
 const web = require('./web/server');
 const tunnel = require('./tunnel');
 const log = require('./log');
@@ -117,6 +118,15 @@ function clearRuntime() {
     }
 }
 
+// Muestra la URL como QR en la consola (para abrirla en el celular).
+// Devuelve false si la URL es demasiado larga para el QR.
+function printQr(url) {
+    const art = qr.qrTerminal(url, 2);
+    if (!art) return false;
+    console.log(art);
+    return true;
+}
+
 // Detiene el server en ejecucion (si lo hay) matando server + hijos. Devuelve
 // true si habia uno. Se usa antes de reconfigurar para no dejar un proceso con
 // la config vieja en memoria (p.ej. la contrasena).
@@ -234,7 +244,7 @@ async function cmdInit(argv) {
         csrfSecret,
         bridgeToken,
         vapid,
-        tunnel: { provider, domain: '' },
+        tunnel: { provider, domain: flags.domain ? String(flags.domain) : '' },
     };
     config.writeBridge(bridgeCfg);
     config.writeApp(appCfg);
@@ -255,6 +265,9 @@ async function cmdInit(argv) {
     console.log('  carpetas  : ' + folders.length + ' en folders.json');
     if (generated) console.log('  -> guarda esta contrasena: no se vuelve a mostrar.');
     console.log('');
+    console.log('  QR local (misma PC):');
+    printQr('http://127.0.0.1:' + port + '/chat.php');
+    console.log('');
     console.log('Siguiente paso:  openbridge server');
     return 0;
 }
@@ -439,6 +452,12 @@ async function printStatus() {
         const sessions = await store.sessionsListFull();
         console.log('  chats  : ' + sessions.length);
     } catch (e) { /* sin datos todavia */ }
+    const target = rt.publicUrl || rt.localUrl;
+    if (target) {
+        console.log('');
+        console.log(rt.publicUrl ? '  escanea para abrir en el celular:' : '  QR local (misma PC):');
+        if (!printQr(target)) console.log('  (URL demasiado larga para el QR; usa el link de arriba)');
+    }
     return true;
 }
 
@@ -447,6 +466,73 @@ async function cmdStatus() {
     return 0;
 }
 
+// Muestra la URL como QR para escanear desde el celular.
+async function cmdQr() {
+    const rt = readRuntime();
+    if (rt && pidAlive(rt.pid) && (rt.publicUrl || rt.localUrl)) {
+        const target = rt.publicUrl || rt.localUrl;
+        console.log((rt.publicUrl ? 'URL publica' : 'URL local') + ': ' + target);
+        console.log('');
+        if (!printQr(target)) { console.log('URL demasiado larga para el QR.'); return 1; }
+        return 0;
+    }
+    if (!paths.exists()) {
+        console.error('No hay configuracion. Corre primero: openbridge init');
+        return 1;
+    }
+    const app = config.readApp();
+    const url = 'http://' + (app.host || '127.0.0.1') + ':' + (app.port || 8799) + '/chat.php';
+    console.log('URL local (el server no esta corriendo): ' + url);
+    console.log('');
+    if (!printQr(url)) { console.log('URL demasiado larga para el QR.'); return 1; }
+    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;
@@ -743,6 +829,8 @@ function usage() {
     console.log('  passwd    Cambia la contrasena de acceso (--password <clave>)');
     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])');
@@ -751,7 +839,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)');
 }
 
@@ -773,6 +861,8 @@ async function main(argv) {
         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));