@danieltmn/tamnora 0.9.6 → 0.11.0

package/CHANGELOG.md

@@ -5,6 +5,35 @@ 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.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
+
+- **Acceso remoto con Tailscale**: nuevo proveedor `tailscale` para `tamnora
+  bridge` (default). Levanta `tailscale serve` y publica HTTPS dentro del tailnet
+  reenviando a loopback, asi que la velocidad es casi local, no hay exposicion
+  publica y la consola + tools funcionan como en local (una sola base, sin sync).
+  `tunnelState()` ignora este proveedor para que los guards locales sigan
+  confiando; `bridge --start/--stop/--status` y el QR lo soportan.
+
+### Obsoleto
+
+- Los tuneles publicos `tunnelmole` y `relay` quedan como **legacy** (`bridge`
+  avisa al usarlos) y **se retiran en la proxima version**. Hasta entonces siguen
+  funcionales; el relay (`harness.tamnora.com`) continua online. `tunnelmole` se
+  conserva solo para el feature de `preview`.
+
 ## [0.9.6] - 2026-10-08
 
 ### Cambios

package/README.md

@@ -144,17 +144,28 @@ corre en modo local sin login. Al cambiar el usuario se detiene el server
 
 ### Acceso remoto
 
+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
-tamnora bridge --start        # abre un tunel publico (tunnelmole) + QR
-tamnora bridge --status       # URL publica
-tamnora bridge --reload       # reinicia el tunel
-tamnora bridge --stop
+# 1. Instalar Tailscale en esta PC y en el dispositivo remoto (misma cuenta)
+#    https://tailscale.com/download
+tamnora user --name yo --password unaClaveLarga
+
+# 2. Server + acceso remoto
+tamnora bridge --start          # tailscale serve (URL + QR)
+tamnora bridge --status         # https://<pc>.<tailnet>.ts.net
+tamnora bridge --stop           # tailscale serve reset
 ```
 
-`tamnora bridge` abre un tunel (tunnelmole) hacia tu server local y muestra la
-URL publica **y un QR** para abrirlo desde el celular. Trabaja protegido por el
-login del server: configura un usuario antes de exponerlo (ver
-[`SECURITY.md`](SECURITY.md)).
+`tamnora bridge --start` muestra la URL y un **QR** para abrirlo desde el celu.
+Sigue protegido por el login del server: configura un usuario antes de exponerlo
+(ver [`SECURITY.md`](SECURITY.md)).
+
+Los tuneles publicos (tunnelmole, relay) fueron **retirados**; `tunnelmole` se
+conserva solo para el feature de *preview*.
 
 ### Telegram (canales de mensajeria)
 

package/SECURITY.md

@@ -14,13 +14,16 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
 
 - **Local (loopback)**: quien ya tiene tu sesion de usuario ya puede correr
   comandos; el server no agrega una barrera adicional mas alla del login.
-- **Acceso remoto por tunel (tunnelmole)**: la URL publica es accesible desde
-  Internet. Configura un **usuario** (asi toda `/api/*` pide sesion) con una
-  **contrasena fuerte**; nunca expongas un server sin login. El tunnel reenvia
-  por loopback, de modo que una vez autenticado se alcanza toda la consola
-  (incluidos el explorador de archivos y el selector de carpetas): tratalo como
-  acceso completo a tu maquina. Cierra el tunnel (`tamnora bridge --stop`) cuando
-  no lo uses.
+- **Acceso remoto por Tailscale (recomendado)**: `tailscale serve` publica el
+  server **solo dentro de tu tailnet** y reenvia por loopback. No hay exposicion
+  publica; quien accede es uno de tus dispositivos. Aun asi configura un
+  **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 (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,
@@ -18,7 +11,7 @@ import {
   tailLines,
   bridgeLogPath,
 } from '../lib/daemon.js';
-import { startTunnel } from '../lib/tunnel.js';
+import { startTunnel, probeTailscale, resetTailscaleServe } from '../lib/tunnel.js';
 import { qrTerminal } from '../lib/qr.js';
 
 const OPTIONS = {
@@ -40,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) {
@@ -62,47 +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 || 'tunnelmole').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 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 === '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();
@@ -113,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 tunel (${provider}) en el puerto ${port}...`);
+  console.log(`Abriendo acceso remoto (tailscale) en el puerto ${port}...`);
 
   const state = await waitForState(() => readBridgeState(), {
     childPid: child.pid,
@@ -128,123 +118,55 @@ async function cmdStart(values) {
   if (!state) {
     const tail = tailLines(bridgeLogPath(), 8);
     if (tail) console.log(tail);
-    console.log('No pude abrir el tunel. Revisa: tamnora bridge --status');
+    console.log('No pude abrir el acceso remoto. Revisa: tamnora bridge --status');
     return 1;
   }
   printStatus(state, true);
   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 runForeground(values) {
-  const { port, provider, app } = resolve(values);
-  const log = createFileLogger(bridgeLogPath());
-  const extra = { provider };
-  if (provider === 'relay') {
-    const relay = ensureRelayConfig(app);
-    extra.relayUrl = relay.relayUrl;
-    extra.token = relay.token;
+  const { port, provider } = resolve(values);
+  if (!isTailscale(provider)) {
+    console.error(`Proveedor no soportado: "${provider}". El acceso remoto usa Tailscale.`);
+    return 1;
   }
-
-  // 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;
+  const log = createFileLogger(bridgeLogPath());
   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 = await startTunnel(port, 'tailscale', { log, verbose: values.verbose });
+  } catch (error) {
+    log(`ERROR: ${error.message}`);
+    console.error(error.message);
+    return 1;
   }
-
+  writeBridgeState({
+    pid: process.pid,
+    url: tun.url,
+    provider: 'tailscale',
+    port,
+    childPid: 0,
+    startedAt: new Date().toISOString(),
+  });
+  printStatus(readBridgeState(), true);
+  log(`Tailscale: ${tun.url}`);
+  // Sin proceso hijo ni timers, el event loop quedaria vacio y node saldria:
+  // un timer referenced mantiene vivo al supervisor hasta la senal de apagado.
+  await new Promise((resolve) => {
+    const keepAlive = setInterval(() => {}, 1 << 30);
+    const stop = () => {
+      clearInterval(keepAlive);
+      resolve();
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+  });
   try {
-    tun?.stop?.();
+    await tun.stop?.();
   } catch {
     /* nada */
   }
@@ -254,7 +176,7 @@ async function runForeground(values) {
 
 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++) {
@@ -266,21 +188,22 @@ async function cmdReload(values) {
 async function cmdStop() {
   const state = readBridgeState();
   const stopped = [];
-  // Mata el supervisor y tambien el proceso del tunel (aunque el supervisor
-  // haya muerto y haya quedado huerfano).
-  if (state?.pid && pidAlive(state.pid)) {
+  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 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;
 }
@@ -296,17 +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}`);
+  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}`);
     }
   }
 }
@@ -314,22 +237,20 @@ function printStatus(state, withQr = false) {
 function printHelp() {
   console.log(`Uso: tamnora bridge [accion] [opciones]
 
-Abre un tunel publico (tunnelmole) hacia el server local para trabajar remoto.
+Da acceso remoto al server local con Tailscale (VPN privada) y muestra la URL + QR.
 
 Acciones:
-  --start           Abre el tunel en segundo plano + QR (default)
-  --reload          Reinicia el tunel
-  --stop            Cierra el tunel
-  --status          Estado y URL publica
+  --start           Abre el acceso en segundo plano + QR (default)
+  --reload          Reinicia
+  --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: tunnelmole o relay)
   --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 tunel sin usuario configurado (peligroso)
+  --insecure        Permitir el acceso sin usuario configurado (peligroso)
 
-Relay propio (app.json -> tunnel: { provider: "relay", relayUrl, token }): URLs
-estables via https://harness.tamnora.com; el QR abre la consola agregada con el
-token ya puesto.`);
+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 } 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', () => {
@@ -13,6 +13,25 @@ test('parseTunnelmoleUrls ignores unrelated output', () => {
   assert.deepEqual(parseTunnelmoleUrls('starting tunnelmole...'), { https: '', http: '' });
 });
 
+test('parseTailscaleStatus lee el DNSName del nodo y su IPv4', () => {
+  const out = parseTailscaleStatus(
+    JSON.stringify({ Self: { DNSName: 'pc.tailnet.ts.net.', TailscaleIPs: ['100.64.0.5', 'fd7a:115c:a1e0::5'] } })
+  );
+  assert.equal(out.dnsName, 'pc.tailnet.ts.net');
+  assert.equal(out.ipv4, '100.64.0.5');
+  assert.ok(out.connected);
+});
+
+test('parseTailscaleStatus marca desconectado sin DNSName', () => {
+  const out = parseTailscaleStatus(JSON.stringify({ Self: { TailscaleIPs: [] } }));
+  assert.equal(out.connected, false);
+  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

@@ -9,7 +9,7 @@ import { appConfigPath, ensureHome } from './home.js';
 export const DEFAULT_APP = {
   port: 4517,
   host: '127.0.0.1',
-  tunnel: { provider: 'tunnelmole', domain: '' },
+  tunnel: { provider: 'tailscale', domain: '' },
   authSecret: '',
   user: null,
   // Datos del usuario para que el agente lo conozca (se inyecta en el prompt).
@@ -29,6 +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 `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

@@ -94,7 +94,17 @@ export {
   registryServerToConfig,
   normalizeMcpConfig,
 } from './mcp/registry.js';
-export { parseTunnelmoleUrls, startTunnelmole, startRelay, startTunnel, tunnelState, tunnelActive } from './tunnel.js';
+export {
+  parseTunnelmoleUrls,
+  parseTailscaleStatus,
+  probeTailscale,
+  resetTailscaleServe,
+  startTailscaleServe,
+  startTunnelmole,
+  startTunnel,
+  tunnelState,
+  tunnelActive,
+} from './tunnel.js';
 export {
   TRUSTED_CLIENT_TOKEN,
   EDGE_VERSION,