@danieltmn/tamnora 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -5,6 +5,26 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.11.1] - 2026-10-09
+
+### Arreglado
+
+- **Consola en movil**: el input del chat ahora es un campo visible en su propia
+  linea (antes flotaba sin fondo y casi no se notaba); las cards de MCP/Skills
+  (y tambien proveedores y procesos) llevan las acciones a su propia fila y la
+  descripcion se recorta a dos lineas en vez de apretarse contra los botones.
+
+## [0.11.0] - 2026-10-09
+
+### Quitado
+
+- **Tuneles publicos retirados**: `tamnora bridge` ahora soporta unicamente
+  **tailscale**. Se elimino el relay propio (`relay/index.php`, el deploy FTPS
+  `scripts/deploy-relay.mjs` y el transporte `relayClient.js` de la consola) y el
+  proveedor `tunnelmole` dejo de ofrecerse para el acceso remoto (se conserva solo
+  para el feature de `preview`). Un `app.json` con `tunnel.provider` en
+  `tunnelmole`/`relay` se migra a `tailscale` al leerlo.
+
 ## [0.10.0] - 2026-10-09
 
 ### Agregado

package/README.md

@@ -144,11 +144,10 @@ corre en modo local sin login. Al cambiar el usuario se detiene el server
 
 ### Acceso remoto
 
-La via recomendada es **Tailscale** (VPN mesh privada, rapida y sin exponer nada
-a Internet). El server sigue escuchando en `127.0.0.1`; `tailscale serve`
-publica HTTPS dentro del tailnet y reenvia por loopback, asi que la consola y
-todas las tools funcionan igual que en local, sin sincronizar datos (una sola
-base SQLite).
+El acceso remoto usa **Tailscale** (VPN mesh privada, rapida y sin exponer nada a
+Internet). El server sigue escuchando en `127.0.0.1`; `tailscale serve` publica
+HTTPS dentro del tailnet y reenvia por loopback, asi que la consola y todas las
+tools funcionan igual que en local, sin sincronizar datos (una sola base SQLite).
 
 ```bash
 # 1. Instalar Tailscale en esta PC y en el dispositivo remoto (misma cuenta)
@@ -156,7 +155,7 @@ base SQLite).
 tamnora user --name yo --password unaClaveLarga
 
 # 2. Server + acceso remoto
-tamnora bridge --start          # proveedor default: tailscale (URL + QR)
+tamnora bridge --start          # tailscale serve (URL + QR)
 tamnora bridge --status         # https://<pc>.<tailnet>.ts.net
 tamnora bridge --stop           # tailscale serve reset
 ```
@@ -165,14 +164,8 @@ tamnora bridge --stop           # tailscale serve reset
 Sigue protegido por el login del server: configura un usuario antes de exponerlo
 (ver [`SECURITY.md`](SECURITY.md)).
 
-Proveedores **legacy** (tuneles publicos; utiles solo si en el dispositivo remoto
-no podes instalar Tailscale). **Se retiran en la proxima version**; `tunnelmole`
-se conservara unicamente para el feature de *preview*:
-
-```bash
-tamnora bridge --start --tunnel tunnelmole   # tunel publico gratis, URL aleatoria
-tamnora bridge --start --tunnel relay        # mailbox propio (harness.tamnora.com)
-```
+Los tuneles publicos (tunnelmole, relay) fueron **retirados**; `tunnelmole` se
+conserva solo para el feature de *preview*.
 
 ### Telegram (canales de mensajeria)
 

package/SECURITY.md

@@ -20,12 +20,10 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
   **usuario** con contrasena fuerte (defensa en profundidad). Como entra por
   loopback, una vez autenticado se alcanza toda la consola y las tools
   (explorador de archivos, shell, git): tratalo como acceso completo a tu PC.
-- **Tuneles publicos (legacy: tunnelmole / relay, se retiran en la proxima
-  version)**: la URL es accesible desde Internet. Configura un **usuario** con
-  **contrasena fuerte**; nunca expongas un server sin login. El tunnel reenvia
-  por loopback, de modo que una vez autenticado se alcanza toda la consola:
-  tratalo como acceso completo a tu maquina. Cierra el tunnel (`tamnora bridge
-  --stop`) cuando no lo uses.
+- **Tuneles publicos (retirados)**: las versiones anteriores usaban tunnelmole y
+  un relay propio para exponer la consola desde Internet. Se retiraron; el acceso
+  remoto hoy es solo por Tailscale. `tunnelmole` sobrevive unicamente para el
+  feature de *preview* de dev servers, que no expone la consola.
 - **Credenciales**: las API keys de proveedores se guardan en la base SQLite de
   la casa local (fuera del repo) **en texto plano**; protege el archivo con los
   permisos del sistema. Para no persistirlas, usa `"apiKey": "env:VAR"` y

package/harness/packages/cli/src/cli.js

@@ -72,7 +72,7 @@ Uso:
   tamnora mcp                     Listar servidores y herramientas MCP
   tamnora server [--init|--start|--reload|--stop|--status|--logs]   Server en segundo plano (abre el navegador)
   tamnora user                    Usuario local (login del server)
-  tamnora bridge [--start|--reload|--stop|--status]   Tunel publico (tunnelmole) + QR
+  tamnora bridge [--start|--reload|--stop|--status]   Acceso remoto con Tailscale + QR
   tamnora autostart install|remove    Arranque automatico del server
   tamnora serve                   Consola web local (primer plano)
   tamnora doctor                  Verificar Node, casa, puerto y base

package/harness/packages/cli/src/commands/bridge.js

@@ -1,11 +1,4 @@
-import {
-  homeDir,
-  ensureHome,
-  ensureApp,
-  writeApp,
-  readApp,
-  randomToken,
-} from '../../../core/src/index.js';
+import { homeDir, ensureHome, ensureApp } from '../../../core/src/index.js';
 import { parse, num } from '../lib/util.js';
 import {
   applyHomeOverride,
@@ -21,17 +14,6 @@ import {
 import { startTunnel, probeTailscale, resetTailscaleServe } from '../lib/tunnel.js';
 import { qrTerminal } from '../lib/qr.js';
 
-// Tuneles publicos legacy: se retiran en la proxima version. `tunnelmole` se
-// conserva solo para el feature de `preview` (no como proveedor de `bridge`).
-const LEGACY_PROVIDERS = new Set(['tunnelmole', 'tmole', 'relay']);
-
-function warnLegacy(provider) {
-  const p = String(provider).toLowerCase();
-  if (!LEGACY_PROVIDERS.has(p)) return;
-  console.log(`Aviso: "${p}" es legacy (tunel publico) y se retirara en la proxima version.`);
-  console.log('El camino recomendado es --tunnel tailscale (VPN privada).');
-}
-
 const OPTIONS = {
   start: { type: 'boolean' },
   reload: { type: 'boolean' },
@@ -51,6 +33,8 @@ const readBridgeState = () => bridgeState.read();
 const writeBridgeState = (data) => bridgeState.write(data);
 const clearBridgeState = () => bridgeState.clear();
 
+const isTailscale = (provider) => provider === 'tailscale' || provider === 'ts';
+
 export async function bridgeCommand(argv) {
   const { values } = parse(argv, OPTIONS);
   if (values.help) {
@@ -73,61 +57,42 @@ export async function bridgeCommand(argv) {
 function resolve(values) {
   ensureHome();
   const app = ensureApp();
+  const requested = values.tunnel ? String(values.tunnel).toLowerCase() : '';
   return {
     port: num(values.port, app.port || 4517),
-    provider: String(values.tunnel || app.tunnel?.provider || 'tailscale').toLowerCase(),
+    provider: requested || String(app.tunnel?.provider || 'tailscale').toLowerCase(),
     app,
   };
 }
 
-/** Asegura la configuracion del relay (url + token) en app.json y la devuelve. */
-function ensureRelayConfig(app) {
-  const tunnel = { ...app.tunnel };
-  if (!tunnel.relayUrl) {
-    tunnel.relayUrl = process.env.TAMNORA_RELAY_URL || 'https://harness.tamnora.com/index.php';
-  }
-  if (!tunnel.token) {
-    tunnel.token = process.env.TAMNORA_RELAY_TOKEN || randomToken(24);
-    const current = readApp();
-    writeApp({ ...current, tunnel: { ...current.tunnel, token: tunnel.token, relayUrl: tunnel.relayUrl } });
-    console.log(`Token de relay nuevo (guardado en app.json): ${tunnel.token}`);
-  }
-  return tunnel;
-}
-
 async function cmdStart(values) {
   const { port, provider } = resolve(values);
   if (provider === 'none') {
-    console.error('El tunel esta desactivado (provider "none"). Usa --tunnel tailscale (recomendado) o --tunnel tunnelmole.');
+    console.error('El acceso remoto esta desactivado (provider "none"). Usa --tunnel tailscale.');
+    return 1;
+  }
+  if (!isTailscale(provider)) {
+    console.error(`Proveedor no soportado: "${provider}". El acceso remoto usa Tailscale.`);
+    console.error('Los tuneles publicos (tunnelmole/relay) fueron retirados.');
     return 1;
   }
 
-  // Exponer el server a Internet sin usuario configurado deja /api/* abierto
-  // (incluido /api/chat con tool bash): hay que pedirlo explicito.
+  // Por la red privada igual conviene un usuario: defensa en profundidad.
   const app = ensureApp();
   if (!app.user?.password && !values.insecure) {
-    console.error('No hay usuario configurado: por el tunel cualquiera con la URL tendria acceso total.');
+    console.error('No hay usuario configurado: sin login cualquiera en tu tailnet tendria acceso total.');
     console.error('Crea uno con: tamnora user --name <usuario> --password <clave>');
     console.error('Si igual queres abrirlo sin proteccion: tamnora bridge --insecure');
     return 1;
   }
 
-  if (provider === 'tailscale' || provider === 'ts') {
-    try {
-      const status = await probeTailscale();
-      if (!status.connected) throw new Error('Tailscale no esta conectado. Inicia sesion con `tailscale up`.');
-    } catch (error) {
-      console.error(error.message);
-      console.error('Instala Tailscale (https://tailscale.com/download) o usa --tunnel tunnelmole (legacy).');
-      return 1;
-    }
-  } else {
-    warnLegacy(provider);
-  }
-
-  if (provider === 'tunnelmole' || provider === 'tmole') {
-    console.log('Aviso: tunnelmole gratuito admite una sola conexion; si abriste el');
-    console.log('preview de la consola, cerralo (o el bridge) antes de usar el otro.');
+  try {
+    const status = await probeTailscale();
+    if (!status.connected) throw new Error('Tailscale no esta conectado. Inicia sesion con `tailscale up`.');
+  } catch (error) {
+    console.error(error.message);
+    console.error('Instala Tailscale: https://tailscale.com/download');
+    return 1;
   }
 
   const current = readBridgeState();
@@ -138,11 +103,11 @@ async function cmdStart(values) {
   }
 
   const bin = process.argv[1];
-  const args = [bin, 'bridge', '--foreground', '--port', String(port), '--tunnel', provider];
+  const args = [bin, 'bridge', '--foreground', '--port', String(port)];
   if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
   if (values.verbose) args.push('--verbose');
   const { child, isDead } = spawnDetached(args, { envFlag: 'TAMNORA_BRIDGE_CHILD' });
-  console.log(`Abriendo acceso remoto (${provider}) en el puerto ${port}...`);
+  console.log(`Abriendo acceso remoto (tailscale) en el puerto ${port}...`);
 
   const state = await waitForState(() => readBridgeState(), {
     childPid: child.pid,
@@ -160,17 +125,16 @@ async function cmdStart(values) {
   return 0;
 }
 
-/** URL publica para el celular: la consola agregada al relay con el token. */
-function relayConsoleUrl(extra) {
-  const base = String(extra.relayUrl ?? '').replace(/\/+$/, '').replace(/index\.php$/, '').replace(/\/$/, '');
-  return `${base}/console/?t=${extra.token}`;
-}
-
 /**
  * Tailscale es configuracion persistente (`tailscale serve`), no un proceso:
  * no hay health-check ni bucle de reconexion, solo esperar la senal de apagado.
  */
-async function runTailscaleForeground(values, port) {
+async function runForeground(values) {
+  const { port, provider } = resolve(values);
+  if (!isTailscale(provider)) {
+    console.error(`Proveedor no soportado: "${provider}". El acceso remoto usa Tailscale.`);
+    return 1;
+  }
   const log = createFileLogger(bridgeLogPath());
   let tun;
   try {
@@ -210,121 +174,9 @@ async function runTailscaleForeground(values, port) {
   return 0;
 }
 
-async function runForeground(values) {
-  const { port, provider, app } = resolve(values);
-  if (provider === 'tailscale' || provider === 'ts') return runTailscaleForeground(values, port);
-  const log = createFileLogger(bridgeLogPath());
-  const extra = { provider };
-  if (provider === 'relay') {
-    const relay = ensureRelayConfig(app);
-    extra.relayUrl = relay.relayUrl;
-    extra.token = relay.token;
-  }
-
-  // Senal de apagado: el supervisor de abajo la consulta entre intentos.
-  let interrupted = false;
-  let notifyInterrupt = null;
-  const interruptPromise = new Promise((r) => {
-    notifyInterrupt = r;
-  });
-  const shutdown = () => {
-    interrupted = true;
-    notifyInterrupt();
-  };
-  process.once('SIGINT', shutdown);
-  process.once('SIGTERM', shutdown);
-  const sleep = (ms) =>
-    new Promise((r) => {
-      const t = setTimeout(r, ms);
-      interruptPromise.then(() => {
-        clearTimeout(t);
-        r();
-      });
-    });
-
-  // Supervision: si el proceso del tunel muere (el servicio gratuito lo hace a
-  // menudo), reconecta con backoff y reescribe el estado con la URL nueva.
-  let attempt = 0;
-  let tun;
-  for (;;) {
-    try {
-      tun = await startTunnel(port, provider, { log, verbose: values.verbose, ...extra });
-    } catch (err) {
-      if (interrupted) break;
-      log(`ERROR: ${err.message}`);
-      return 1;
-    }
-    if (!tun.url) {
-      log('ERROR: el tunel no devolvio URL.');
-      return 1;
-    }
-
-    writeBridgeState({
-      pid: process.pid,
-      url: tun.url,
-      publicUrl: provider === 'relay' ? relayConsoleUrl(extra) : undefined,
-      provider: tun.provider,
-      port,
-      childPid: tun.pid,
-      startedAt: new Date().toISOString(),
-    });
-    printStatus(readBridgeState(), true);
-    log(`Tunel publico: ${tun.url}`);
-    attempt = 0;
-
-    const exitCode = await new Promise((r) => {
-      // Health-check cada 60 s: si la URL publica deja de responder dos veces
-      // seguidas, matamos el tunel y el supervisor abre otro.
-      let fails = 0;
-      const probe = async () => {
-        const probeUrl = tun.probeUrl ?? `${tun.url}/api/health`;
-        try {
-          const res = await fetch(probeUrl, { signal: AbortSignal.timeout(8000) });
-          if (res.ok) fails = 0;
-          else fails += 1;
-        } catch {
-          fails += 1;
-        }
-        if (fails >= 2) {
-          log(`La URL publica no responde (${tun.url}); reiniciando el tunel...`);
-          tun.stop();
-        }
-      };
-      const health = setInterval(probe, 60000);
-      health.unref?.();
-      tun.child?.once('exit', (code) => {
-        clearInterval(health);
-        r(code ?? 1);
-      });
-      if (!tun.child) {
-        clearInterval(health);
-        r(0);
-      }
-      interruptPromise.then(() => {
-        clearInterval(health);
-        r('signal');
-      });
-    });
-
-    if (interrupted || exitCode === 'signal') break;
-    attempt += 1;
-    const wait = Math.min(30000, 2000 * attempt);
-    log(`El tunel termino (codigo ${exitCode}); reconectando en ${Math.round(wait / 1000)} s...`);
-    await sleep(wait);
-  }
-
-  try {
-    tun?.stop?.();
-  } catch {
-    /* nada */
-  }
-  clearBridgeState();
-  return 0;
-}
-
 async function cmdReload(values) {
   // Leer el estado ANTES de parar: clearBridgeState borra el archivo y despues
-  // no habria nada que esperar (el tunel viejo seguia muriendo).
+  // no habria nada que esperar.
   const previous = readBridgeState();
   await cmdStop();
   for (let i = 0; i < 25 && previous?.pid && pidAlive(previous.pid); i++) {
@@ -336,29 +188,22 @@ async function cmdReload(values) {
 async function cmdStop() {
   const state = readBridgeState();
   const stopped = [];
-  if (state?.provider === 'tailscale') {
-    try {
-      await resetTailscaleServe();
-      stopped.push('tailscale serve');
-    } catch (error) {
-      console.log(`No pude ejecutar tailscale serve reset: ${error.message}`);
-    }
+  if (!state) {
+    console.log('El bridge no esta corriendo.');
+    return 0;
+  }
+  try {
+    await resetTailscaleServe();
+    stopped.push('tailscale serve');
+  } catch (error) {
+    console.log(`No pude ejecutar tailscale serve reset: ${error.message}`);
   }
-  // Mata el supervisor y tambien el proceso del tunel (aunque el supervisor
-  // haya muerto y haya quedado huerfano).
-  if (state?.pid && pidAlive(state.pid)) {
+  // Mata el supervisor si quedo vivo.
+  if (state.pid && pidAlive(state.pid)) {
     killPid(state.pid);
     stopped.push(`bridge ${state.pid}`);
   }
-  if (state?.childPid && pidAlive(state.childPid)) {
-    killPid(state.childPid);
-    stopped.push(`tunel ${state.childPid}`);
-  }
   clearBridgeState();
-  if (!stopped.length) {
-    console.log('El bridge no esta corriendo.');
-    return 0;
-  }
   console.log(`Bridge detenido (${stopped.join(', ')}).`);
   return 0;
 }
@@ -374,18 +219,17 @@ async function cmdStatus() {
 }
 
 function printStatus(state, withQr = false) {
-  const shown = state.publicUrl || state.url;
   console.log(`Bridge corriendo (pid ${state.pid})`);
-  console.log(`  url     : ${shown}`);
+  console.log(`  url     : ${state.url}`);
   console.log(`  proveedor: ${state.provider}   puerto local: ${state.port}`);
-  if (state.provider === 'tailscale') console.log('  red     : privada (tailnet; solo tus dispositivos)');
+  console.log('  red     : privada (tailnet; solo tus dispositivos)');
   console.log(`  casa    : ${homeDir()}`);
   if (withQr && state.url) {
-    const art = qrTerminal(shown, 2);
+    const art = qrTerminal(state.url, 2);
     if (art) {
       console.log('');
       console.log(art);
-      console.log(`  escanea para abrir ${shown}`);
+      console.log(`  escanea para abrir ${state.url}`);
     }
   }
 }
@@ -393,23 +237,20 @@ function printStatus(state, withQr = false) {
 function printHelp() {
   console.log(`Uso: tamnora bridge [accion] [opciones]
 
-Da acceso remoto al server local y muestra la URL + QR.
+Da acceso remoto al server local con Tailscale (VPN privada) y muestra la URL + QR.
 
 Acciones:
   --start           Abre el acceso en segundo plano + QR (default)
   --reload          Reinicia
-  --stop            Cierra
+  --stop            Cierra (tailscale serve reset)
   --status          Estado y URL
   --foreground      Corre en primer plano (debug)
 
 Opciones:
-  --tunnel <prov>   Proveedor (default: el de app.json; hoy: tailscale)
-                    tailscale  VPN privada via \`tailscale serve\` (recomendado)
-                    tunnelmole tunel publico gratis, URL aleatoria (legacy*)
-                    relay      mailbox propio en harness.tamnora.com (legacy*)
-
-Tailscale requiere instalarlo y estar logueado (https://tailscale.com/download).
+  --port <n>        Puerto local a exponer (default: el del server)
+  --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+  --insecure        Permitir el acceso sin usuario configurado (peligroso)
 
-* Los tuneles publicos (tunnelmole/relay) se retiran en la proxima version.
-  tunnelmole se conserva solo para el feature de "preview".`);
+Requiere Tailscale instalado y logueado (https://tailscale.com/download) en la PC
+y en el dispositivo remoto.`);
 }

package/harness/packages/cli/test/tunnel.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { parseTunnelmoleUrls, parseTailscaleStatus } from '../src/lib/tunnel.js';
+import { parseTunnelmoleUrls, parseTailscaleStatus, startTunnel } from '../src/lib/tunnel.js';
 import { qrTerminal } from '../src/lib/qr.js';
 
 test('parseTunnelmoleUrls extracts the https URL', () => {
@@ -28,6 +28,10 @@ test('parseTailscaleStatus marca desconectado sin DNSName', () => {
   assert.equal(out.dnsName, '');
 });
 
+test('startTunnel rechaza el proveedor retirado (relay)', async () => {
+  await assert.rejects(() => startTunnel(4517, 'relay'), /no soportado/);
+});
+
 test('qrTerminal renders a block matrix for a URL', () => {
   const art = qrTerminal('https://abc-123.tunnelmole.net', 1);
   assert.ok(art.length > 0);

package/harness/packages/core/src/config/app.js

@@ -29,12 +29,10 @@ export function readApp() {
   }
   const app = { ...DEFAULT_APP, ...(data && typeof data === 'object' ? data : {}) };
   app.tunnel = { ...DEFAULT_APP.tunnel, ...(app.tunnel || {}) };
-  // tunnelmole fue el default viejo y quedo persistido en instalaciones previas:
-  // ahora es legacy, asi que se migra a tailscale (seguis pudiendo forzar
-  // `--tunnel tunnelmole` en cada corrida).
-  if (app.tunnel.provider === 'tunnelmole' || app.tunnel.provider === 'tmole') {
-    app.tunnel.provider = 'tailscale';
-  }
+  // `tunnelmole` fue el default viejo y `relay` fue un proveedor retirado: lo
+  // persistido en instalaciones previas se migra a tailscale.
+  const legacy = ['tunnelmole', 'tmole', 'relay'];
+  if (legacy.includes(app.tunnel.provider)) app.tunnel.provider = 'tailscale';
   return app;
 }
 

package/harness/packages/core/src/index.js

@@ -101,7 +101,6 @@ export {
   resetTailscaleServe,
   startTailscaleServe,
   startTunnelmole,
-  startRelay,
   startTunnel,
   tunnelState,
   tunnelActive,