@danieltmn/tamnora 0.8.0 → 0.9.1

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();
+  }
+});

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

@@ -0,0 +1,245 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { streamSse, followRun, backoffDelay, linkSignals, delay } from '../public/runStream.js';
+
+/** Arma una `fetch` falsa que devuelve los chunks indicados y despues se cuelga. */
+function stubFetch(chunks, { status = 200, hang = true } = {}) {
+  const queue = [...chunks];
+  const enqueue = (controller) => {
+    // Sin chunks pendientes el stream queda abierto y mudo: eso es justo lo que
+    // el watchdog tiene que detectar, asi que no cerramos nada. Con `hang:false`
+    // se cierra. `queueMicrotask` y no `setTimeout`: no deja timers colgados
+    // entre tests.
+    if (!queue.length) {
+      if (!hang) controller.close();
+      return;
+    }
+    controller.enqueue(new TextEncoder().encode(queue.shift()));
+    queueMicrotask(() => enqueue(controller));
+  };
+  return async (_url, options = {}) => {
+    if (status !== 200) {
+      return {
+        ok: false,
+        status,
+        statusText: 'Error',
+        json: async () => ({ error: 'no autorizado' }),
+      };
+    }
+    // Un fetch real aborta el body cuando se dispara la senal: hay que
+    // reproducirlo o el watchdog no puede cortar el `reader.read()`.
+    const body = new ReadableStream({
+      start(controller) {
+        const stop = () => controller.error(new DOMException('Aborted', 'AbortError'));
+        if (options.signal?.aborted) return stop();
+        options.signal?.addEventListener('abort', stop, { once: true });
+        enqueue(controller);
+      },
+    });
+    return { ok: true, status: 200, body };
+  };
+}
+
+test('entrega los frames parseados y recuerda el ultimo id', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch(['event: start\ndata: {"a":1}\nid: 7\n\n: ping\n\nevent: done\ndata: {}\nid: 9\n\n'], { hang: false }) }, (event, data, id) => {
+    frames.push([event, data, id]);
+  });
+  assert.deepEqual(frames, [
+    ['start', { a: 1 }, '7'],
+    ['done', {}, '9'],
+  ]);
+});
+
+test('usa el fetch global cuando no se pasa fetchImpl', async () => {
+  // La consola nunca pasa fetchImpl. Si el default se rompe, todos los streams
+  // fallan con TypeError y followRun los reintenta para siempre.
+  const original = globalThis.fetch;
+  let called = false;
+  globalThis.fetch = async (url) => {
+    called = true;
+    assert.equal(url, '/api/events');
+    return { ok: true, status: 200, body: new ReadableStream({ start: (c) => c.close() }) };
+  };
+  try {
+    const frames = [];
+    await streamSse('/api/events', {}, (event, data) => frames.push([event, data]));
+    assert.equal(called, true);
+    assert.deepEqual(frames, []);
+  } finally {
+    globalThis.fetch = original;
+  }
+});
+
+test('tolera frames partidas entre varios chunks', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch(['event: te', 'xt\ndata: {"b', '":2}\nid: 3\n\n'], { hang: false }) }, (event, data, id) => {
+    frames.push([event, data, id]);
+  });
+  assert.deepEqual(frames, [['text', { b: 2 }, '3']]);
+});
+
+test('los comentarios de heartbeat no producen eventos', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch([': ping\n\n: ping\n\nevent: done\ndata: {}\n\n'], { hang: false }) }, (event) => {
+    frames.push(event);
+  });
+  assert.deepEqual(frames, ['done']);
+});
+
+test('corta cuando el stream queda mudo y reporta el cursor', async () => {
+  await assert.rejects(
+    streamSse('/x', { silenceMs: 40, fetchImpl: stubFetch(['event: start\ndata: {}\nid: 12\n\n']) }, () => {}),
+    (error) => {
+      assert.equal(error.name, 'SilentStream');
+      assert.equal(error.resumable, true);
+      assert.equal(error.from, '12');
+      return true;
+    }
+  );
+});
+
+test('propaga el status HTTP para distinguir un 409', async () => {
+  await assert.rejects(
+    streamSse('/x', { fetchImpl: stubFetch([], { status: 409 }) }, () => {}),
+    (error) => {
+      assert.equal(error.status, 409);
+      assert.equal(error.message, 'no autorizado');
+      return true;
+    }
+  );
+});
+
+test('el AbortError del caller no se reporta como stream mudo', async () => {
+  const controller = new AbortController();
+  controller.abort();
+  await assert.rejects(
+    streamSse('/x', { signal: controller.signal, fetchImpl: stubFetch([]) }, () => {}),
+    (error) => error.name === 'AbortError'
+  );
+});
+
+test('followRun reintenta con backoff creciente hasta terminar', async () => {
+  const slept = [];
+  let calls = 0;
+  const result = await followRun({
+    open: async (cursor) => {
+      calls += 1;
+      if (calls < 4) {
+        const error = new Error('se corto');
+        error.name = 'SilentStream';
+        error.from = String(cursor + 10);
+        throw error;
+      }
+      return { finished: true, cursor: 99 };
+    },
+    sleep: async (ms) => {
+      slept.push(ms);
+    },
+  });
+  assert.equal(calls, 4);
+  assert.deepEqual(slept, [1000, 2000, 4000]);
+  assert.equal(result.finished, true);
+  assert.equal(result.cursor, 99);
+});
+
+test('followRun no reintenta un AbortError', async () => {
+  let calls = 0;
+  await assert.rejects(
+    followRun({
+      open: async () => {
+        calls += 1;
+        throw new DOMException('Aborted', 'AbortError');
+      },
+      sleep: async () => {},
+    }),
+    (error) => error.name === 'AbortError'
+  );
+  assert.equal(calls, 1);
+});
+
+test('followRun respeta el limite de intentos', async () => {
+  let calls = 0;
+  await assert.rejects(
+    followRun({
+      attempts: 2,
+      open: async () => {
+        calls += 1;
+        throw new Error('siempre falla');
+      },
+      sleep: async () => {},
+    }),
+    /siempre falla/
+  );
+  assert.equal(calls, 3);
+});
+
+test('followRun avisa el cursor que va a reanudar', async () => {
+  const retries = [];
+  await followRun({
+    open: async (cursor) => {
+      if (cursor === 0) {
+        const error = new Error('murio');
+        error.name = 'SilentStream';
+        error.from = '55';
+        throw error;
+      }
+      return { finished: true };
+    },
+    onRetry: (info) => retries.push([info.cursor, info.attempt]),
+    sleep: async () => {},
+  });
+  assert.deepEqual(retries, [[55, 1]]);
+});
+
+test('un error del handler no se reintenta en bucle', async () => {
+  // Si se confundiera con una caida del transporte, el sintoma seria un
+  // "reconectando..." eterno que no dice nada del bug real.
+  let calls = 0;
+  const boom = await followRun({
+    attempts: Infinity,
+    open: async () => {
+      calls += 1;
+      const error = new Error('handler roto');
+      error.eventHandler = true;
+      throw error;
+    },
+    sleep: async () => {},
+  }).catch((error) => error);
+  assert.equal(calls, 1, 'no debe reintentar');
+  assert.ok(boom.eventHandler, 'debe marcar el error como del handler');
+});
+
+test('un error del handler se propaga marcado', async () => {
+  await assert.rejects(
+    streamSse('/x', { fetchImpl: stubFetch(['event: text\ndata: {}\n\n'], { hang: false }) }, () => {
+      throw new Error('se rompio el render');
+    }),
+    (error) => {
+      assert.equal(error.message, 'se rompio el render');
+      assert.equal(error.eventHandler, true);
+      return true;
+    }
+  );
+});
+
+test('backoffDelay acota en el ultimo paso', () => {
+  assert.equal(backoffDelay(0), 1000);
+  assert.equal(backoffDelay(3), 8000);
+  assert.equal(backoffDelay(99), 10000);
+});
+
+test('linkSignals aborta si cualquiera de las senales dispara', () => {
+  const a = new AbortController();
+  const b = new AbortController();
+  const linked = linkSignals([a.signal, b.signal]);
+  assert.equal(linked.signal.aborted, false);
+  b.abort();
+  assert.equal(linked.signal.aborted, true);
+});
+
+test('delay se corta cuando abortan', async () => {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), 5);
+  await assert.rejects(delay(5000, controller.signal), (error) => error.name === 'AbortError');
+});