@danieltmn/tamnora 0.25.1 → 0.26.1

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

@@ -33,11 +33,10 @@ test('los registros de tema y fuente son consistentes', () => {
   assert.equal(sistema.google, null, 'sistema no usa webfont');
 });
 
-test('resolveTheme mapea legacy light -> paper y cae al default', () => {
-  assert.equal(resolveTheme('light'), 'paper');
-  assert.equal(resolveTheme('nord'), 'nord');
+test('resolveTheme cae al default y resolveFont tambien', () => {
+  assert.equal(resolveTheme('github'), 'github');
   assert.equal(resolveTheme('no-existe'), DEFAULTS.theme);
-  assert.equal(resolveFont('plex'), 'plex');
+  assert.equal(resolveFont('sistema'), 'sistema');
   assert.equal(resolveFont('no-existe'), DEFAULTS.font);
 });
 
@@ -53,9 +52,9 @@ test('nextTheme recorre todos los temas y vuelve al inicio', () => {
 });
 
 test('normalizeAppearance acota tamaños y resuelve ids', () => {
-  const a = normalizeAppearance({ theme: 'dracula', font: 'inter', chatFont: 99, scale: 5 });
-  assert.equal(a.theme, 'dracula');
-  assert.equal(a.font, 'inter');
+  const a = normalizeAppearance({ theme: 'mocha', font: 'sistema', chatFont: 99, scale: 5 });
+  assert.equal(a.theme, 'mocha');
+  assert.equal(a.font, 'sistema');
   assert.equal(a.chatFont, 20);
   assert.equal(a.scale, 1.3);
   const b = normalizeAppearance({ theme: 'nope', chatFont: 1, scale: 0.1 });
@@ -67,44 +66,19 @@ test('normalizeAppearance acota tamaños y resuelve ids', () => {
 });
 
 test('la validacion del server coincide con el registro del cliente', () => {
-  assert.deepEqual(
-    THEMES.map((t) => t.id).sort(),
-    [
-      'paper',
-      'dark',
-      'midnight',
-      'nord',
-      'dracula',
-      'solarized',
-      'solarized-dark',
-      'bosque',
-      'vino',
-      'arena',
-      'hielo',
-      'vercel',
-      'dark-plus',
-      'github',
-      'github-dark',
-      'mocha',
-      'ebano',
-    ].sort()
-  );
-  assert.equal(resolveThemeId('solarized-dark'), 'solarized-dark');
-  assert.equal(resolveThemeId('vercel'), 'vercel');
-  assert.equal(resolveThemeId('github-dark'), 'github-dark');
-  assert.equal(resolveThemeId('light'), 'paper');
+  assert.deepEqual(THEMES.map((t) => t.id).sort(), ['paper', 'github', 'dark', 'mocha'].sort());
+  assert.equal(resolveThemeId('mocha'), 'mocha');
   assert.equal(resolveThemeId('bogus'), 'paper');
   assert.equal(resolveFontId('sistema'), 'sistema');
-  assert.equal(resolveFontId('jetbrains'), 'jetbrains');
   assert.equal(resolveFontId('bogus'), 'clasico');
 });
 
 test('resolveAppearance y sanitizeAppearance normalizan app.json', () => {
   assert.deepEqual(resolveAppearance({}), DEFAULT_APPEARANCE);
-  const saved = resolveAppearance({ appearance: { theme: 'nord', font: 'plex', chatFont: 18, scale: 1.1 } });
-  assert.deepEqual(saved, { theme: 'nord', font: 'plex', chatFont: 18, scale: 1.1 });
-  const merged = sanitizeAppearance({ theme: 'vino' }, saved);
-  assert.deepEqual(merged, { theme: 'vino', font: 'plex', chatFont: 18, scale: 1.1 });
+  const saved = resolveAppearance({ appearance: { theme: 'github', font: 'sistema', chatFont: 18, scale: 1.1 } });
+  assert.deepEqual(saved, { theme: 'github', font: 'sistema', chatFont: 18, scale: 1.1 });
+  const merged = sanitizeAppearance({ theme: 'mocha' }, saved);
+  assert.deepEqual(merged, { theme: 'mocha', font: 'sistema', chatFont: 18, scale: 1.1 });
   const clamped = sanitizeAppearance({ theme: 'x', font: 'y', chatFont: -5, scale: 9 });
   assert.deepEqual(clamped, { theme: 'paper', font: 'clasico', chatFont: 12, scale: 1.3 });
 });

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

@@ -1,8 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  ADVISOR_KINDS,
-  advisorMeta,
   basename,
   formatDuration,
   isFailedToolText,
@@ -97,12 +95,6 @@ test('userText y userImages separan las partes del mensaje multimodal', () => {
   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');

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

@@ -62,7 +62,7 @@ for (const [label, width, height] of [['escritorio', 1280, 800], ['tablet', 820,
         const result = shot.preScriptResult;
         assert.ok(result, 'el recorrido no devolvio resultado');
 
-        assert.ok(result.views.length >= 5, `vistas recorridas: ${JSON.stringify(result.views)}`);
+        assert.ok(result.views.length >= 3, `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})`);
         }
@@ -159,13 +159,13 @@ for (const [label, width, height] of [['escritorio', 1280, 800], ['movil', 390,
         const r = shot.preScriptResult;
         assert.ok(r, 'el script no devolvio resultado');
 
-        assert.equal(r.todas, 14, 'sin busqueda se ven las 14 secciones');
+        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: 14 }, 'Escape limpia la busqueda y vuelve a mostrar todo');
+        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' });
 
@@ -198,7 +198,7 @@ const TAMANOS = `(async () => {
     }
   };
   scan('chat');
-  for (const tab of ['providers', 'ajustes', 'eval', 'runs']) {
+  for (const tab of ['providers', 'ajustes']) {
     document.querySelector('#more-menu button[data-tab="' + tab + '"]').click();
     await wait(250);
     scan(tab);

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

@@ -1,6 +1,5 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import http from 'node:http';
 import { execFileSync } from 'node:child_process';
 import { mkdtemp, mkdir, writeFile, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -123,9 +122,13 @@ test('runs a scheduled task on demand (shell and agent)', async () => {
   }
 });
 
-test('detects, runs and stops dev processes', async () => {
+test('loads, runs and stops declared dev processes', async () => {
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
-  await writeFile(path.join(cwd, 'package.json'), JSON.stringify({ scripts: { dev: 'node server.js' } }));
+  await mkdir(path.join(cwd, '.tamnora'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'procs.json'),
+    JSON.stringify({ processes: [{ label: 'dev', command: 'npm', args: ['run', 'dev'], port: 5173 }] })
+  );
   const { instance, base } = await startServer({ cwd });
   const json = { 'Content-Type': 'application/json' };
   try {
@@ -191,14 +194,14 @@ test('runs a console shell command and kills a port', async () => {
     });
     assert.equal(missing.status, 400);
 
-    const badPort = await fetch(`${base}/api/procs/kill`, {
+    const badPort = await fetch(`${base}/api/ports/kill`, {
       method: 'POST',
       headers: json,
       body: JSON.stringify({ port: 0 }),
     });
     assert.equal(badPort.status, 400);
 
-    const none = await fetch(`${base}/api/procs/kill`, {
+    const none = await fetch(`${base}/api/ports/kill`, {
       method: 'POST',
       headers: json,
       body: JSON.stringify({ port: 47555 }),
@@ -213,14 +216,6 @@ test('runs a console shell command and kills a port', async () => {
     assert.equal(info.listening, false);
     assert.deepEqual(info.pids, []);
 
-    const aliasKill = await fetch(`${base}/api/ports/kill`, {
-      method: 'POST',
-      headers: json,
-      body: JSON.stringify({ port: 47555 }),
-    });
-    assert.equal(aliasKill.status, 200);
-    assert.deepEqual((await aliasKill.json()).pids, []);
-
     const badStatus = await fetch(`${base}/api/ports/0`);
     assert.equal(badStatus.status, 400);
   } finally {
@@ -228,49 +223,6 @@ test('runs a console shell command and kills a port', async () => {
   }
 });
 
-test('runs an evaluation over HTTP and persists the run', async () => {
-  const model = http.createServer((req, res) => {
-    let body = '';
-    req.on('data', (c) => (body += c));
-    req.on('end', () => {
-      res.setHeader('Content-Type', 'text/event-stream');
-      res.write(`data: ${JSON.stringify({ choices: [{ delta: { content: 'hola' } }] })}\n\n`);
-      res.write('data: [DONE]\n\n');
-      res.end();
-    });
-  });
-  await new Promise((r) => model.listen(0, '127.0.0.1', r));
-  const modelBase = `http://127.0.0.1:${model.address().port}/v1`;
-
-  const { instance, base } = await startServer();
-  try {
-    const res = await fetch(`${base}/api/eval`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        provider: 'openai-compatible',
-        baseUrl: modelBase,
-        models: ['mock'],
-        concurrency: 1,
-        tasks: [{ id: 't1', input: 'saluda', expect: { contains: 'hola' } }],
-      }),
-    });
-    const text = await res.text();
-    assert.match(text, /event: result/);
-    assert.match(text, /event: summary/);
-    assert.match(text, /"passed":1/);
-
-    const runs = await (await fetch(`${base}/api/runs`)).json();
-    assert.equal(runs.runs.length, 1);
-    const detail = await (await fetch(`${base}/api/runs/${runs.runs[0].id}`)).json();
-    assert.equal(detail.results.length, 1);
-    assert.equal(detail.results[0].passed, 1);
-  } finally {
-    await instance.close();
-    model.close();
-  }
-});
-
 test('creates a folder over HTTP and rejects bad input', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'tamnora-newdir-'));
   const { instance, base } = await startServer();

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

@@ -1,10 +1,10 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, writeFile, unlink } from 'node:fs/promises';
+import { mkdtemp, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { createTamnoraServer } from '../src/index.js';
-import { setHome, bridgeStatePath } from '../../core/src/index.js';
+import { setHome } from '../../core/src/index.js';
 
 async function startServer() {
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-preview-'));
@@ -21,29 +21,12 @@ async function startServer() {
   return { instance, base: info.url, cwd };
 }
 
-/** Deja un bridge.json apuntando a un tunel publico vivo (este proceso). */
-async function fakePublicTunnel() {
-  await writeFile(
-    bridgeStatePath(),
-    `${JSON.stringify({ pid: process.pid, url: 'https://fake.tunnelmole.net', provider: 'tunnelmole', port: 4517 })}\n`
-  );
-}
-
-async function clearTunnel() {
-  try {
-    await unlink(bridgeStatePath());
-  } catch {
-    /* nada */
-  }
-}
-
 test('GET /api/preview arranca sin tunel', async () => {
   const { instance, base } = await startServer();
   try {
     const data = await (await fetch(`${base}/api/preview`)).json();
     assert.equal(data.tunnel, null);
   } finally {
-    await clearTunnel();
     await instance.close();
   }
 });
@@ -69,7 +52,6 @@ test('POST/GET/DELETE /api/preview/tunnel mantiene el estado', async () => {
     const after = await (await fetch(`${base}/api/preview`)).json();
     assert.equal(after.tunnel, null);
   } finally {
-    await clearTunnel();
     await instance.close();
   }
 });
@@ -84,28 +66,6 @@ test('POST /api/preview/tunnel rechaza un puerto invalido', async () => {
     });
     assert.equal(post.status, 400);
   } finally {
-    await clearTunnel();
-    await instance.close();
-  }
-});
-
-test('con un tunel publico activo el preview queda cerrado para no locales', async () => {
-  const { instance, base } = await startServer();
-  try {
-    await fakePublicTunnel();
-    await new Promise((resolve) => setTimeout(resolve, 1100));
-
-    const post = await fetch(`${base}/api/preview/tunnel`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ port: 8080 }),
-    });
-    assert.equal(post.status, 403);
-
-    const del = await fetch(`${base}/api/preview/tunnel`, { method: 'DELETE' });
-    assert.equal(del.status, 403);
-  } finally {
-    await clearTunnel();
     await instance.close();
   }
 });