@danieltmn/tamnora 0.16.1 → 0.18.0

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

@@ -262,7 +262,73 @@ test('keeps a run alive after the client disconnects and can stop it', async ()
   }
 });
 
-/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
+test('interrupt cancels the running turn and starts the new message right away', async () => {
+  const calls = { n: 0 };
+  let abortedFirst = false;
+  const provider = {
+    id: 'interrupt',
+    async streamChat(_config, { onEvent, signal }) {
+      calls.n += 1;
+      if (calls.n === 1) {
+        onEvent?.({ type: 'text', delta: 'trabajando', full: 'trabajando' });
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(resolve, 5000);
+          const onAbort = () => {
+            clearTimeout(timer);
+            abortedFirst = true;
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+          };
+          if (signal?.aborted) return onAbort();
+          signal?.addEventListener('abort', onAbort, { once: true });
+        });
+      }
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+
+    const first = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'uno', model: 'm', sessionId: id }),
+    })
+      .then((res) => res.text())
+      .catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+
+    const second = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'dos', model: 'm', sessionId: id, interrupt: true }),
+      })
+    ).text();
+
+    assert.match(second, /event: text/);
+    assert.match(second, /listo/);
+    assert.equal(abortedFirst, true);
+    await first;
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    const after = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(after.running, false);
+  } finally {
+    await instance.close();
+  }
+});
+
+/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
 async function readSse(url, options, until, timeoutMs = 5000) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -877,13 +943,74 @@ test('manages MCP servers from the console', async () => {
     });
     assert.equal(bad.status, 400);
 
-    res = await fetch(`${base}/api/mcp/servers/echo`, { method: 'DELETE' });
-    assert.equal(res.status, 200);
-    data = await res.json();
-    assert.equal(data.servers.length, 0);
-  } finally {
-    await instance.close();
-  }
+    res = await fetch(`${base}/api/mcp/servers/echo`, { method: 'DELETE' });
+    assert.equal(res.status, 200);
+    data = await res.json();
+    assert.equal(data.servers.length, 0);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('sirve el catálogo de MCP/skills y los instala deshabilitados', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const catalog = await (await fetch(`${base}/api/mcp/catalog`)).json();
+    assert.ok(catalog.catalog.some((e) => e.id === 'playwright' && e.installed === false));
+
+    const add = await fetch(`${base}/api/mcp/import`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ catalog: 'playwright' }),
+    });
+    assert.equal(add.status, 200);
+    const added = await add.json();
+    assert.equal(added.imported, 'playwright');
+    assert.equal(added.servers.find((s) => s.id === 'playwright').enabled, false);
+
+    const again = await (await fetch(`${base}/api/mcp/catalog`)).json();
+    assert.equal(again.catalog.find((e) => e.id === 'playwright').installed, true);
+
+    const skills = await (await fetch(`${base}/api/skills/catalog`)).json();
+    assert.ok(skills.catalog.some((e) => e.id === 'code-review' && e.installed === false));
+    const skillAdd = await fetch(`${base}/api/skills`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ id: 'code-review' }),
+    });
+    assert.equal(skillAdd.status, 200);
+    const skillData = await skillAdd.json();
+    assert.equal(skillData.installed, 'code-review');
+    assert.equal(skillData.skills.find((s) => s.id === 'code-review').enabled, false);
+
+    const unknown = await fetch(`${base}/api/mcp/import`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ catalog: 'nope' }),
+    });
+    assert.equal(unknown.status, 404);
+    const unknownSkill = await fetch(`${base}/api/skills`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ id: 'nope' }),
+    });
+    assert.equal(unknownSkill.status, 404);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('los buscadores devuelven vacío sin query', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const mcp = await (await fetch(`${base}/api/mcp/search`)).json();
+    assert.deepEqual(mcp.results, []);
+    const skills = await (await fetch(`${base}/api/skills/search`)).json();
+    assert.deepEqual(skills.results, []);
+  } finally {
+    await instance.close();
+  }
 });
 
 test('MCP: el env se enmascara y no se pisa al guardar sin cambios', async () => {
@@ -949,6 +1076,36 @@ test('guarda los límites del agente desde Ajustes', async () => {
   }
 });
 
+test('guarda el modo de carga y las tools fijas de MCP', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const res = await fetch(`${base}/api/settings`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ mcpMode: 'lazy', mcpPinned: 'mcp__postgres__query, postgres' }),
+    });
+    const data = await res.json();
+    assert.equal(data.settings.mcpMode, 'lazy');
+    assert.deepEqual(data.settings.mcpPinned, ['mcp__postgres__query', 'postgres']);
+
+    const mcp = await (await fetch(`${base}/api/mcp`)).json();
+    assert.equal(mcp.mode, 'lazy');
+    assert.deepEqual(mcp.pinned, ['mcp__postgres__query', 'postgres']);
+    assert.equal(mcp.threshold, 12);
+    assert.equal(mcp.toolCount, null);
+
+    const bad = await fetch(`${base}/api/settings`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ mcpMode: 'nope' }),
+    });
+    assert.equal((await bad.json()).settings.mcpMode, 'auto');
+  } finally {
+    await instance.close();
+  }
+});
+
 test('imports an MCP server from a JSON snippet', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };
@@ -1561,20 +1718,38 @@ test('runs a console shell command and kills a port', async () => {
     });
     assert.equal(missing.status, 400);
 
-    const badPort = await fetch(`${base}/api/procs/kill`, {
-      method: 'POST',
-      headers: json,
-      body: JSON.stringify({ port: 0 }),
-    });
-    assert.equal(badPort.status, 400);
-
-    const none = await fetch(`${base}/api/procs/kill`, {
-      method: 'POST',
-      headers: json,
-      body: JSON.stringify({ port: 47555 }),
-    });
-    assert.equal(none.status, 200);
-    assert.deepEqual((await none.json()).pids, []);
+    const badPort = await fetch(`${base}/api/procs/kill`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ port: 0 }),
+    });
+    assert.equal(badPort.status, 400);
+
+    const none = await fetch(`${base}/api/procs/kill`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ port: 47555 }),
+    });
+    assert.equal(none.status, 200);
+    assert.deepEqual((await none.json()).pids, []);
+
+    const status = await fetch(`${base}/api/ports/47555`);
+    assert.equal(status.status, 200);
+    const info = await status.json();
+    assert.equal(info.port, 47555);
+    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 {
     await instance.close();
   }
@@ -1982,18 +2157,89 @@ test('asks for approval before running a gated tool and runs it once approved',
   }
 });
 
-test('rejects unknown permission requests', async () => {
-  const { instance, base } = await startServer();
-  try {
-    const res = await fetch(`${base}/api/permissions/does-not-exist`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ allow: true }),
-    });
-    assert.equal(res.status, 404);
-  } finally {
-    await instance.close();
-  }
+test('rejects unknown permission requests', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/api/permissions/does-not-exist`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ allow: true }),
+    });
+    assert.equal(res.status, 404);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('ask_user muestra un formulario y recibe las respuestas', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-askuser-'));
+  let calls = 0;
+  let captured = null;
+  const provider = {
+    id: 'formy',
+    async streamChat(_config, opts) {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: 'q1',
+              function: {
+                name: 'ask_user',
+                arguments: JSON.stringify({
+                  questions: [
+                    { id: 'nombre', label: '¿Tu nombre?' },
+                    { id: 'color', label: 'Color', type: 'select', options: ['rojo', 'verde'] },
+                  ],
+                }),
+              },
+            },
+          ],
+        };
+      }
+      captured = opts.messages;
+      return { content: 'Gracias', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'preguntame', model: 'm' }),
+    });
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let askId = null;
+    let done = false;
+    while (!done) {
+      const { value } = await reader.read();
+      if (!value) break;
+      buffer += decoder.decode(value, { stream: true });
+      if (!askId && buffer.includes('event: question')) {
+        const match = buffer.match(/"askId":"([0-9a-f-]+)"/);
+        if (match) {
+          askId = match[1];
+          const answer = await fetch(`${base}/api/questions/${askId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ answers: { nombre: 'Ana', color: 'verde' } }),
+          });
+          assert.equal(answer.status, 200);
+        }
+      }
+      if (buffer.includes('event: done')) done = true;
+    }
+    assert.ok(askId, 'emitió el evento question');
+    const toolMsg = (captured ?? []).find((m) => m.role === 'tool');
+    assert.match(String(toolMsg?.content ?? ''), /Ana/);
+    assert.match(String(toolMsg?.content ?? ''), /verde/);
+  } finally {
+    await instance.close();
+  }
 });
 
 async function readEvents(res, onFrame) {
@@ -2237,6 +2483,7 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
       })
     ).text();
     assert.deepEqual(captured.tools, [
+      'ask_user',
       'console_errors',
       'fetch_url',
       'git_diff',
@@ -2247,9 +2494,13 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
       'list',
       'list_mcp',
       'list_skills',
+      'offer_choices',
       'preview_url',
       'read',
       'screenshot',
+      'search_mcp',
+      'search_skills',
+      'show_plan',
       'skill',
       'speak',
       'task',

package/harness/packages/server/test/telegram-features.test.js

@@ -79,6 +79,8 @@ function makeCtx(cwd, { app = {}, presence } = {}) {
     effectiveProviderId: () => 'fake',
     effectiveModel: () => 'm',
     effectiveMode: () => 'agent',
+    effectiveMcpMode: () => 'auto',
+    effectiveMcpPinned: () => [],
     providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
     apiKeyFor: () => '',
     customProviderDefs: () => [],

package/harness/packages/server/test/telegram-voz.test.js

@@ -81,6 +81,8 @@ function makeCtx(cwd, app = {}) {
     effectiveProviderId: () => 'fake',
     effectiveModel: () => 'm',
     effectiveMode: () => 'agent',
+    effectiveMcpMode: () => 'auto',
+    effectiveMcpPinned: () => [],
     providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
     apiKeyFor: () => '',
     customProviderDefs: () => [],

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

@@ -48,6 +48,8 @@ function makeCtx(cwd) {
     effectiveProviderId: () => 'fake',
     effectiveModel: () => 'm',
     effectiveMode: () => 'agent',
+    effectiveMcpMode: () => 'auto',
+    effectiveMcpPinned: () => [],
     providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
     apiKeyFor: () => '',
     customProviderDefs: () => [],

package/harness/tamnora.example.json

@@ -15,6 +15,8 @@
   "plugins": [],
   "tools": [],
   "permissions": {},
+  "mcpMode": "auto",
+  "mcpPinned": [],
   "mcp": [
     {
       "id": "echo",
@@ -51,7 +53,7 @@
     "enabled": true,
     "allow": ["npm", "node", "npx", "pnpm", "yarn", "bun", "php", "python", "composer"]
   },
-  "preview": { "provider": "tunnelmole" },
+  "preview": { "provider": "tailscale", "tailscalePort": 8443, "fallback": true },
   "telegram": { "token": "", "allowedChatIds": [], "transcribeModel": "whisper-1" },
   "agents": { "maxRounds": 6 }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",