@danieltmn/tamnora 0.7.1 → 0.9.0

package/harness/packages/server/src/routes/tts.js

@@ -0,0 +1,82 @@
+// Voz (TTS): sintesis bajo demanda de la consola + ajustes persistidos en
+// app.json (la casa). La config no necesita recarga: cada consumidor la lee
+// cuando va a hablar.
+
+import { sintetizar, listarVoces, MAX_TEXTO } from '../lib/core.js';
+import { readApp, writeApp } from '../lib/core.js';
+import { ffmpegDisponible } from '../lib/ffmpeg.js';
+import { resolveTts, sanearVoz, sanearRate } from '../lib/ttsSettings.js';
+import { sendJson, sendError, readJson } from '../lib/http.js';
+
+const cacheVoces = { at: 0, data: null, filtro: 'es-' };
+
+async function catalogoVoces(filtro) {
+  const now = Date.now();
+  if (cacheVoces.data && cacheVoces.filtro === filtro && now - cacheVoces.at < 600000) {
+    return cacheVoces.data;
+  }
+  const voces = await listarVoces(filtro);
+  cacheVoces.at = now;
+  cacheVoces.data = voces;
+  cacheVoces.filtro = filtro;
+  return voces;
+}
+
+export function registerTts(route, ctx) {
+  route('GET', '/api/tts/settings', async ({ res }) => {
+    const config = resolveTts(ctx.app);
+    sendJson(res, 200, { ...config, ffmpeg: await ffmpegDisponible() });
+  });
+
+  route('PUT', '/api/tts/settings', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const actual = resolveTts(ctx.app);
+    const next = { ...actual };
+
+    if ('enabled' in body) next.enabled = body.enabled === true;
+    if ('voice' in body) next.voice = sanearVoz(body.voice, actual.voice);
+    if ('rate' in body) next.rate = sanearRate(body.rate, actual.rate);
+    if (body.announce && typeof body.announce === 'object') {
+      const announce = { ...actual.announce };
+      for (const key of ['start', 'tools', 'end']) {
+        if (key in body.announce) announce[key] = body.announce[key] === true;
+      }
+      next.announce = announce;
+    }
+
+    app.tts = next;
+    writeApp(app);
+    ctx.app = app;
+    sendJson(res, 200, { ...next, ffmpeg: await ffmpegDisponible() });
+  });
+
+  route('GET', '/api/tts/voices', async ({ res, query }) => {
+    const filtro = /^[a-zA-Z]{2}-?$/.test(String(query.get('filter') ?? 'es-')) ? query.get('filter') : 'es-';
+    try {
+      const voces = await catalogoVoces(filtro);
+      sendJson(res, 200, { voices: voces });
+    } catch (error) {
+      sendError(res, 502, `No pude listar las voces: ${error?.message ?? error}`);
+    }
+  });
+
+  route('GET', '/api/tts', async ({ res, query }) => {
+    const config = resolveTts(ctx.app);
+    const texto = String(query.get('texto') ?? '').trim().slice(0, MAX_TEXTO);
+    if (!texto) return sendError(res, 400, 'Falta "texto".');
+    const voz = sanearVoz(query.get('voice'), config.voice);
+    const rate = sanearRate(query.get('rate'), config.rate);
+    try {
+      const mp3 = await sintetizar(texto, { voice: voz, rate });
+      res.writeHead(200, {
+        'Content-Type': 'audio/mpeg',
+        'Content-Length': mp3.length,
+        'Cache-Control': 'no-store',
+      });
+      res.end(mp3);
+    } catch (error) {
+      sendError(res, 502, `No pude sintetizar: ${error?.message ?? error}`);
+    }
+  });
+}

package/harness/packages/server/src/server.js

@@ -28,14 +28,19 @@ import { registerAuth } from './routes/auth.js';
 import { registerSessions } from './routes/sessions.js';
 import { registerFolders } from './routes/folders.js';
 import { registerFiles } from './routes/files.js';
+import { registerGit } from './routes/git.js';
 import { registerModels } from './routes/models.js';
 import { registerProviders } from './routes/providers.js';
 import { registerMcp } from './routes/mcp.js';
 import { registerSkills } from './routes/skills.js';
 import { registerChannels } from './routes/channels.js';
+import { registerTts } from './routes/tts.js';
 import { registerProcs } from './routes/procs.js';
+import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
 import { registerChat } from './routes/chat.js';
+import { registerEvents } from './routes/events.js';
+import { registerState } from './routes/state.js';
 import { registerEval } from './routes/eval.js';
 
 const VERSION = readPackageVersion();
@@ -212,14 +217,19 @@ export async function createTamnoraServer({
   registerSessions(route, ctx);
   registerFolders(route, ctx);
   registerFiles(route, ctx);
+  registerGit(route, ctx);
   registerModels(route, ctx);
   registerProviders(route, ctx);
   registerMcp(route, ctx);
   registerSkills(route, ctx);
   registerChannels(route, ctx);
+  registerTts(route, ctx);
   registerProcs(route, ctx);
+  registerShell(route, ctx);
   const preview = registerPreview(route, ctx);
   registerChat(route, ctx);
+  registerEvents(route, ctx);
+  registerState(route, ctx);
   registerEval(route, ctx);
 
   function matchRoute(method, pathname) {
@@ -243,6 +253,10 @@ export async function createTamnoraServer({
 
   const serveStatic = createStaticHandler(staticDir ?? DEFAULT_PUBLIC_DIR);
 
+  // Los SSE (turno, stream de sesion, canal global) son conexiones que no
+  // terminan solas: sin registrarlas, `server.close()` espera indefinidamente y
+  // `tamnora server --stop` queda colgado.
+  const sockets = new Set();
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://${req.headers.host ?? 'localhost'}`);
 
@@ -282,6 +296,11 @@ export async function createTamnoraServer({
     }
   });
 
+  server.on('connection', (socket) => {
+    sockets.add(socket);
+    socket.on('close', () => sockets.delete(socket));
+  });
+
   const listen = (options = {}) =>
     new Promise((resolve, reject) => {
       server.once('error', reject);
@@ -311,12 +330,17 @@ export async function createTamnoraServer({
     } catch {
       // ignore MCP shutdown errors
     }
+    // Cortar las conexiones abiertas ANTES de esperar al server, y la base
+    // DESPUES: un run abortado termina en otro tick y emite `aborted`.
+    for (const socket of sockets) socket.destroy();
+    sockets.clear();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await new Promise((resolve) => setTimeout(resolve, 50));
     try {
       store.close();
     } catch {
       // already closed
     }
-    await new Promise((resolve) => server.close(() => resolve()));
   };
 
   return { server, config, store, ctx, listen, close, staticDir: staticDir ?? DEFAULT_PUBLIC_DIR };

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

@@ -0,0 +1,51 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { fraseTool, fraseInicio, fraseFin, fraseError, createFiltroTools } from '../src/lib/announcer.js';
+
+test('fraseTool arma verbos con el resumen de la tool', () => {
+  assert.equal(fraseTool('read', 'src/app.js'), 'Leyendo src/app.js');
+  assert.equal(fraseTool('write', 'a/b.txt'), 'Escribiendo a/b.txt');
+  assert.equal(fraseTool('bash', 'npm test'), 'Ejecutando npm test');
+  assert.equal(fraseTool('grep', '"foo" *.js'), 'Buscando "foo" *.js');
+});
+
+test('fraseTool sin resumen, tools mudas y MCP', () => {
+  assert.equal(fraseTool('read', ''), 'Leyendo');
+  assert.equal(fraseTool('desconocida', 'x'), '');
+  assert.equal(fraseTool('git_status', ''), 'Mirando el estado de git');
+  assert.equal(fraseTool('git_commit', 'feat: algo'), 'Commiteando: feat: algo');
+  assert.equal(fraseTool('mcp__db__query', 'x'), 'Usando una herramienta de db');
+});
+
+test('fraseTool recorta frases largas sin cortar palabras', () => {
+  const frase = fraseTool('bash', 'x'.repeat(400));
+  assert.ok(frase.length <= 200, frase.length);
+  assert.ok(frase.endsWith('…'));
+});
+
+test('fraseFin resume el cierre del turno', () => {
+  assert.equal(fraseFin({ stopReason: 'aborted' }), 'Cancelado.');
+  assert.match(fraseFin({ stopReason: 'end_turn', rounds: 3, toolCalls: 5, durationMs: 12000 }), /^Listo\. 3 rondas, 5 herramientas, 12 segundos\.$/);
+  assert.equal(fraseFin({ stopReason: 'end_turn', rounds: 1, toolCalls: 0, durationMs: 500 }), 'Listo. Respondí sin usar herramientas.');
+  assert.match(
+    fraseFin({ stopReason: 'max_rounds', rounds: 8, toolCalls: 12, durationMs: 60000 }),
+    /corte de seguridad tras 8 rondas, 60 segundos/
+  );
+  assert.match(fraseInicio(), /Empecé/);
+  assert.match(fraseError(), /error/);
+});
+
+test('createFiltroTools deduplica y aplica la ventana entre frases', () => {
+  const filtro = createFiltroTools({ minGapMs: 60000 });
+  assert.equal(filtro('read', 'a.js'), 'Leyendo a.js');
+  assert.equal(filtro('read', 'b.js'), '');
+  assert.equal(filtro('write', 'b.js'), '');
+  const ahora = Date.now();
+  const original = Date.now;
+  Date.now = () => ahora + 61000;
+  try {
+    assert.equal(filtro('write', 'b.js'), 'Escribiendo b.js');
+  } finally {
+    Date.now = original;
+  }
+});

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

@@ -0,0 +1,146 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { diffState, pollDelayMs, localState, summarizeArgs, humanSize } from '../public/reconcile.js';
+
+const pane = (over = {}) => ({ working: false, attached: false, ...over });
+const ask = (over = {}) => ({ askId: 'a1', sessionId: 's1', name: 'bash', args: {}, requestedAt: 1, ...over });
+
+test('engancha una sesion abierta que esta trabajando sin stream propio', () => {
+  const diff = diffState({ panes: [{ id: 's1', working: false, attached: false }], asks: [] }, {
+    sessions: [{ id: 's1', running: true, awaiting: 0 }],
+    permissions: [],
+  });
+  assert.deepEqual(diff.toAttach, ['s1']);
+});
+
+test('engancha aunque no haya run si hay un permiso pendiente', () => {
+  // El permiso no se reconstruye desde los mensajes: vive en /api/state.
+  const diff = diffState({ panes: [{ id: 's1', working: false, attached: false }], asks: [] }, {
+    sessions: [{ id: 's1', running: false, awaiting: 1 }],
+    permissions: [ask()],
+  });
+  assert.deepEqual(diff.toAttach, ['s1']);
+});
+
+test('desengancha una sesion que figuraba activa y ya no', () => {
+  const diff = diffState({ panes: [{ id: 's1', working: true, attached: true }], asks: [] }, {
+    sessions: [{ id: 's1', running: false, awaiting: 0 }],
+    permissions: [],
+  });
+  assert.deepEqual(diff.toDetach, ['s1']);
+});
+
+test('no toca una sesion que ya esta enganchada', () => {
+  const diff = diffState({ panes: [{ id: 's1', working: true, attached: true }], asks: [] }, {
+    sessions: [{ id: 's1', running: true, awaiting: 0 }],
+    permissions: [],
+  });
+  assert.deepEqual(diff.toAttach, []);
+  assert.deepEqual(diff.toDetach, []);
+});
+
+test('detecta permisos nuevos y resueltos', () => {
+  const diff = diffState({ panes: [], asks: ['a1', 'a2'] }, {
+    sessions: [],
+    permissions: [ask({ askId: 'a1' }), ask({ askId: 'a3' })],
+  });
+  assert.deepEqual(diff.newAsks.map((a) => a.askId), ['a3']);
+  assert.deepEqual(diff.resolvedAsks, ['a2']);
+});
+
+test('un permiso repetido no vuelve a notificarse', () => {
+  const state = { panes: [], asks: [] };
+  const remote = { sessions: [], permissions: [ask()] };
+  const first = diffState(state, remote);
+  assert.equal(first.newAsks.length, 1);
+  const second = diffState({ panes: [], asks: ['a1'] }, remote);
+  assert.equal(second.newAsks.length, 0);
+});
+
+test('noPropone ninguna accion cuando nada cambio', () => {
+  // Esto importa: un re-render por nada borra la tarjeta de permiso.
+  const local = { panes: [{ id: 's1', working: true, attached: true }], asks: ['a1'] };
+  const remote = { sessions: [{ id: 's1', running: true, awaiting: 1 }], permissions: [ask()] };
+  const diff = diffState(local, remote);
+  assert.deepEqual(diff.toAttach, []);
+  assert.deepEqual(diff.toDetach, []);
+  assert.deepEqual(diff.gone, []);
+  assert.deepEqual(diff.newAsks, []);
+  assert.deepEqual(diff.resolvedAsks, []);
+});
+
+test('avisa las sesiones que el server ya no conoce', () => {
+  const diff = diffState({ panes: [{ id: 'borrada', working: false, attached: false }], asks: [] }, {
+    sessions: [{ id: 's1', running: false, awaiting: 0 }],
+    permissions: [],
+  });
+  assert.deepEqual(diff.gone, ['borrada']);
+});
+
+test('ignora las sesiones que el usuario no tiene abiertas', () => {
+  const diff = diffState({ panes: [], asks: [] }, {
+    sessions: [{ id: 's1', running: true, awaiting: 0 }],
+    permissions: [],
+  });
+  assert.deepEqual(diff.toAttach, []);
+  assert.deepEqual(diff.remoteActive, ['s1']);
+});
+
+test('la cadencia se apura cuando algo espera tu decision', () => {
+  const idle = { sessions: [{ running: false, awaiting: 0 }], permissions: [] };
+  const running = { sessions: [{ running: true, awaiting: 0 }], permissions: [] };
+  const waiting = { sessions: [{ running: false, awaiting: 1 }], permissions: [ask()] };
+  assert.equal(pollDelayMs(idle), 25000);
+  assert.equal(pollDelayMs(running), 10000);
+  assert.equal(pollDelayMs(waiting), 5000);
+});
+
+test('localState aplana los Map del cliente', () => {
+  const flat = localState({ panes: new Map([['s1', pane({ working: true, attached: true })]]), asks: new Set(['a1']) });
+  assert.deepEqual(flat, { panes: [{ id: 's1', working: true, attached: true }], asks: ['a1'] });
+});
+
+test('tolera un remoto vacio o corrupto sin romper', () => {
+  const diff = diffState({ panes: [{ id: 's1', working: false, attached: false }], asks: [] }, {});
+  assert.deepEqual(diff.toAttach, []);
+  assert.deepEqual(diff.pending, []);
+});
+
+test('el resumen de un permiso muestra el comando, no el JSON', () => {
+  const command = 'powershell -NoProfile -Command "Get-ChildItem -Recurse"';
+  assert.equal(summarizeArgs('bash', { command }), command);
+});
+
+test('el resumen de write muestra ruta y tamano, no el archivo entero', () => {
+  // Esto era medio archivo en pantalla con los \n escapados a la vista.
+  const summary = summarizeArgs('write', { path: 'AGENTS.md', content: 'x'.repeat(1840) });
+  assert.equal(summary, 'AGENTS.md · 1.8 kB');
+  assert.ok(!summary.includes('\\n'));
+  assert.ok(summary.length < 60);
+});
+
+test('el resumen de read y fetch_url muestra la ruta y la url', () => {
+  assert.equal(summarizeArgs('read', { path: 'src/app.js' }), 'src/app.js');
+  assert.equal(summarizeArgs('fetch_url', { url: 'https://x.dev/a' }), 'https://x.dev/a');
+});
+
+test('el resumen de task usa la descripcion', () => {
+  assert.equal(summarizeArgs('task', { description: 'auditar el repo', prompt: 'busca TODOs' }), 'auditar el repo');
+});
+
+test('una tool desconocida cae a JSON en una sola linea', () => {
+  const summary = summarizeArgs('git_diff', { path: 'a.js', staged: false, note: 'uno\ndos' });
+  assert.ok(!summary.includes('\\n'), 'no debe mostrar saltos escapados');
+  assert.match(summary, /git_diff|a\.js/);
+});
+
+test('sin argumentos el resumen queda vacio', () => {
+  assert.equal(summarizeArgs('git_status', {}), '');
+  assert.equal(summarizeArgs('git_status', null), '');
+});
+
+test('humanSize usa la unidad que corresponde', () => {
+  assert.equal(humanSize('hola'), '4 B');
+  assert.equal(humanSize('x'.repeat(2048)), '2.0 kB');
+  assert.equal(humanSize('x'.repeat(3 * 1024 * 1024)), '3.0 MB');
+});

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

@@ -0,0 +1,219 @@
+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();
+  }
+});