@danieltmn/tamnora 0.21.2 → 0.23.0

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

@@ -0,0 +1,119 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  ADVISOR_KINDS,
+  advisorMeta,
+  basename,
+  formatDuration,
+  isFailedToolText,
+  isReadOnlyTool,
+  parseToolArgs,
+  previewText,
+  screenshotName,
+  shortText,
+  toolSummary,
+  userImages,
+  userText,
+} from '../public/chatFormat.js';
+
+test('shortText normaliza espacios y corta con punto', () => {
+  assert.equal(shortText('  hola   mundo  '), 'hola mundo');
+  assert.equal(shortText('x'.repeat(10), 5), 'xxxx…');
+  assert.equal(shortText(null), '');
+});
+
+test('isReadOnlyTool distingue las tools de lectura, tambien las MCP', () => {
+  assert.ok(isReadOnlyTool('read'));
+  assert.ok(isReadOnlyTool('grep'));
+  assert.ok(!isReadOnlyTool('write'));
+  assert.ok(!isReadOnlyTool('bash'));
+  assert.ok(isReadOnlyTool('mcp__postgres__query'));
+  assert.ok(isReadOnlyTool('mcp__fs__list_files'));
+  assert.ok(!isReadOnlyTool('mcp__fs__write_file'));
+  assert.ok(!isReadOnlyTool(undefined));
+});
+
+test('toolSummary resume cada tool en una linea corta', () => {
+  assert.equal(toolSummary('read', { path: 'src/a.js', offset: 10, limit: 5 }), 'src/a.js:10-14');
+  assert.equal(toolSummary('read', { path: 'src/a.js', offset: 10 }), 'src/a.js:10+');
+  assert.equal(toolSummary('read', {}), '.');
+  assert.equal(toolSummary('write', { path: 'a.txt', content: 'x' }), 'a.txt');
+  assert.equal(toolSummary('bash', { command: 'npm test\notra linea' }), 'npm test');
+  assert.equal(toolSummary('grep', { pattern: 'foo', path: 'src' }), '"foo" en src');
+  assert.equal(toolSummary('git_diff', { staged: true, path: 'a.js' }), 'staged a.js');
+  assert.equal(toolSummary('git_log', { limit: 5 }), '5 commits');
+  assert.equal(toolSummary('desconocida', {}), '');
+});
+
+test('parseToolArgs acepta objeto, JSON y basura', () => {
+  assert.deepEqual(parseToolArgs({ function: { arguments: '{"a":1}' } }), { a: 1 });
+  assert.deepEqual(parseToolArgs({ arguments: { a: 2 } }), { a: 2 });
+  assert.deepEqual(parseToolArgs({ arguments: 'no es json' }), {});
+  assert.deepEqual(parseToolArgs(null), {});
+});
+
+test('isFailedToolText detecta errores y permisos denegados', () => {
+  assert.ok(isFailedToolText('Error: se rompio'));
+  assert.ok(isFailedToolText('Permiso denegado por el usuario'));
+  assert.ok(!isFailedToolText('listo, sin errores'));
+  assert.ok(!isFailedToolText(undefined));
+});
+
+test('screenshotName sale del meta o del texto del resultado', () => {
+  assert.equal(screenshotName({ meta: { screenshot: { name: 'a.png' } } }, ''), 'a.png');
+  assert.equal(screenshotName({}, 'guardado en capturas/abc-123.png'), 'abc-123.png');
+  assert.equal(screenshotName({}, 'sin captura'), null);
+});
+
+test('previewText trunca por lineas y por caracteres', () => {
+  const largo = Array.from({ length: 50 }, (_, i) => `linea ${i}`).join('\n');
+  const { preview, truncated } = previewText(largo, 5, 100);
+  assert.equal(preview.split('\n').length, 5);
+  assert.ok(truncated);
+  assert.deepEqual(previewText('hola'), { preview: 'hola', truncated: false });
+  // Un objeto se serializa con formato.
+  assert.match(previewText({ a: 1 }).preview, /"a": 1/);
+});
+
+test('userText y userImages separan las partes del mensaje multimodal', () => {
+  assert.equal(userText('plano'), 'plano');
+  assert.equal(
+    userText([
+      { type: 'text', text: 'hola' },
+      { type: 'text', text: 'mundo' },
+      { type: 'image_url', image_url: { url: 'data:x' } },
+    ]),
+    'hola\nmundo',
+  );
+  assert.equal(userText(null), '');
+  assert.deepEqual(
+    userImages([
+      { type: 'image_url', image_url: { url: 'data:x' } },
+      { type: 'text', text: 'y' },
+      { type: 'image_url', image_url: {} },
+    ]),
+    ['data:x'],
+  );
+  assert.deepEqual(userImages('plano'), []);
+});
+
+test('advisorMeta cae al default con un tipo desconocido', () => {
+  assert.equal(advisorMeta('code'), ADVISOR_KINDS.code);
+  assert.equal(advisorMeta('nope').label, 'Asesor');
+  assert.ok(ADVISOR_KINDS.summary);
+});
+
+test('basename corta el ultimo segmento y los separadores finales', () => {
+  assert.equal(basename('a/b/c'), 'c');
+  assert.equal(basename('a\\b\\c\\'), 'c');
+  // Solo separadores: no hay segmento que devolver.
+  assert.equal(basename('/'), '');
+  assert.equal(basename(null), '');
+});
+
+test('formatDuration da ms cortos y segundos con decimal', () => {
+  assert.equal(formatDuration(0), '');
+  assert.equal(formatDuration(undefined), '');
+  assert.equal(formatDuration(300), '300ms');
+  assert.equal(formatDuration(1200), '1.2s');
+});

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

@@ -0,0 +1,301 @@
+// El grafo de imports de la consola (`public/`), verificado sin navegador.
+//
+// La consola no tiene tests de DOM: si un refactor borra un export, renombra una
+// funcion o mueve una llamada a tiempo de evaluacion dentro de un ciclo, la
+// suite no lo ve y el navegador se queda con la pantalla en blanco. Esto cierra
+// ese hueco: valida que cada import resuelve a un export real y que los ciclos
+// (chrome <-> chat, app <-> explorer) siguen seguros.
+//
+// Es analisis estatico sobre el texto: no importa el modulo, asi que no hace
+// falta emular el DOM.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'public');
+
+const lee = (archivo) => readFileSync(path.join(DIR, archivo), 'utf8');
+const modulos = readdirSync(DIR).filter((f) => f.endsWith('.js'));
+
+/** Nombres exportados de un modulo: `export function X`, `export { A, B }`, `export const`. */
+function exportsDe(archivo) {
+  const src = lee(archivo);
+  const nombres = new Set();
+  for (const m of src.matchAll(/export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g)) nombres.add(m[1]);
+  for (const m of src.matchAll(/export\s+(?:const|let|var|class)\s+([A-Za-z_$][\w$]*)/g)) nombres.add(m[1]);
+  // `export { a, b } from './x.js'` tambien expone esos nombres.
+  for (const m of src.matchAll(/export\s*\{([^}]*)\}\s*from\s*'[^']+'/g)) {
+    for (const bruto of m[1].split(',')) {
+      const nombre = bruto.trim().split(/\s+as\s+/).pop().trim();
+      if (nombre) nombres.add(nombre);
+    }
+  }
+  return nombres;
+}
+
+/** Imports relativos: `{ nombres, de }` por cada `import { ... } from './x.js'`. */
+function importsDe(archivo) {
+  const src = lee(archivo);
+  const lista = [];
+  for (const m of src.matchAll(/import\s*\{([^}]*)\}\s*from\s*'(\.[^']+)'/g)) {
+    const nombres = m[1]
+      .split(',')
+      .map((n) => n.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim())
+      .filter(Boolean);
+    const de = path.basename(m[2]);
+    lista.push({ nombres, de });
+  }
+  return lista;
+}
+
+const exportsPorModulo = new Map(modulos.map((m) => [m, exportsDe(m)]));
+const importsPorModulo = new Map(modulos.map((m) => [m, importsDe(m)]));
+
+/**
+ * Statements de nivel superior de un modulo, agrupando por balance de llaves y
+ * parentesis. Asi `const x = f();` sale como un statement, y un
+ * `addEventListener(...)` con un callback multilinea tambien.
+ */
+function statementsTopLevel(src) {
+  const stmts = [];
+  let actual = '';
+  let inicio = 0;
+  let llaves = 0;
+  let corchetes = 0;
+  let parentesis = 0;
+  let enCadena = '';
+  let pos = 0;
+  for (const linea of src.split(/\r?\n/)) {
+    if (!actual) inicio = pos;
+    actual += `${actual ? '\n' : ''}${linea}`;
+    for (let i = 0; i < linea.length; i += 1) {
+      const c = linea[i];
+      const previo = linea[i - 1];
+      if (enCadena) {
+        if (c === enCadena && previo !== '\\') enCadena = '';
+        continue;
+      }
+      if (c === '"' || c === "'" || c === '`') {
+        enCadena = c;
+        continue;
+      }
+      if (c === '{') llaves += 1;
+      else if (c === '}') llaves -= 1;
+      else if (c === '[') corchetes += 1;
+      else if (c === ']') corchetes -= 1;
+      else if (c === '(') parentesis += 1;
+      else if (c === ')') parentesis -= 1;
+    }
+    pos += linea.length + 1;
+    if (llaves <= 0 && corchetes <= 0 && parentesis <= 0) {
+      if (actual.trim()) stmts.push({ texto: actual, inicio });
+      actual = '';
+      llaves = 0;
+      corchetes = 0;
+      parentesis = 0;
+    }
+  }
+  if (actual.trim()) stmts.push({ texto: actual, inicio });
+  return stmts;
+}
+
+/**
+ * Quita del statement lo que se ejecuta **despues** del arranque: cuerpos de
+ * callbacks (`=> {...}`, `=> expr`, `function () {...}`) y literales de datos
+ * (`= [...]`, `= {...}`), que a lo sumo guardan referencias. Lo que queda es lo
+ * que se evalua al cargar el modulo.
+ *
+ * Recorre con estado de cadenas: un `=>` dentro de un template no es un arrow.
+ */
+function sinDiferidos(stmt) {
+  const s = stmt.replace(/\r?\n/g, ' ');
+  let out = '';
+  let i = 0;
+  let cadena = '';
+  const cortarBloque = (desde) => {
+    // Corta hasta el cierre balanceado de `{`/`[` abierto en `desde - 1`.
+    let prof = 1;
+    let j = desde;
+    let cad = '';
+    for (; j < s.length; j += 1) {
+      const c = s[j];
+      const previo = s[j - 1];
+      if (cad) {
+        if (c === cad && previo !== '\\') cad = '';
+        continue;
+      }
+      if (c === '"' || c === "'" || c === '`') {
+        cad = c;
+        continue;
+      }
+      if (c === '{' || c === '[') prof += 1;
+      else if (c === '}' || c === ']') {
+        prof -= 1;
+        if (prof === 0) return j + 1;
+      }
+    }
+    return j;
+  };
+
+  while (i < s.length) {
+    const c = s[i];
+    const previo = s[i - 1];
+    if (cadena) {
+      out += c;
+      if (c === cadena && previo !== '\\') cadena = '';
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      cadena = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    const resto = s.slice(i);
+    if (c === '=' && s[i + 1] === '>') {
+      const despues = s.slice(i + 2).match(/^\s*([[{])/);
+      if (despues) {
+        const inicio = i + 2 + despues[0].length;
+        i = cortarBloque(inicio);
+      } else {
+        i = s.length; // arrow de expression: su cuerpo corre al invocarlo
+      }
+      continue;
+    }
+    const fn = /^\bfunction\b\s*[\w$]*\s*\([^)]*\)\s*\{/.exec(resto);
+    if (fn) {
+      out += fn[0].slice(0, -1);
+      i = cortarBloque(i + fn[0].length);
+      continue;
+    }
+    if (c === '=' && /^\s*[[{]/.test(s.slice(i + 1))) {
+      const inicio = i + 1 + s.slice(i + 1).match(/^\s*[[{]/)[0].length;
+      out += '=';
+      i = cortarBloque(inicio);
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  return out;
+}
+
+/** Profundidad de llaves antes del caracter `hasta` (para saber si es nivel 0). */
+function profundidadEn(src, hasta) {
+  let prof = 0;
+  let cadena = '';
+  for (let i = 0; i < hasta; i += 1) {
+    const c = src[i];
+    const previo = src[i - 1];
+    if (cadena) {
+      if (c === cadena && previo !== '\\') cadena = '';
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      cadena = c;
+      continue;
+    }
+    if (c === '{') prof += 1;
+    else if (c === '}') prof -= 1;
+  }
+  return prof;
+}
+
+test('cada import de la consola resuelve a un export real', () => {
+  const rotos = [];
+  for (const [modulo, imports] of importsPorModulo) {
+    for (const { nombres, de } of imports) {
+      if (!exportsPorModulo.has(de)) {
+        rotos.push(`${modulo}: importa de "${de}", que no existe`);
+        continue;
+      }
+      const expuestos = exportsPorModulo.get(de);
+      for (const nombre of nombres) {
+        if (!expuestos.has(nombre)) rotos.push(`${modulo}: "${nombre}" no existe en ${de}`);
+      }
+    }
+  }
+  assert.deepEqual(rotos, [], `imports rotos:\n  ${rotos.join('\n  ')}`);
+});
+
+test('los ciclos de la consola son seguros (nada se usa en tiempo de evaluacion)', () => {
+  // Construye el grafo dirigido y busca ciclos.
+  const grafo = new Map(modulos.map((m) => [m, [...new Set(importsPorModulo.get(m).map((i) => i.de))].filter((d) => exportsPorModulo.has(d))]));
+  const ciclos = [];
+  const camino = [];
+  const enCamino = new Set();
+  const visitado = new Set();
+
+  const dfs = (nodo) => {
+    if (enCamino.has(nodo)) {
+      const desde = camino.indexOf(nodo);
+      ciclos.push([...camino.slice(desde), nodo].join(' -> '));
+      return;
+    }
+    if (visitado.has(nodo)) return;
+    visitado.add(nodo);
+    enCamino.add(nodo);
+    camino.push(nodo);
+    for (const vecino of grafo.get(nodo) ?? []) dfs(vecino);
+    camino.pop();
+    enCamino.delete(nodo);
+  };
+  for (const nodo of grafo.keys()) dfs(nodo);
+
+  // Un ciclo es seguro mientras nadie USE un importado durante la evaluacion del
+  // modulo. Las funciones y clases estan izadas, asi que referenciarlas en un
+  // callback (`addEventListener('click', cerrar)`) es legal: corre despues. Lo
+  // que rompe el ciclo es **invocarlas** en nivel superior.
+  const enCiclo = new Set(ciclos.flatMap((c) => c.split(' -> ')));
+  // `app.js` es el entry point: lo carga el HTML, asi que su codigo de nivel
+  // superior corre cuando todo el grafo ya esta evaluado y no hay nada en la
+  // zona muerta. Ciclo con el, pero inofensivo.
+  const peligrosos = [];
+  for (const miembro of enCiclo) {
+    if (!miembro.endsWith('.js') || miembro === 'app.js') continue;
+    const propios = new Set(importsPorModulo.get(miembro).filter((i) => enCiclo.has(i.de)).flatMap((i) => i.nombres));
+    if (!propios.size) continue;
+    const src = lee(miembro);
+    for (const { texto: stmt, inicio } of statementsTopLevel(src)) {
+      // Solo nivel superior: dentro de un `switch` (los `case` de un comando) o
+      // de una funcion el codigo corre despues, no al cargar.
+      if (profundidadEn(src, inicio) !== 0) continue;
+      // Fuera de callbacks y literales: lo que se ejecuta al cargar el modulo.
+      const fuera = sinDiferidos(stmt);
+      for (const nombre of propios) {
+        if (new RegExp(`(^|[^\\w$.])${nombre}\\s*\\(`).test(fuera)) {
+          peligrosos.push(`${miembro}: ${stmt.trim().replace(/\s+/g, ' ').slice(0, 70)}`);
+        }
+      }
+    }
+  }
+  assert.deepEqual(peligrosos, [], `un ciclo invoca un importado en tiempo de evaluacion:\n  ${peligrosos.join('\n  ')}`);
+  // Estos ciclos existen a proposito; si desaparecen, cambio el grafo y
+  // conviene revisarlo a mano.
+  assert.ok(ciclos.length > 0, 'no se encontraron ciclos: cambio el grafo, revisar a mano');
+});
+
+test('los modulos de la consola no exportan nombres repetidos entre si', () => {
+  // Un `export function x` duplicado en dos modulos suele ser codigo movido dos
+  // veces al partir un archivo grande.
+  const visto = new Map();
+  const duplicados = [];
+  for (const [modulo, nombres] of exportsPorModulo) {
+    for (const nombre of nombres) {
+      if (visto.has(nombre)) duplicados.push(`${nombre}: ${visto.get(nombre)} y ${modulo}`);
+      else visto.set(nombre, modulo);
+    }
+  }
+  // `index`-style re-exports (chat.js re-exporta chatFormat.js) son esperados.
+  const reexports = new Set();
+  for (const [modulo] of importsPorModulo) {
+    const src = lee(modulo);
+    for (const m of src.matchAll(/export\s*\{([^}]*)\}\s*from/g)) {
+      for (const bruto of m[1].split(',')) reexports.add(bruto.trim().split(/\s+as\s+/).pop().trim());
+    }
+  }
+  assert.deepEqual(duplicados.filter((d) => !reexports.has(d.split(':')[0])), []);
+});

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

@@ -0,0 +1,34 @@
+// Smoke test de la consola con un navegador de verdad.
+//
+// La consola es la parte del harness que ningun test cubria: si un cambio rompe
+// un import, deja un `undefined` al cargar o dispara un error en el arranque,
+// la pantalla queda en blanco y la suite seguia en verde. Esto la abre en el
+// Chrome/Edge del sistema (el mismo navegador headless de las tools `screenshot`
+// y `console_errors`) y exige que **no haya errores de consola**.
+//
+// Se saltea si no hay navegador: es una verificacion de UI, no del engine.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { findBrowserPath, readConsole } from '../../core/src/browser/index.js';
+import { startServer } from './helpers.js';
+
+const HAY_NAVEGADOR = Boolean(findBrowserPath());
+
+test('la consola carga sin errores de consola', { skip: HAY_NAVEGADOR ? false : 'sin navegador headless' }, async () => {
+  const { instance, base } = await startServer();
+  try {
+    const { errors } = await readConsole(base, { waitMs: 2500, timeoutMs: 30000, allowPrivate: true });
+    // Solo importan los errores de la consola. El favicon y el ruido de red (la
+    // consola pide fuentes a Google) no son fallos del codigo: sin conexion el
+    // test fallaria por algo que no controlamos.
+    const ruido = /favicon|ERR_NAME_NOT_RESOLVED|ERR_INTERNET_DISCONNECTED|ERR_CONNECTION|ERR_NETWORK|Failed to load resource/i;
+    const reales = errors.filter((e) => !ruido.test(String(e?.text ?? e?.message ?? e)));
+    assert.deepEqual(
+      reales.map((e) => e?.text ?? e?.message ?? String(e)),
+      [],
+      'la consola tiro errores al cargar',
+    );
+  } finally {
+    await instance.close();
+  }
+});

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

@@ -0,0 +1,121 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+
+const fakeProvider = {
+  id: 'fake',
+  async streamChat(_config, { onEvent }) {
+    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
+    return { content: 'hola', reasoning: '', toolCalls: [] };
+  },
+};
+
+async function startServer(overrides = {}) {
+  const cwd = overrides.cwd ?? (await mkdtemp(path.join(tmpdir(), 'tamnora-srv-')));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    ...overrides,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+const HAS_GIT = (() => {
+  try {
+    execFileSync('git', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+})();
+
+function gitInit(root) {
+  execFileSync('git', ['init', '-q'], { cwd: root });
+  execFileSync('git', ['config', 'user.email', 'test@tamnora.dev'], { cwd: root });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root });
+}
+
+async function readSse(url, options, until, timeoutMs = 5000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const frames = [];
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    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 event = null;
+        let data = '';
+        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();
+        }
+        if (!event) continue;
+        const parsed = data ? JSON.parse(data) : {};
+        frames.push({ event, data: parsed });
+        if (until(parsed, event)) return frames;
+      }
+    }
+  } catch (error) {
+    if (error?.name !== 'AbortError') throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  return frames;
+}
+
+/**
+ * Espera una condicion (no un tiempo fijo): los procesos y los servicios tardan
+ * lo que tardan, y una espera fija solo hace flaky al test cuando la maquina
+ * esta cargada.
+ */
+async function waitFor(cond, timeoutMs = 5000, stepMs = 50) {
+  const start = Date.now();
+  for (;;) {
+    if (await cond()) return true;
+    if (Date.now() - start >= timeoutMs) return false;
+    await new Promise((resolve) => setTimeout(resolve, stepMs));
+  }
+}
+
+async function waitIdle(base, id, attempts = 60) {
+  for (let i = 0; i < attempts; i += 1) {
+    const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    if (!detail.running) return true;
+    await fetch(`${base}/api/sessions/${id}/stop`, { method: 'POST' }).catch(() => {});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return false;
+}
+
+async function readEvents(res, onFrame) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let done = false;
+  while (!done) {
+    const { value } = await reader.read();
+    if (!value) break;
+    buffer += decoder.decode(value, { stream: true });
+    if (onFrame) await onFrame(buffer);
+    if (buffer.includes('event: done')) done = true;
+  }
+  return buffer;
+}
+
+export { fakeProvider, startServer, HAS_GIT, gitInit, readSse, waitFor, waitIdle, readEvents };