@danieltmn/tamnora 0.9.6 → 0.10.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.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,35 @@ 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).
+
 ```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          # proveedor default: tailscale (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)).
+
+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)
+```
 
 ### Telegram (canales de mensajeria)
 

package/SECURITY.md

@@ -14,13 +14,18 @@ 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
+- **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 (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
-  (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.
+  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.
 - **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/commands/bridge.js

@@ -18,9 +18,20 @@ 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';
 
+// 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' },
@@ -64,7 +75,7 @@ function resolve(values) {
   const app = ensureApp();
   return {
     port: num(values.port, app.port || 4517),
-    provider: String(values.tunnel || app.tunnel?.provider || 'tunnelmole').toLowerCase(),
+    provider: String(values.tunnel || app.tunnel?.provider || 'tailscale').toLowerCase(),
     app,
   };
 }
@@ -87,7 +98,7 @@ function ensureRelayConfig(app) {
 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 tunel esta desactivado (provider "none"). Usa --tunnel tailscale (recomendado) o --tunnel tunnelmole.');
     return 1;
   }
 
@@ -100,6 +111,20 @@ async function cmdStart(values) {
     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.');
@@ -117,7 +142,7 @@ async function cmdStart(values) {
   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 (${provider}) en el puerto ${port}...`);
 
   const state = await waitForState(() => readBridgeState(), {
     childPid: child.pid,
@@ -128,7 +153,7 @@ 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);
@@ -141,8 +166,53 @@ function relayConsoleUrl(extra) {
   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) {
+  const log = createFileLogger(bridgeLogPath());
+  let tun;
+  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 {
+    await tun.stop?.();
+  } catch {
+    /* nada */
+  }
+  clearBridgeState();
+  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') {
@@ -266,6 +336,14 @@ 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}`);
+    }
+  }
   // Mata el supervisor y tambien el proceso del tunel (aunque el supervisor
   // haya muerto y haya quedado huerfano).
   if (state?.pid && pidAlive(state.pid)) {
@@ -300,6 +378,7 @@ function printStatus(state, withQr = false) {
   console.log(`Bridge corriendo (pid ${state.pid})`);
   console.log(`  url     : ${shown}`);
   console.log(`  proveedor: ${state.provider}   puerto local: ${state.port}`);
+  if (state.provider === 'tailscale') console.log('  red     : privada (tailnet; solo tus dispositivos)');
   console.log(`  casa    : ${homeDir()}`);
   if (withQr && state.url) {
     const art = qrTerminal(shown, 2);
@@ -314,22 +393,23 @@ 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 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
+  --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)
-
-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.`);
+  --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).
+
+* Los tuneles publicos (tunnelmole/relay) se retiran en la proxima version.
+  tunnelmole se conserva solo para el feature de "preview".`);
 }

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 } from '../src/lib/tunnel.js';
 import { qrTerminal } from '../src/lib/qr.js';
 
 test('parseTunnelmoleUrls extracts the https URL', () => {
@@ -13,6 +13,21 @@ 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('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,12 @@ 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';
+  }
   return app;
 }
 

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

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

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

@@ -4,8 +4,13 @@ import { bridgeStatePath } from './config/home.js';
 import { pidAlive, killPidTree } from './pid.js';
 
 /**
- * Tuneles publicos. v1 soporta tunnelmole (gratis, sin cuenta; URL aleatoria)
- * via `npx --yes tunnelmole <puerto>`.
+ * Acceso remoto. Proveedores:
+ *  - tailscale: VPN mesh privada + `tailscale serve` (recomendado; sin exposicion).
+ *  - tunnelmole: tunel publico gratis (URL aleatoria) — LEGACY.
+ *  - relay: mailbox HTTP propio (harness.tamnora.com) — LEGACY.
+ *
+ * Los tuneles publicos se retiran en la proxima version. `tunnelmole` se
+ * conserva solo para el feature de `preview`; `startRelay` esta condenado.
  */
 
 function killTree(child) {
@@ -32,7 +37,9 @@ export function tunnelState() {
   let state = null;
   try {
     const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
-    if (parsed?.pid && pidAlive(parsed.pid)) state = parsed;
+    // Tailscale es una red privada que entra por loopback: no es un tunel
+    // publico, asi que no debe degradar los guards locales (`localOk`).
+    if (parsed?.provider !== 'tailscale' && parsed?.pid && pidAlive(parsed.pid)) state = parsed;
   } catch {
     /* sin bridge */
   }
@@ -109,6 +116,7 @@ function spawnTunnel(bin, args, opts = {}) {
   });
 }
 
+// LEGACY: proveedor legacy de `bridge`; se conserva para el feature `preview`.
 export function startTunnelmole(port, opts = {}) {
   return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
     ...opts,
@@ -123,7 +131,120 @@ export function startTunnelmole(port, opts = {}) {
  * Relay propio (harness.tamnora.com): mailbox HTTP sobre cPanel (solo PHP).
  * El daemon no recibe conexiones: llama hacia afuera (a=poll), ejecuta cada
  * request contra el server local y empuja las respuestas (a=push).
+ *
+ * LEGACY / condenado: se retira en la proxima version (usar tailscale).
  */
+/**
+ * Tailscale: VPN mesh (WireGuard). `tailscale serve` publica HTTPS dentro del
+ * tailnet reenviando a loopback, asi que no hay exposicion publica y las
+ * peticiones siguen siendo "locales" para el server. Proveedor recomendado.
+ */
+function runTailscale(args, opts = {}) {
+  const timeoutMs = opts.timeoutMs || 15000;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn('tailscale', args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: process.platform === 'win32',
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    let out = '';
+    let err = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      killTree(child);
+      reject(new Error(`tailscale ${args.join(' ')} no respondio (${Math.round(timeoutMs / 1000)} s).`));
+    }, timeoutMs);
+    child.stdout.on('data', (data) => {
+      out += String(data);
+    });
+    child.stderr.on('data', (data) => {
+      err += String(data);
+    });
+    child.on('error', (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`no se pudo ejecutar tailscale (${error.message}). Instalalo: https://tailscale.com/download`));
+    });
+    child.on('exit', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout: out, stderr: err });
+      else {
+        const detail = err.trim() ? `: ${err.trim().slice(0, 200)}` : '';
+        reject(new Error(`tailscale ${args.join(' ')} fallo (codigo ${code})${detail}`));
+      }
+    });
+  });
+}
+
+/** Interpreta `tailscale status --json`: nombre DNS del nodo e IPv4 del tailnet. */
+export function parseTailscaleStatus(json) {
+  const data = typeof json === 'string' ? JSON.parse(json) : json ?? {};
+  const dnsName = String(data?.Self?.DNSName ?? '').replace(/\.$/, '');
+  const ipv4 = String((data?.Self?.TailscaleIPs ?? []).find((ip) => !String(ip).includes(':')) ?? '');
+  return { dnsName, ipv4, connected: Boolean(dnsName) };
+}
+
+export async function startTailscaleServe(port, opts = {}) {
+  const log = opts.log ?? (() => {});
+  let status;
+  try {
+    status = await runTailscale(['status', '--json']);
+  } catch (error) {
+    throw new Error(`tailscale no esta disponible: ${error.message}`);
+  }
+  let parsed;
+  try {
+    parsed = parseTailscaleStatus(status.stdout);
+  } catch {
+    throw new Error('no pude interpretar `tailscale status --json`.');
+  }
+  if (!parsed.connected) {
+    throw new Error('Tailscale no esta conectado. Inicia sesion con `tailscale up`.');
+  }
+  const backend = `http://127.0.0.1:${port}`;
+  try {
+    await runTailscale(['serve', '--bg', backend], { timeoutMs: 30000 });
+  } catch (first) {
+    try {
+      await runTailscale(['serve', '--bg', String(port)], { timeoutMs: 30000 });
+    } catch {
+      throw new Error(`no pude publicar con \`tailscale serve\`: ${first.message}`);
+    }
+  }
+  const url = `https://${parsed.dnsName}`;
+  log(`tailscale: ${url} -> ${backend}`);
+  return {
+    url,
+    provider: 'tailscale',
+    pid: 0,
+    child: null,
+    probeUrl: `${url}/api/health`,
+    stop: () => runTailscale(['serve', 'reset']).catch(() => {}),
+  };
+}
+
+/** Estado de Tailscale (lanza si no esta instalado o no responde). */
+export async function probeTailscale() {
+  const { stdout } = await runTailscale(['status', '--json']);
+  return parseTailscaleStatus(stdout);
+}
+
+/** Quita toda la configuracion de `tailscale serve` de este nodo. */
+export function resetTailscaleServe() {
+  return runTailscale(['serve', 'reset'], { timeoutMs: 30000 });
+}
+
 export function startRelay(port, opts = {}) {
   const relayUrl = String(opts.relayUrl ?? '').replace(/\/+$/, '');
   const token = String(opts.token ?? '');
@@ -268,6 +389,7 @@ export function startRelay(port, opts = {}) {
 export async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
   const p = String(provider || 'tunnelmole').toLowerCase();
   if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
+  if (p === 'tailscale' || p === 'ts') return startTailscaleServe(port, opts);
   if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
   if (p === 'relay') return startRelay(port, opts);
   throw new Error(`proveedor de tunel no soportado: ${provider}`);

package/harness/packages/core/test/home.test.js

@@ -48,6 +48,15 @@ test('ensureApp creates app.json with a secret and roundtrips', async () => {
   assert.equal(readApp().port, 4599);
 });
 
+test('readApp migra un tunnelmole guardado a tailscale (legacy)', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
+  setHome(dir);
+  const app = ensureApp();
+  app.tunnel = { ...app.tunnel, provider: 'tunnelmole' };
+  writeApp(app);
+  assert.equal(readApp().tunnel.provider, 'tailscale');
+});
+
 test('migrateLegacyDb copies the legacy project database to the global home', async () => {
   const home = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-cwd-'));

package/harness/packages/server/public/index.html

@@ -37,7 +37,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span class="ver">v0.9.6</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span class="ver">v0.10.0</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>

package/harness/packages/server/test/security.test.js

@@ -74,6 +74,21 @@ test('localOk exige loopback en remoteAddress y sin tunel activo', async () => {
   }
 });
 
+test('un bridge de tailscale no degrada localOk (red privada por loopback)', async () => {
+  const { instance } = await startServer();
+  try {
+    await writeFile(
+      bridgeStatePath(),
+      `${JSON.stringify({ pid: process.pid, url: 'https://pc.tailnet.ts.net', provider: 'tailscale', port: 4517 })}\n`
+    );
+    await new Promise((r) => setTimeout(r, 1100));
+    assert.ok(localOk({ socket: { remoteAddress: '127.0.0.1' } }), 'loopback sigue siendo local con tailscale');
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
 test('POST /api/shell responde 403 mientras el tunel esta activo', async () => {
   const { instance, base } = await startServer();
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.6",
+  "version": "0.10.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",