@danieltmn/tamnora 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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

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,

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

@@ -6,11 +6,7 @@ import { pidAlive, killPidTree } from './pid.js';
 /**
  * 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.
+ *  - tunnelmole: tunel publico gratis (URL aleatoria); solo para `preview`.
  */
 
 function killTree(child) {
@@ -116,7 +112,7 @@ function spawnTunnel(bin, args, opts = {}) {
   });
 }
 
-// LEGACY: proveedor legacy de `bridge`; se conserva para el feature `preview`.
+// Tunel publico para el feature `preview` (no lo usa `bridge`).
 export function startTunnelmole(port, opts = {}) {
   return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
     ...opts,
@@ -127,13 +123,6 @@ 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
@@ -245,152 +234,11 @@ 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 ?? '');
-  if (!relayUrl || !/^https?:\/\//.test(relayUrl)) {
-    throw new Error('relay: falta tunnel.relayUrl (https://harness.tamnora.com/index.php)');
-  }
-  if (!token) throw new Error('relay: falta tunnel.token');
-  const log = opts.log ?? (() => {});
-  const local = `http://127.0.0.1:${port}`;
-  const state = { stopped: false };
-
-  const call = async (action, body = {}, { timeoutMs = 30000 } = {}) => {
-    const res = await fetch(`${relayUrl}?a=${action}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ token, ...body }),
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!res.ok) throw new Error(`relay ${action}: HTTP ${res.status}`);
-    return res.json();
-  };
-
-  async function push(rid, chunks) {
-    await call('push', { rid, chunks }, { timeoutMs: 60000 });
-  }
-
-  async function handleRequest(row) {
-    const envelope = typeof row.payload === 'string' ? JSON.parse(row.payload) : row.payload;
-    const method = envelope.method ?? 'GET';
-    const path = String(envelope.path ?? '/');
-    const target = `${local}${path.startsWith('/') ? path : `/${path}`}`;
-    const init = { method, headers: { ...envelope.headers } };
-    delete init.headers.host;
-    if (envelope.body != null) init.body = envelope.body;
-    const res = await fetch(target, init);
-    const contentType = String(res.headers.get('content-type') ?? '');
-    const flat = {};
-    for (const header of ['content-type']) {
-      const value = res.headers.get(header);
-      if (value) flat[header] = value;
-    }
-    const cookies = res.headers.getSetCookie?.() ?? [];
-    if (cookies.length) flat['set-cookie'] = cookies;
-
-    if (!contentType.includes('text/event-stream')) {
-      const buffer = Buffer.from(await res.arrayBuffer());
-      await push(row.id, [
-        {
-          status: res.status,
-          headers: flat,
-          body: buffer.toString('base64'),
-          done: true,
-        },
-      ]);
-      return;
-    }
-
-    // SSE: reenviamos cada frame tal cual (el cliente sabe reconectar con cursor).
-    let seq = 0;
-    await push(row.id, [{ seq: seq++, status: res.status, headers: flat, done: false }]);
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    for (;;) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let index;
-      while ((index = buffer.indexOf('\n\n')) !== -1) {
-        const frame = buffer.slice(0, index);
-        buffer = buffer.slice(index + 2);
-        let ev = '';
-        let data = '';
-        let id = null;
-        for (const line of frame.split('\n')) {
-          if (line.startsWith('event:')) ev = line.slice(6).trim();
-          else if (line.startsWith('data:')) data += line.slice(5).trim();
-          else if (line.startsWith('id:')) id = line.slice(3).trim();
-        }
-        if (!ev && !data) continue;
-        await push(row.id, [{ seq: seq++, ev: ev || 'message', data, id, done: false }]);
-      }
-    }
-    await push(row.id, [{ done: true }]);
-  }
-
-  async function pump() {
-    const registered = await call('register', {}, { timeoutMs: 20000 });
-    let cursor = Number(registered.cursor) || 0;
-    log(`relay: conectado a ${relayUrl} (inbox desde ${cursor})`);
-    while (!state.stopped) {
-      let rows;
-      try {
-        const batch = await call('poll', { after: cursor, wait: 20 }, { timeoutMs: 40000 });
-        rows = batch.rows ?? [];
-      } catch (error) {
-        if (state.stopped) break;
-        log(`relay poll: ${error?.message ?? error}`);
-        await new Promise((r) => setTimeout(r, 3000));
-        continue;
-      }
-      for (const row of rows) {
-        cursor = Math.max(cursor, Number(row.id) || 0);
-        try {
-          await handleRequest(row);
-        } catch (error) {
-          log(`relay request ${row.id}: ${error?.message ?? error}`);
-          try {
-            await push(row.id, [
-              {
-                status: 502,
-                headers: { 'content-type': 'application/json; charset=utf-8' },
-                body: Buffer.from(JSON.stringify({ error: `harness inaccesible: ${error?.message ?? error}` })).toString('base64'),
-                done: true,
-              },
-            ]);
-          } catch {
-            /* nada */
-          }
-        }
-      }
-    }
-  }
-
-  pump().catch((error) => {
-    if (!state.stopped) log(`relay pump: ${error?.message ?? error}`);
-  });
-
-  return {
-    url: relayUrl,
-    provider: 'relay',
-    pid: 0,
-    child: null,
-    probeUrl: `${relayUrl}?a=status`,
-    stop() {
-      state.stopped = true;
-    },
-  };
-}
-
 /** Devuelve { url, provider, pid, stop }. provider 'none' no abre nada. */
 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,13 +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 () => {
+test('readApp migra los proveedores retirados (tunnelmole/relay) a tailscale', 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');
+  for (const provider of ['tunnelmole', 'relay']) {
+    const app = ensureApp();
+    app.tunnel = { ...app.tunnel, provider };
+    writeApp(app);
+    assert.equal(readApp().tunnel.provider, 'tailscale', provider);
+  }
 });
 
 test('migrateLegacyDb copies the legacy project database to the global home', async () => {

package/harness/packages/server/public/app.js

@@ -3,7 +3,6 @@
 import { renderMarkdown, speechText } from './markdown.js';
 import { streamSse, followRun } from './runStream.js';
 import { diffState, pollDelayMs, localState, summarizeArgs } from './reconcile.js';
-import { installRelayTransport, showRelayTokenGate } from './relayClient.js';
 
 const $ = (sel) => document.querySelector(sel);
 let csrfToken = '';
@@ -97,30 +96,7 @@ function icon(name, size = 16, className = '') {
 
 /* --- HTTP / SSE ---------------------------------------------------------- */
 
-// Tamnora Relay: cuando la consola se sirve desde harness.tamnora.com/console,
-// el page define `window.TAMNORA_RELAY = { base }` y todo el trafico /api pasa
-// por el mailbox del relay (relaClient). Sin esa variable es el harness local.
-const RELAY_CONFIG = window.TAMNORA_RELAY ?? null;
-const relayToken = RELAY_CONFIG
-  ? new URLSearchParams(location.search).get('t') || localStorage.getItem('tamnora-relay-token') || ''
-  : '';
-const relayTransport = RELAY_CONFIG
-  ? installRelayTransport({ base: RELAY_CONFIG.base, token: relayToken })
-  : null;
-
-if (RELAY_CONFIG && !relayTransport.enabled) {
-  showRelayTokenGate();
-  throw new Error('[relay] falta el token de acceso');
-}
-
 async function api(path, { method = 'GET', body, headers = {} } = {}) {
-  if (relayTransport?.enabled) {
-    return relayTransport.request(path, {
-      method,
-      body,
-      headers: method !== 'GET' && csrfToken ? { 'x-csrf': csrfToken, ...headers } : headers,
-    });
-  }
   const init = {};
   if (body) init['Content-Type'] = 'application/json';
   if (method !== 'GET' && csrfToken) init['x-csrf'] = csrfToken;
@@ -145,13 +121,10 @@ async function api(path, { method = 'GET', body, headers = {} } = {}) {
 }
 
 const streamPost = (url, body, onEvent, signal) =>
-  relayTransport?.enabled
-    ? relayTransport.stream(url, { method: 'POST', body, signal, headers: csrfToken ? { 'x-csrf': csrfToken } : {} }, onEvent)
-    : streamSse(url, { method: 'POST', body, csrf: csrfToken, signal }, onEvent);
+  streamSse(url, { method: 'POST', body, csrf: csrfToken, signal }, onEvent);
 
 /** SSE GET de la consola (/api/sessions/:id/stream, /api/events). */
-const openStream = (url, opts, onEvent) =>
-  relayTransport?.enabled ? relayTransport.stream(url, opts, onEvent) : streamSse(url, opts, onEvent);
+const openStream = (url, opts, onEvent) => streamSse(url, opts, onEvent);
 
 /* --- localStorage (todas las lecturas/escrituras pasan por aca) ------------ */
 
@@ -601,7 +574,7 @@ if (logout) {
     } catch {
       // igual salimos
     }
-    location.href = relayTransport?.enabled ? location.pathname : '/landing';
+    location.href = '/landing';
   });
 }
 

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.10.0</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span class="ver">v0.11.0</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.10.0",
+  "version": "0.11.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",

package/harness/packages/server/public/relayClient.js

@@ -1,170 +0,0 @@
-// Transporte relay para la consola estatica (harness.tamnora.com/console/).
-//
-// La misma consola corre en el harness local y en el tamnora del sitio: aqui
-// cada llamada a `api()` y cada stream se manda por el mailbox del relay y el
-// daemon local (`tamnora bridge --tunnel relay`) la ejecuta contra su propio
-// server. El token (?t=...) es la credencial compartida con el mailbox.
-//
-// Requiere runStream.js (streamSse/delay) que ya carga la consola.
-
-import { streamSse, delay } from './runStream.js';
-
-export function installRelayTransport({ base, token }) {
-  const cleanToken = String(token ?? '').trim();
-  if (!cleanToken) {
-    console.warn('[relay] sin token: la consola vera solo la pantalla de login');
-  }
-
-  const b64decode = (value) =>
-    new TextDecoder().decode(Uint8Array.from(atob(String(value ?? '')), (c) => c.charCodeAt(0)));
-
-  const relayUrl = (action) => `${base}?a=${action}&t=${encodeURIComponent(cleanToken)}`;
-
-  async function post(action, payload, signal) {
-    const res = await fetch(relayUrl(action), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-      signal,
-    });
-    if (!res.ok) {
-      const error = new Error(`relay HTTP ${res.status}`);
-      error.status = res.status;
-      throw error;
-    }
-    return res.json();
-  }
-
-  function applyCookies(headers) {
-    for (const cookie of headers?.['set-cookie'] ?? []) {
-      const kv = String(cookie).split(';')[0];
-      if (kv && kv.includes('=')) document.cookie = `${kv}; Path=/`;
-    }
-  }
-
-  /** Request sincrono: PHP espera inline la respuesta completa del mailbox. */
-  async function request(path, { method = 'GET', body, headers = {} } = {}) {
-    const envelope = {
-      method,
-      path,
-      headers,
-      body: body === undefined ? null : JSON.stringify(body),
-      stream: false,
-    };
-    const data = await post('send', envelope);
-    if (data.error) {
-      const error = new Error(data.error);
-      error.status = Number(data.status) || 0;
-      throw error;
-    }
-    applyCookies(data.headers);
-    const text = b64decode(data.body);
-    let parsed = null;
-    try {
-      parsed = JSON.parse(text);
-    } catch {
-      parsed = { raw: text };
-    }
-    if (Number(data.status) >= 400) {
-      const error = new Error(parsed?.error ?? `HTTP ${data.status}`);
-      error.status = Number(data.status);
-      throw error;
-    }
-    return parsed;
-  }
-
-  const parseOrRaw = (text) => {
-    try {
-      return JSON.parse(text);
-    } catch {
-      return { raw: text };
-    }
-  };
-
-  /**
-   * Stream via mailbox: abre el rid y consume `a=stream` (SSE con cursor).
-   * Si el PHP corta (max_execution_time) reconecta y repite desde el cursor:
-   * el replay es del mailbox, NO re-ejecuta el request original.
-   */
-  async function stream(path, { method = 'POST', body, headers = {}, signal, silenceMs } = {}, onEvent) {
-    const envelope = {
-      method,
-      path,
-      headers,
-      body: body === undefined ? null : JSON.stringify(body),
-      stream: true,
-    };
-    const opened = await post('send', envelope, signal);
-    if (opened.error) {
-      const error = new Error(opened.error);
-      error.status = Number(opened.status) || 0;
-      throw error;
-    }
-    const rid = opened.rid;
-    let cursor = 0;
-    let attempt = 0;
-    for (;;) {
-      if (signal?.aborted) {
-        const error = new Error('Aborted', 'AbortError');
-        error.name = 'AbortError';
-        throw error;
-      }
-      try {
-        let finished = false;
-        await streamSse(
-          `${base}?a=stream&t=${encodeURIComponent(cleanToken)}&rid=${encodeURIComponent(rid)}&from=${cursor}`,
-          { signal, silenceMs },
-          (event, data, id) => {
-            if (id != null) cursor = Number(id) || cursor;
-            if (event === 'chunk') {
-              const payload = data?.payload ?? {};
-              if (!payload.done) {
-                onEvent(payload.ev || 'message', payload.data != null ? parseOrRaw(payload.data) : {}, payload.id ?? null);
-              }
-              return;
-            }
-            // meta: headers del run o cierre del daemon.
-            if (data?.payload?.done) finished = true;
-            else if (data?.payload?.error) {
-              const error = new Error(data.payload.error);
-              error.fatalRelay = true;
-              throw error;
-            }
-          }
-        );
-        return { finished };
-      } catch (error) {
-        if (error?.name === 'AbortError' || error?.fatalRelay) throw error;
-        attempt += 1;
-        await delay(Math.min(8000, 1000 * 2 ** (attempt - 1)), signal);
-      }
-    }
-  }
-
-  window.relayTransport = { token: cleanToken, base, request, stream, enabled: Boolean(cleanToken) };
-  return window.relayTransport;
-}
-
-/** Pantalla minima si no hay token: pide uno y recarga. */
-export function showRelayTokenGate() {
-  document.body.innerHTML = '';
-  document.body.style.visibility = 'visible';
-  const form = document.createElement('form');
-  form.style.cssText = 'max-width:420px;margin:15vh auto;font-family:ui-sans-serif,system-ui;padding:0 16px';
-  form.innerHTML = `
-    <h1 style="font-size:20px">Tamnora Console</h1>
-    <p style="color:#777;font-size:14px">Pegá el token del bridge (o escaneá el QR del <code>tamnora bridge --tunnel relay</code>).</p>
-    <input name="t" placeholder="token" style="width:100%;padding:10px;font-size:14px" autocomplete="off" />
-    <button style="margin-top:10px;padding:10px 16px">entrar</button>`;
-  form.addEventListener('submit', (event) => {
-    event.preventDefault();
-    const value = form.elements.t.value.trim();
-    if (!value) return;
-    localStorage.setItem('tamnora-relay-token', value);
-    const params = new URLSearchParams(location.search);
-    params.delete('t');
-    location.href = location.pathname + (params.toString() ? `?${params}` : '');
-    location.reload();
-  });
-  document.body.append(form);
-}

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

@@ -1,219 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { mkdtemp } from 'node:fs/promises';
-import { execFileSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-
-import { createTamnoraServer } from '../src/index.js';
-import { setHome, startRelay, randomToken } from '../../core/src/index.js';
-
-const HAS_PHP = (() => {
-  try {
-    execFileSync('php', ['-v'], { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-})();
-
-const fakeProvider = {
-  id: 'fake',
-  async streamChat(_config, { onEvent }) {
-    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
-    return { content: 'hola', reasoning: '', toolCalls: [] };
-  },
-};
-
-/** SSE crudo por GET crudo (fetch con streaming del lado Node). */
-async function sseGet(url, { expectFrames = 1, timeoutMs = 30000 } = {}) {
-  const frames = [];
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const res = await fetch(url, { signal: controller.signal });
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buf = '';
-    while (frames.length < expectFrames) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buf += decoder.decode(value, { stream: true });
-      let index;
-      while ((index = buf.indexOf('\n\n')) !== -1) {
-        const frame = buf.slice(0, index);
-        buf = buf.slice(index + 2);
-        let event = null;
-        let data = '';
-        let id = null;
-        for (const line of frame.split('\n')) {
-          if (line.startsWith('event:')) event = line.slice(6).trim();
-          else if (line.startsWith('data:')) data += line.slice(5).trim();
-          else if (line.startsWith('id:')) id = line.slice(3).trim();
-        }
-        if (!event && !data) continue;
-        let parsed = {};
-        try {
-          parsed = JSON.parse(data);
-        } catch {
-          parsed = { raw: data };
-        }
-        frames.push({ event, data: parsed, id });
-        if (frames.length >= expectFrames) {
-          controller.abort();
-          break;
-        }
-      }
-    }
-  } catch (error) {
-    if (error?.name !== 'AbortError' && frames.length < expectFrames) throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-  return frames;
-}
-
-async function phpServer(docroot) {
-  const port = 44000 + Math.floor(Math.random() * 4000);
-  const args = ['-S', `127.0.0.1:${port}`, '-t', docroot];
-  const child = spawn('php', args, {
-    env: { ...process.env },
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-  });
-  let stderr = '';
-  child.stderr.on('data', (d) => (stderr += String(d)));
-  let exited = null;
-  child.on('exit', (code) => (exited = code));
-  const base = `http://127.0.0.1:${port}/index.php`;
-  // esperar a que escuche
-  let lastError = '';
-  for (let i = 0; i < 60; i++) {
-    try {
-      await fetch(`${base}?a=status`, { signal: AbortSignal.timeout(1000) });
-      return { child, base };
-    } catch (error) {
-      lastError = error?.message ?? String(error);
-      if (exited !== null) break;
-      await new Promise((r) => setTimeout(r, 250));
-    }
-  }
-  throw new Error(
-    `php server no arranco: ${JSON.stringify({ docroot, exited, lastError, stderr: stderr.slice(0, 400) })}`
-  );
-}
-
-/**
- * El PHP built-in en Windows es monohilo (PHP_CLI_SERVER_WORKERS no existe
- * alla); send/poll largos se bloquearian mutuamente. Para el test corremos
- * DOS servers sobre la misma SQLite (WAL es multi-proceso): el agente usa
- * uno, el browser el otro. En cPanel con FPM esto no hace falta.
- */
-async function relayStack(docroot) {
-  const agent = await phpServer(docroot);
-  const browser = await phpServer(docroot);
-  return { children: [agent.child, browser.child], relayBase: agent.base, browserBase: browser.base };
-}
-
-test('el relay PHP mailbox carga y hace GC', async (t) => {
-  if (!HAS_PHP) return t.skip('sin PHP disponible');
-  const docroot = path.join(import.meta.dirname, '..', '..', '..', '..', 'relay');
-  const { child, base } = await phpServer(docroot);
-  try {
-    const status = await (await fetch(`${base}?a=status`)).json();
-    assert.equal(status.ok, true);
-
-    const token = randomToken(24);
-    const reg = await (
-      await fetch(`${base}?a=register`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ token }),
-      })
-    ).json();
-    assert.equal(reg.ok, true);
-    assert.equal(reg.cursor, 0);
-
-    const bad = await fetch(`${base}?a=send&t=${token}`, {
-      method: 'POST',
-      body: JSON.stringify({ path: 'nope' }),
-    });
-    assert.equal(bad.status, 400);
-  } finally {
-    child.kill('SIGTERM');
-  }
-});
-
-test('end-to-end: request no-stream y stream de chat via relay', async (t) => {
-  if (!HAS_PHP) return t.skip('sin PHP disponible');
-
-  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-relay-'));
-  setHome(cwd);
-  const instance = await createTamnoraServer({
-    cwd,
-    dbPath: path.join(cwd, 'tamnora.db'),
-    loadMcp: false,
-    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
-  });
-  const local = await instance.listen({ port: 0 });
-
-  const docroot = path.join(import.meta.dirname, '..', '..', '..', '..', 'relay');
-  const { children, relayBase, browserBase } = await relayStack(docroot);
-  const token = randomToken(24);
-  const logs = [];
-  const pump = startRelay(local.port, { relayUrl: relayBase, token, log: (line) => logs.push(line) });
-
-  try {
-    // 1) request sincrono: /api/health pasa entero
-    const health = await (
-      await fetch(`${browserBase}?a=send&t=${token}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ method: 'GET', path: '/api/health' }),
-      })
-    ).json();
-    assert.equal(health.status, 200);
-    assert.equal(JSON.parse(Buffer.from(health.body, 'base64').toString('utf8')).ok, true);
-
-    // 2) crear sesion y correr un turno SSE via mailbox
-    const session = await (
-      await fetch(`${browserBase}?a=send&t=${token}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ method: 'POST', path: '/api/sessions', body: JSON.stringify({ title: 'relay' }) }),
-      })
-    ).json();
-    assert.equal(session.status, 201, `sesion: ${session.body && Buffer.from(session.body, 'base64').toString('utf8')}`);
-    const sessionId = JSON.parse(Buffer.from(session.body, 'base64').toString('utf8')).session.id;
-
-    const opened = await (
-      await fetch(`${browserBase}?a=send&t=${token}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          method: 'POST',
-          path: '/api/chat',
-          body: JSON.stringify({ input: 'hola', sessionId, model: 'm' }),
-          stream: true,
-        }),
-      })
-    ).json();
-    assert.ok(opened.rid, 'a=send stream devuelve rid');
-
-    const frames = await sseGet(`${browserBase}?a=stream&t=${token}&rid=${opened.rid}&from=0`, { expectFrames: 20 });
-    const events = frames.filter((f) => f.event === 'chunk').map((f) => f.data.payload?.ev);
-    assert.ok(events.includes('start'), `start en ${JSON.stringify(events)}`);
-    assert.ok(events.includes('text'), `text en ${JSON.stringify(events)}`);
-    const doneRow = frames.some((f) => f.event === 'meta' && f.data.payload?.done === true);
-    assert.ok(doneRow, 'la fila final done cierra el stream');
-  } catch (error) {
-    error.logs = logs.slice();
-    throw error;
-  } finally {
-    pump.stop();
-    for (const child of children) child.kill('SIGTERM');
-    await instance.close();
-  }
-});