@danieltmn/tamnora 0.24.2 → 0.25.0

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

@@ -0,0 +1,228 @@
+// Recorre la consola en un navegador de verdad: abre cada vista y cada panel de
+// ajustes, y exige que (a) el click muestre lo que dice y (b) no haya errores de
+// consola. Es la red de seguridad para tocar la UI sin verla: un panel que
+// queda en blanco o un handler roto aparece aca y no en el uso diario.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { findBrowserPath, captureScreenshot } from '../../core/src/browser/index.js';
+import { startServer } from './helpers.js';
+
+const HAY_NAVEGADOR = Boolean(findBrowserPath());
+const RUIDO = /favicon|ERR_NAME_NOT_RESOLVED|ERR_INTERNET_DISCONNECTED|ERR_CONNECTION|ERR_NETWORK|Failed to load resource/i;
+
+const RECORRIDO = `(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const visible = (node) => {
+    if (!node) return false;
+    const box = node.getBoundingClientRect();
+    return box.width > 0 && box.height > 0 && getComputedStyle(node).visibility !== 'hidden';
+  };
+  const out = { views: [], panels: [], overflow: [] };
+
+  for (const button of [...document.querySelectorAll('#more-menu button[data-tab]')]) {
+    const name = button.dataset.tab;
+    button.click();
+    await wait(250);
+    const view = document.getElementById('view-' + name);
+    out.views.push({ name, active: Boolean(view && view.classList.contains('active')), visible: visible(view) });
+    const wide = document.documentElement.scrollWidth - document.documentElement.clientWidth;
+    if (wide > 1) out.overflow.push({ where: 'view:' + name, px: wide });
+  }
+
+  document.querySelector('#more-menu button[data-tab="ajustes"]')?.click();
+  await wait(250);
+  const triggers = [...document.querySelectorAll('.ajustes-tab')];
+  for (const trigger of triggers) {
+    const name = trigger.dataset.panel;
+    trigger.click();
+    await wait(200);
+    const panel = document.querySelector('.ajustes-panel[data-panel="' + name + '"]');
+    out.panels.push({ name, active: Boolean(panel && panel.classList.contains('active')), visible: visible(panel) });
+    const wide = document.documentElement.scrollWidth - document.documentElement.clientWidth;
+    if (wide > 1) out.overflow.push({ where: 'panel:' + name, px: wide });
+  }
+  return out;
+})()`;
+
+for (const [label, width, height] of [['escritorio', 1280, 800], ['tablet', 820, 1180], ['movil', 390, 844], ['movil angosto', 360, 740]]) {
+  test(
+    `consola (${label}): cada vista y cada panel de ajustes se muestra sin errores`,
+    { skip: HAY_NAVEGADOR ? false : 'sin navegador headless', timeout: 90000 },
+    async () => {
+      const { instance, base } = await startServer();
+      try {
+        const shot = await captureScreenshot(base, {
+          allowPrivate: true,
+          width,
+          height,
+          waitMs: 300,
+          timeoutMs: 30000,
+          preScript: RECORRIDO,
+        });
+        const result = shot.preScriptResult;
+        assert.ok(result, 'el recorrido no devolvio resultado');
+
+        assert.ok(result.views.length >= 5, `vistas recorridas: ${JSON.stringify(result.views)}`);
+        for (const view of result.views) {
+          assert.ok(view.active && view.visible, `la vista "${view.name}" no se mostro (${label})`);
+        }
+        assert.ok(result.panels.length >= 5, `paneles recorridos: ${JSON.stringify(result.panels)}`);
+        for (const panel of result.panels) {
+          assert.ok(panel.active && panel.visible, `el panel "${panel.name}" no se mostro (${label})`);
+        }
+        assert.deepEqual(result.overflow, [], `scroll horizontal de pagina (${label})`);
+
+        const reales = shot.consoleErrors.filter((e) => !RUIDO.test(e.text));
+        assert.deepEqual(reales.map((e) => e.text), [], `errores de consola (${label})`);
+      } finally {
+        await instance.close();
+      }
+    },
+  );
+}
+
+
+const NAVEGACION = `(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const shown = (node) => {
+    if (!node || node.hidden) return false;
+    const box = node.getBoundingClientRect();
+    return box.width > 0 && box.height > 0;
+  };
+  const type = (input, value) => {
+    input.value = value;
+    input.dispatchEvent(new Event('input', { bubbles: true }));
+  };
+  const key = (node, k) => node.dispatchEvent(new KeyboardEvent('keydown', { key: k, bubbles: true, cancelable: true }));
+  const visibles = () => [...document.querySelectorAll('.ajustes-tab')].filter((t) => !t.hidden).map((t) => t.dataset.panel);
+  const grupos = () => [...document.querySelectorAll('.ajustes-group')].filter((g) => !g.hidden).map((g) => g.dataset.group);
+  const out = { movil: window.innerWidth <= 820 };
+
+  document.querySelector('#more-menu button[data-tab="ajustes"]').click();
+  await wait(300);
+  const wrap = document.querySelector('.ajustes-wrap');
+  const search = document.getElementById('ajustes-search');
+  out.nivelInicial = wrap.dataset.level;
+  out.todas = visibles().length;
+
+  type(search, 'voz');
+  out.filtradoVoz = visibles();
+  out.gruposVoz = grupos();
+  type(search, 'tema');
+  out.filtradoTema = visibles();
+  type(search, 'zzzzzz');
+  out.sinResultados = { tabs: visibles().length, mensaje: shown(document.getElementById('ajustes-empty')), grupos: grupos().length };
+  type(search, 'limites');
+  key(search, 'Enter');
+  await wait(150);
+  out.enter = { activo: document.querySelector('.ajustes-tab.active')?.dataset.panel, selected: document.querySelector('.ajustes-tab[aria-selected="true"]')?.dataset.panel, nivel: wrap.dataset.level };
+
+  if (out.movil) {
+    out.movilDetalle = { lista: shown(document.querySelector('.ajustes-side')), volver: shown(document.getElementById('ajustes-back')) };
+    document.getElementById('ajustes-back').click();
+    await wait(100);
+    out.movilLista = { nivel: wrap.dataset.level, lista: shown(document.querySelector('.ajustes-side')), detalle: shown(document.querySelector('.ajustes-main')) };
+  }
+
+  type(search, '');
+  key(search, 'Escape');
+  type(search, 'zzz');
+  key(search, 'Escape');
+  out.escape = { valor: search.value, tabs: visibles().length };
+
+  document.getElementById('search-toggle').click();
+  await wait(200);
+  const palette = document.getElementById('palette-input');
+  type(palette, 'tema');
+  await wait(100);
+  const etiquetas = [...document.querySelectorAll('#palette-list .palette-item-label')].map((n) => n.textContent);
+  out.palette = etiquetas;
+  const item = [...document.querySelectorAll('#palette-list .palette-item')].find((n) => n.textContent.includes('Ajustes · Apariencia'));
+  item?.click();
+  await wait(400);
+  out.paletteSalto = {
+    vista: document.getElementById('view-ajustes').classList.contains('active'),
+    panel: document.querySelector('.ajustes-panel.active')?.dataset.panel,
+    nivel: wrap.dataset.level,
+  };
+  return out;
+})()`;
+
+for (const [label, width, height] of [['escritorio', 1280, 800], ['movil', 390, 844]]) {
+  test(
+    `ajustes (${label}): buscador, Enter, Escape, volver y palette`,
+    { skip: HAY_NAVEGADOR ? false : 'sin navegador headless', timeout: 90000 },
+    async () => {
+      const { instance, base } = await startServer();
+      try {
+        const shot = await captureScreenshot(base, { allowPrivate: true, width, height, waitMs: 300, timeoutMs: 30000, preScript: NAVEGACION });
+        const r = shot.preScriptResult;
+        assert.ok(r, 'el script no devolvio resultado');
+
+        assert.equal(r.todas, 13, 'sin busqueda se ven las 13 secciones');
+        assert.deepEqual(r.filtradoVoz, ['voz']);
+        assert.deepEqual(r.gruposVoz, ['canales'], 'los grupos sin resultados se ocultan');
+        assert.ok(r.filtradoTema.includes('apariencia'), 'busca por palabra clave');
+        assert.deepEqual(r.sinResultados, { tabs: 0, mensaje: true, grupos: 0 });
+        assert.deepEqual(r.enter, { activo: 'limites', selected: 'limites', nivel: 'panel' });
+        assert.deepEqual(r.escape, { valor: '', tabs: 13 }, 'Escape limpia la busqueda y vuelve a mostrar todo');
+        assert.ok(r.palette.some((label) => label === 'Ajustes · Apariencia'), `la palette no encontro Apariencia: ${r.palette}`);
+        assert.deepEqual(r.paletteSalto, { vista: true, panel: 'apariencia', nivel: 'panel' });
+
+        if (r.movil) {
+          assert.equal(r.nivelInicial, 'list', 'en movil se abre en la lista');
+          assert.deepEqual(r.movilDetalle, { lista: false, volver: true }, 'en el detalle se oculta la lista y aparece volver');
+          assert.deepEqual(r.movilLista, { nivel: 'list', lista: true, detalle: false }, 'volver regresa a la lista');
+        }
+
+        const reales = shot.consoleErrors.filter((e) => !RUIDO.test(e.text));
+        assert.deepEqual(reales.map((e) => e.text), [], `errores de consola (${label})`);
+      } finally {
+        await instance.close();
+      }
+    },
+  );
+}
+
+
+const TAMANOS = `(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  await wait(1200);
+  const chicos = [];
+  const scan = (donde) => {
+    for (const node of document.querySelectorAll('button, a[href], input:not([type=hidden]), select, textarea, [role=tab], [role=menuitem], summary')) {
+      const box = node.getBoundingClientRect();
+      if (box.width < 1 || box.height < 1 || getComputedStyle(node).visibility === 'hidden') continue;
+      if (node.type === 'checkbox' || node.type === 'radio' || node.type === 'range') continue;
+      if (box.width < 28 || box.height < 28) chicos.push(donde + ' ' + (node.id ? '#' + node.id : node.tagName.toLowerCase() + '.' + String(node.className).split(' ')[0]) + ' ' + Math.round(box.width) + 'x' + Math.round(box.height));
+    }
+  };
+  scan('chat');
+  for (const tab of ['providers', 'ajustes', 'eval', 'runs']) {
+    document.querySelector('#more-menu button[data-tab="' + tab + '"]').click();
+    await wait(250);
+    scan(tab);
+  }
+  for (const trigger of document.querySelectorAll('.ajustes-tab')) {
+    trigger.click();
+    await wait(120);
+    scan('ajustes:' + trigger.dataset.panel);
+  }
+  return chicos;
+})()`;
+
+for (const [label, width, height] of [['movil', 390, 844], ['movil angosto', 360, 740]]) {
+  test(
+    `controles tactiles (${label}): ninguno mide menos de 28 px`,
+    { skip: HAY_NAVEGADOR ? false : 'sin navegador headless', timeout: 90000 },
+    async () => {
+      const { instance, base } = await startServer();
+      try {
+        const shot = await captureScreenshot(base, { allowPrivate: true, width, height, waitMs: 200, timeoutMs: 30000, preScript: TAMANOS });
+        assert.deepEqual(shot.preScriptResult, [], `controles demasiado chicos (${label})`);
+      } finally {
+        await instance.close();
+      }
+    },
+  );
+}

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

@@ -0,0 +1,73 @@
+// La tabla de endpoints de `AGENTS.md` contra las rutas que registra el server.
+//
+// La doc vive en un archivo solo (AGENTS.md) y se lee como un texto mas: si se
+// agrega una ruta y no se documenta (o la doc menciona una ruta que ya no
+// existe), esto lo detecta sin tener que acordarse de mirar. Compara rutas, no
+// metodos: la tabla usa abreviaturas (`GET/PUT /api/settings`) y no hace falta
+// que enumere cada combinacion.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const TEST_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SRC_DIR = path.join(TEST_DIR, '..', 'src');
+
+function findAgentsMd() {
+  let dir = TEST_DIR;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path.join(dir, 'AGENTS.md');
+    if (existsSync(candidate)) return candidate;
+    dir = path.dirname(dir);
+  }
+  throw new Error('no encontre AGENTS.md subiendo desde test/');
+}
+
+const AGENTS_MD = findAgentsMd();
+
+/** Rutas `/api/...` que registra el server (`route('METHOD', '/api/...')`). */
+function codeRoutes() {
+  const files = [path.join(SRC_DIR, 'server.js'), ...readdirSync(path.join(SRC_DIR, 'routes')).map((f) => path.join(SRC_DIR, 'routes', f))];
+  const routes = new Set();
+  for (const file of files) {
+    const text = readFileSync(file, 'utf8');
+    for (const m of text.matchAll(/route\('(GET|POST|PUT|DELETE|PATCH)',\s*'(\/api\/[^']*)'/g)) routes.add(m[2]);
+  }
+  return routes;
+}
+
+/** Paths `/api/...` que menciona AGENTS.md (tabla y prosa). */
+function docPaths() {
+  const text = readFileSync(AGENTS_MD, 'utf8');
+  const paths = new Set();
+  for (const m of text.matchAll(/\/api\/[A-Za-z0-9_\-/:.]+/g)) {
+    const p = m[0].replace(/[.,;:]+$/, '');
+    if (/^\/api\/?$/.test(p)) continue; // menciones comodin ("/api/..."), no rutas
+    paths.add(p);
+  }
+  return paths;
+}
+
+/** `/api/sessions/:id` y `/api/sessions/:name` son la misma ruta. */
+const norm = (p) => p.replace(/\/:[A-Za-z]+/g, '/:p');
+
+const code = codeRoutes();
+const doc = docPaths();
+const codeByNorm = new Map([...code].map((p) => [norm(p), p]));
+const docByNorm = new Map([...doc].map((p) => [norm(p), p]));
+
+test('hay rutas registradas para comparar (el parser no se rompio)', () => {
+  assert.ok(code.size > 60, `solo se leyeron ${code.size} rutas del server`);
+  assert.ok(doc.size > 60, `solo se leyeron ${doc.size} paths de AGENTS.md`);
+});
+
+test('toda ruta del server esta documentada en AGENTS.md', () => {
+  const faltan = [...codeByNorm].filter(([n]) => !docByNorm.has(n)).map(([, p]) => p);
+  assert.deepEqual(faltan, [], `rutas sin documentar en AGENTS.md: ${faltan.join(', ')}`);
+});
+
+test('todo /api/... que menciona AGENTS.md existe en el server', () => {
+  const sobran = [...docByNorm].filter(([n]) => !codeByNorm.has(n)).map(([, p]) => p);
+  assert.deepEqual(sobran, [], `paths de AGENTS.md que ya no existen: ${sobran.join(', ')}`);
+});

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

@@ -0,0 +1,89 @@
+// Regresion del login de la landing en un navegador de verdad.
+//
+// La landing se construye sobre elementos del DOM que pueden no existir (el
+// boton de tema se quito del header): si un `getElementById` devuelve null y se
+// usa sin guarda, el modulo entero se cae con un TypeError antes de registrar
+// el handler del form y el login queda "muerto" (el submit nativo recarga la
+// pagina y no pasa nada). Este test abre /landing con auth configurada, dispara
+// el submit y exige que el handler llame a /api/auth/login, sin errores de
+// consola.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { findBrowserPath, captureScreenshot } from '../../core/src/browser/index.js';
+import { setHome, ensureApp, writeApp, makeUser } from '../../core/src/index.js';
+import { createTamnoraServer } from '../src/index.js';
+import { fakeProvider } from './helpers.js';
+
+const HAY_NAVEGADOR = Boolean(findBrowserPath());
+const RUIDO = /favicon|ERR_NAME_NOT_RESOLVED|ERR_INTERNET_DISCONNECTED|ERR_CONNECTION|ERR_NETWORK|Failed to load resource/i;
+
+// Intercepta fetch para no depender del server aca y para que el submit no
+// navegue a la consola a mitad del script. El listener en fase de captura solo
+// cancela la accion por defecto (la recarga), no a los otros listeners.
+const LOGIN = `(async () => {
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const form = document.getElementById('login-form');
+  const out = { form: Boolean(form), user: Boolean(document.getElementById('user')), password: Boolean(document.getElementById('password')), calls: [] };
+  if (!form) return out;
+  await wait(300);
+  const realFetch = window.fetch;
+  window.fetch = (url, opts) => {
+    out.calls.push({ url: String(url), method: opts?.method || 'GET', body: opts?.body || '' });
+    // 401 controlado: el handler responde con el toast y NO navega a la
+    // consola, que romperia la captura a mitad del script.
+    return Promise.resolve(new Response(JSON.stringify({ error: 'prueba' }), { status: 401, headers: { 'Content-Type': 'application/json' } }));
+  };
+  form.addEventListener('submit', (e) => e.preventDefault(), { capture: true });
+  document.getElementById('user').value = 'admin';
+  document.getElementById('password').value = 'secreto123';
+  form.dispatchEvent(new Event('submit', { cancelable: true, bubbles: true }));
+  await wait(300);
+  window.fetch = realFetch;
+  return out;
+})()`;
+
+test(
+  'la landing loguea: el submit del form llama a /api/auth/login sin romperse',
+  { skip: HAY_NAVEGADOR ? false : 'sin navegador headless', timeout: 90000 },
+  async () => {
+    const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-landing-'));
+    setHome(cwd);
+    const app = ensureApp();
+    app.user = makeUser('admin', 'secreto123');
+    writeApp(app);
+
+    const instance = await createTamnoraServer({
+      cwd,
+      dbPath: path.join(cwd, 'tamnora.db'),
+      loadMcp: false,
+      resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    });
+    const info = await instance.listen({ port: 0 });
+    try {
+      const shot = await captureScreenshot(`${info.url}/landing`, {
+        allowPrivate: true,
+        width: 1280,
+        height: 800,
+        waitMs: 300,
+        timeoutMs: 30000,
+        preScript: LOGIN,
+      });
+      const result = shot.preScriptResult;
+      assert.ok(result, 'el script de la landing no devolvio resultado');
+      assert.ok(result.form && result.user && result.password, 'faltan el form o los inputs de login');
+
+      const login = result.calls.find((c) => c.url.endsWith('/api/auth/login') && c.method === 'POST');
+      assert.ok(login, `el submit del form no llamo a /api/auth/login (llamadas: ${JSON.stringify(result.calls)})`);
+      const body = JSON.parse(login.body);
+      assert.deepEqual(body, { username: 'admin', password: 'secreto123' });
+
+      const reales = shot.consoleErrors.filter((e) => !RUIDO.test(e.text));
+      assert.deepEqual(reales.map((e) => e.text), [], 'la landing tiro errores al cargar');
+    } finally {
+      await instance.close();
+    }
+  },
+);

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

@@ -0,0 +1,80 @@
+// Regresion de XSS del renderer de markdown. La consola mete su salida con
+// `innerHTML`, asi que cualquier etiqueta o atributo que se cuele con texto del
+// modelo (o de una pagina que el modelo leyo) se ejecutaria en la consola.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { renderMarkdown, highlight } from '../public/markdown.js';
+
+/** Etiquetas HTML reales que quedaron en el resultado (no las escapadas). */
+function tags(html) {
+  return [...html.matchAll(/<\/?([a-z][a-z0-9]*)\b[^>]*>/gi)].map((m) => m[1].toLowerCase());
+}
+
+const PERMITIDAS = new Set(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'strong', 'em', 'code', 'a', 'ul', 'ol', 'li', 'hr', 'blockquote', 'pre', 'div', 'span', 'button', 'table', 'thead', 'tbody', 'tr', 'th', 'td']);
+
+const PAYLOADS = [
+  '<img src=x onerror=alert(1)>',
+  '<svg/onload=alert(1)>',
+  '<script>alert(1)</script>',
+  '<iframe src="javascript:alert(1)"></iframe>',
+  '<a href="javascript:alert(1)">x</a>',
+  '"><img src=x onerror=alert(1)>',
+  "'><script>alert(1)</script>",
+  '</p><script>alert(1)</script>',
+  '<details open ontoggle=alert(1)>',
+  '<style>*{display:none}</style>',
+];
+
+test('ningun payload clasico deja etiquetas fuera de la lista permitida', () => {
+  for (const payload of PAYLOADS) {
+    for (const wrap of [(p) => p, (p) => `# ${p}`, (p) => `- ${p}`, (p) => `> ${p}`, (p) => `**${p}**`, (p) => `| ${p} |\n| --- |\n| ${p} |`]) {
+      const html = renderMarkdown(wrap(payload));
+      for (const tag of tags(html)) {
+        assert.ok(PERMITIDAS.has(tag), `etiqueta <${tag}> inesperada con ${JSON.stringify(payload)} -> ${html}`);
+      }
+      assert.ok(!/<(script|img|svg|iframe|style|details)\b/i.test(html), `etiqueta peligrosa viva: ${html}`);
+    }
+  }
+});
+
+test('un payload dentro de un bloque de codigo y su lenguaje queda escapado', () => {
+  for (const lang of ['js', 'html', 'css']) {
+    const html = renderMarkdown('```' + lang + '\n<img src=x onerror=alert(1)><script>alert(1)</script>\n```');
+    assert.ok(!/<img\b/i.test(html), html);
+    assert.ok(!/<script\b/i.test(html), html);
+    assert.match(html, /&lt;/);
+  }
+});
+
+test('los enlaces solo salen para http(s) y no se pueden salir del atributo href', () => {
+  for (const url of ['javascript:alert(1)', 'JaVaScRiPt:alert(1)', 'data:text/html,<script>alert(1)</script>', 'vbscript:x', ' javascript:alert(1)']) {
+    const html = renderMarkdown(`[click](${url})`);
+    assert.ok(!/<a\b/i.test(html), `no deberia haber enlace para ${url}: ${html}`);
+  }
+
+  const html = renderMarkdown('[x](https://a.com/"onmouseover="alert(1))');
+  assert.ok(!/\sonmouseover\s*=/i.test(html), `el atributo se escapo del href: ${html}`);
+  const anchors = html.match(/<a\b[^>]*>/g) ?? [];
+  for (const anchor of anchors) {
+    const attrs = [...anchor.matchAll(/\s([a-z-]+)=/gi)].map((m) => m[1]);
+    assert.deepEqual(attrs.sort(), ['href', 'rel', 'target'], anchor);
+  }
+});
+
+test('el nombre del lenguaje del fence no se interpreta como HTML', () => {
+  const html = renderMarkdown('```<img src=x onerror=alert(1)>\ncodigo\n```');
+  assert.ok(!/<img\b/i.test(html), html);
+});
+
+test('los marcadores internos del inline no se pueden forjar desde el texto', () => {
+  const html = renderMarkdown('texto \uE0005\uE000 y `real`');
+  assert.ok(!/undefined/.test(html), html);
+});
+
+test('highlight de html/css/js nunca devuelve etiquetas vivas', () => {
+  for (const lang of ['html', 'xml', 'css', 'js', 'python', '']) {
+    const out = highlight('<img src=x onerror=alert(1)> "</span><script>alert(1)</script>"', lang);
+    assert.ok(!/<(img|script)\b/i.test(out), `${lang}: ${out}`);
+    for (const tag of tags(out)) assert.equal(tag, 'span', `${lang}: ${out}`);
+  }
+});

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

@@ -0,0 +1,95 @@
+// Recargas operativas desde la consola: reiniciar el server y abrir el puente.
+// El spawn y tailscale se inyectan (como `spawnUpdater` en el update) para no
+// matar el proceso de test ni depender de tener tailscale instalado.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+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';
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-reload-'));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: { id: 'fake' }, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+test('POST /api/server/restart dispara el relanzador y responde 202', async () => {
+  const { instance, base } = await startServer();
+  let called = null;
+  instance.ctx.spawnRestarter = (options) => {
+    called = options;
+    return { ok: true, pid: 1234 };
+  };
+  instance.ctx.shutdown = async () => {};
+  try {
+    const res = await fetch(`${base}/api/server/restart`, { method: 'POST' });
+    assert.equal(res.status, 202);
+    const data = await res.json();
+    assert.equal(data.restarting, true);
+    assert.ok(called);
+    assert.equal(called.pid, process.pid);
+    assert.ok(Array.isArray(called.argv) && called.argv.length > 0, 'el relanzador necesita el argv del server');
+  } finally {
+    await instance.close();
+  }
+});
+
+test('POST /api/server/restart falla claro si no puede lanzar el relanzador', async () => {
+  const { instance, base } = await startServer();
+  instance.ctx.spawnRestarter = () => ({ ok: false, error: 'no arranco' });
+  try {
+    const res = await fetch(`${base}/api/server/restart`, { method: 'POST' });
+    assert.equal(res.status, 500);
+    const data = await res.json();
+    assert.match(data.error, /no arranco/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('POST /api/bridge/reload reinicia el puente y devuelve la URL', async () => {
+  const { instance, base } = await startServer();
+  const eventos = [];
+  instance.ctx.tunnelStop = async () => {
+    eventos.push('stop');
+  };
+  instance.ctx.tunnelStart = async (port) => {
+    eventos.push(`start:${port}`);
+    return { url: 'https://demo.ts.net', provider: 'tailscale' };
+  };
+  try {
+    const res = await fetch(`${base}/api/bridge/reload`, { method: 'POST' });
+    assert.equal(res.status, 200);
+    const data = await res.json();
+    assert.equal(data.ok, true);
+    assert.equal(data.url, 'https://demo.ts.net');
+    assert.deepEqual(eventos, ['stop', `start:${instance.ctx.serverInfo.port}`], 'apaga y vuelve a publicar el puerto del server');
+  } finally {
+    await instance.close();
+  }
+});
+
+test('POST /api/bridge/reload expone el fallo de tailscale como 502', async () => {
+  const { instance, base } = await startServer();
+  instance.ctx.tunnelStop = async () => {};
+  instance.ctx.tunnelStart = async () => {
+    throw new Error('Tailscale no esta conectado.');
+  };
+  try {
+    const res = await fetch(`${base}/api/bridge/reload`, { method: 'POST' });
+    assert.equal(res.status, 502);
+    const data = await res.json();
+    assert.match(data.error, /Tailscale/);
+  } finally {
+    await instance.close();
+  }
+});

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

@@ -0,0 +1,109 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { startServer } from './helpers.js';
+import { buildCsp, CSP_DIRECTIVES, cspMode } from '../src/lib/securityHeaders.js';
+
+const PUBLIC = new URL('../public/', import.meta.url);
+
+async function serverWithConfig(config) {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-csp-'));
+  if (config) await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify(config));
+  return startServer({ cwd });
+}
+
+test('la consola sale con CSP estricta y cabeceras de endurecimiento', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/`);
+    assert.equal(res.status, 200);
+    const csp = res.headers.get('content-security-policy');
+    assert.ok(csp, 'falta Content-Security-Policy');
+    assert.match(csp, /(^|;\s*)script-src 'self'(;|$)/);
+    assert.ok(!/script-src[^;]*unsafe-(inline|eval)/.test(csp), 'script-src no puede permitir inline ni eval');
+    assert.match(csp, /frame-ancestors 'self'/);
+    assert.match(csp, /object-src 'none'/);
+    assert.match(csp, /base-uri 'self'/);
+    assert.equal(res.headers.get('x-content-type-options'), 'nosniff');
+    assert.equal(res.headers.get('x-frame-options'), 'SAMEORIGIN');
+    assert.equal(res.headers.get('referrer-policy'), 'same-origin');
+  } finally {
+    await instance.close();
+  }
+});
+
+test('la CSP deja pasar lo que la consola necesita: preview embebido y fuentes', () => {
+  const csp = buildCsp();
+  assert.match(csp, /frame-src http: https:/);
+  assert.match(csp, /style-src [^;]*https:\/\/fonts\.googleapis\.com/);
+  assert.match(csp, /font-src [^;]*https:\/\/fonts\.gstatic\.com/);
+  assert.match(csp, /img-src [^;]*data: blob:/);
+  assert.match(csp, /media-src [^;]*blob:/);
+  assert.match(csp, /connect-src 'self'(;|$)/);
+});
+
+test('la API lleva nosniff pero no CSP (no protege nada en un JSON)', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/api/health`);
+    assert.equal(res.status, 200);
+    assert.equal(res.headers.get('x-content-type-options'), 'nosniff');
+    assert.equal(res.headers.get('content-security-policy'), null);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('el landing tambien lleva CSP', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/landing/`);
+    assert.equal(res.status, 200);
+    assert.ok(res.headers.get('content-security-policy'));
+  } finally {
+    await instance.close();
+  }
+});
+
+test('server.csp permite pasar a report-only o apagarla', async () => {
+  for (const [mode, header, present] of [
+    ['report-only', 'content-security-policy-report-only', true],
+    ['off', 'content-security-policy', false],
+  ]) {
+    const { instance, base } = await serverWithConfig({ server: { csp: mode } });
+    try {
+      const res = await fetch(`${base}/`);
+      assert.equal(Boolean(res.headers.get(header)), present, mode);
+      if (mode === 'report-only') assert.equal(res.headers.get('content-security-policy'), null);
+      assert.equal(res.headers.get('x-content-type-options'), 'nosniff', `${mode}: nosniff sigue`);
+    } finally {
+      await instance.close();
+    }
+  }
+});
+
+test('cspMode ignora valores invalidos y cae a enforce', () => {
+  assert.equal(cspMode({}), 'enforce');
+  assert.equal(cspMode({ server: { csp: 'banana' } }), 'enforce');
+  assert.equal(cspMode({ server: { csp: 'off' } }), 'off');
+});
+
+test('ningun directive de la CSP queda vacio', () => {
+  for (const [name, sources] of Object.entries(CSP_DIRECTIVES)) {
+    assert.ok(sources.length > 0, name);
+  }
+});
+
+test('el HTML de la consola no tiene scripts ni handlers inline (la CSP los bloquearia)', async () => {
+  for (const file of ['index.html', 'landing/index.html']) {
+    const html = await readFile(new URL(file, PUBLIC), 'utf8');
+    const scripts = [...html.matchAll(/<script\b([^>]*)>/gi)];
+    assert.ok(scripts.length > 0, `${file}: sin scripts?`);
+    for (const [, attrs] of scripts) {
+      assert.match(attrs, /\ssrc=/, `${file}: script inline`);
+    }
+    assert.ok(!/\son[a-z]+\s*=\s*["']/i.test(html), `${file}: handler inline (onclick=...)`);
+  }
+});