@danieltmn/tamnora 0.9.3 → 0.9.4

package/harness/packages/core/test/agent.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, readFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { runAgent, parseToolArguments } from '../src/agent/runAgent.js';
+import { runAgent, parseToolArguments, normalizeToolOutput } from '../src/agent/runAgent.js';
 import { createTools } from '../src/tools/index.js';
 
 test('agent executes tool calls then returns the final answer', async () => {
@@ -328,3 +328,32 @@ test('agent respeta el presupuesto de tokens y cierra con resumen', async () =>
   assert.equal(result.stopReason, 'budget');
   assert.equal(result.content, 'cierre');
 });
+
+test('normalizeToolOutput acepta string y { content, meta }', () => {
+  assert.deepEqual(normalizeToolOutput('hola'), { content: 'hola' });
+  assert.deepEqual(normalizeToolOutput({ content: 'ok', meta: { a: 1 } }), { content: 'ok', meta: { a: 1 } });
+  assert.deepEqual(normalizeToolOutput({ x: 1 }), { content: '{"x":1}' });
+  assert.deepEqual(normalizeToolOutput(undefined), { content: '' });
+});
+
+test('tool_result propaga el meta del executor sin ensuciar el contenido', async () => {
+  const events = [];
+  const provider = {
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool')) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return { content: '', reasoning: '', toolCalls: [{ id: 'c1', function: { name: 'shot', arguments: '{}' } }] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'shot', parameters: {} } }],
+    execute: async () => ({ content: 'captura', meta: { screenshot: { name: 'a.png' } } }),
+    onEvent: (e) => events.push(e),
+  });
+  const result = events.find((e) => e.type === 'tool_result');
+  assert.equal(result.result, 'captura');
+  assert.deepEqual(result.meta, { screenshot: { name: 'a.png' } });
+});

package/harness/packages/core/test/browser.test.js

@@ -0,0 +1,18 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { findBrowserPath } from '../src/browser/index.js';
+
+test('findBrowserPath respeta TAMNORA_BROWSER cuando el archivo existe', () => {
+  const self = fileURLToPath(import.meta.url);
+  assert.ok(existsSync(self));
+  const previous = process.env.TAMNORA_BROWSER;
+  process.env.TAMNORA_BROWSER = self;
+  try {
+    assert.equal(findBrowserPath(), self);
+  } finally {
+    if (previous === undefined) delete process.env.TAMNORA_BROWSER;
+    else process.env.TAMNORA_BROWSER = previous;
+  }
+});

package/harness/packages/core/test/tools.test.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { resolveInRoot, toRel } from '../src/tools/paths.js';
 import { evaluatePermission } from '../src/tools/permissions.js';
 import { createTools, createToolRegistry } from '../src/tools/index.js';
-import { fetchUrlTool } from '../src/tools/executors.js';
+import { fetchUrlTool, previewUrlTool, screenshotTool, consoleTool } from '../src/tools/executors.js';
 
 async function makeWorkspace() {
   const root = await mkdtemp(path.join(tmpdir(), 'tamnora-ws-'));
@@ -169,3 +169,18 @@ test('la tool speak valida el texto y la recorta', async () => {
   const { definitions } = createTools({ root: await makeWorkspace() });
   assert.ok(definitions.some((d) => d.function.name === 'speak'));
 });
+
+test('screenshot, console_errors y preview_url validan la URL sin lanzar el navegador', async () => {
+  assert.match(previewUrlTool(null, { url: 'https://example.com/x' }), /example\.com/);
+  assert.match(previewUrlTool(null, {}), /falta "url"/);
+  assert.match(await screenshotTool(null, { url: 'ftp://x' }), /Solo se admite http/);
+  assert.match(await screenshotTool(null, {}), /falta "url"/);
+  assert.match(await consoleTool(null, { url: 'no-url' }), /URL inválida/);
+  assert.equal(evaluatePermission('screenshot', {}, {}), 'allow');
+  assert.equal(evaluatePermission('console_errors', {}, {}), 'allow');
+  assert.equal(evaluatePermission('preview_url', {}, {}), 'allow');
+  const { definitions } = createTools({ root: await makeWorkspace() });
+  for (const name of ['screenshot', 'console_errors', 'preview_url']) {
+    assert.ok(definitions.some((d) => d.function.name === name), `falta ${name}`);
+  }
+});

package/harness/packages/server/public/app.js

@@ -1158,6 +1158,10 @@ function toolSummary(name, args) {
       return shortText(a.url, 90);
     case 'speak':
       return shortText(a.texto, 90);
+    case 'screenshot':
+    case 'console_errors':
+    case 'preview_url':
+      return shortText(a.url, 90);
     case 'git_diff':
       return [a.ref ? `vs ${shortText(a.ref, 30)}` : a.staged ? 'staged' : 'unstaged', a.path ? shortText(a.path, 40) : '']
         .filter(Boolean)
@@ -1189,6 +1193,26 @@ function isFailedToolText(text) {
   return /^Error|^Permiso denegado/i.test(String(text ?? ''));
 }
 
+/** Nombre de archivo de una captura, del meta o del texto del resultado. */
+function screenshotName(data, text) {
+  const fromMeta = data?.meta?.screenshot?.name;
+  if (fromMeta) return String(fromMeta);
+  const match = /capturas\/([a-z0-9][a-z0-9-]*\.png)/i.exec(String(text ?? ''));
+  return match ? match[1] : null;
+}
+
+/** Muestra la captura del tool `screenshot` en su tarjeta (clic para ampliar). */
+function showScreenshot(entry, name) {
+  if (!entry || !name || entry.shot) return;
+  entry.shot = true;
+  const img = el('img', 'tool-shot');
+  img.loading = 'lazy';
+  img.alt = 'captura de pantalla';
+  img.src = `/api/screenshots/${encodeURIComponent(name)}`;
+  img.addEventListener('click', () => window.open(img.src, '_blank'));
+  entry.card.appendChild(img);
+}
+
 /** Cierra la tarjeta de un tool-call (evento tool_result o mensaje persistido). */
 function finishToolCard(entry, data) {
   if (!entry) return;
@@ -1203,6 +1227,7 @@ function finishToolCard(entry, data) {
     entry.truncated = true;
     entry.more.hidden = false;
   }
+  if (!failed) showScreenshot(entry, screenshotName(data, preview));
 }
 
 function previewText(value, maxLines = 24, maxChars = 4000) {
@@ -2026,6 +2051,10 @@ function handleChatEvent(event, data, turn) {
       const texto = String(data.args?.texto ?? '').trim();
       if (texto) reproducirVoz(texto, { voice: data.args?.voice, rate: data.args?.rate, label: 'voz' }).catch(() => {});
     }
+    if (turn.live && data.name === 'preview_url' && data.args?.url) {
+      setExplorerMode('preview');
+      loadPreview(data.args.url);
+    }
   } else if (event === 'tool_result') {
     setActivity(turn.assistant(), 'thinking');
     finishToolCard(turn.lastTool, data);

package/harness/packages/server/public/index.html

@@ -34,7 +34,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.9.3</span></div>
+      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.9.4</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>

package/harness/packages/server/public/landing/index.html

@@ -451,7 +451,8 @@
 
           <p class="hero-copy">
             Un harness local para orquestar agentes de IA, ejecutar tools en tu workspace y mantener el
-            control desde tu máquina o el celular (túnel + QR o Telegram).
+            control desde tu máquina o el celular (túnel + QR o Telegram). Renderiza páginas con un
+            navegador headless, narra su progreso y hace trazable cada corrida.
           </p>
 
           <div class="actions">
@@ -472,6 +473,18 @@
               <div class="feature-icon">✓</div>
               <div><b>Control</b><span>Permisos allow/ask/deny y runs trazables.</span></div>
             </div>
+            <div class="feature">
+              <div class="feature-icon">◎</div>
+              <div><b>Navegador</b><span>Screenshot y errores de consola de una página.</span></div>
+            </div>
+            <div class="feature">
+              <div class="feature-icon">♪</div>
+              <div><b>Voz</b><span>Narra el progreso y manda audio bajo pedido.</span></div>
+            </div>
+            <div class="feature">
+              <div class="feature-icon">⌘</div>
+              <div><b>Multi-modelo</b><span>OpenRouter, OpenAI, Claude, Gemini y Ollama.</span></div>
+            </div>
           </div>
         </section>
 

package/harness/packages/server/public/reconcile.js

@@ -110,7 +110,9 @@ export function summarizeArgs(name, args, max = 240) {
   if ((name === 'write' || name === 'edit' || name === 'read') && a.path) {
     return a.content ? `${a.path} · ${humanSize(a.content)}` : String(a.path);
   }
-  if ((name === 'fetch_url' || name === 'preview_url') && a.url) return cut(a.url);
+  if ((name === 'fetch_url' || name === 'preview_url' || name === 'screenshot' || name === 'console_errors') && a.url) {
+    return cut(a.url);
+  }
   if (name === 'task' && (a.description || a.prompt)) return cut(a.description || a.prompt);
   const keys = Object.keys(a);
   if (keys.length === 1 && typeof a[keys[0]] === 'string') return cut(a[keys[0]]);

package/harness/packages/server/public/styles.css

@@ -627,6 +627,17 @@ body.resizing * { cursor: col-resize !important; }
   font: 600 12px var(--sans);
 }
 .tool-card > .tool-audio-btn:hover { background: var(--theirs); }
+.tool-card > .tool-shot {
+  display: block;
+  max-width: calc(100% - 28px);
+  max-height: 420px;
+  width: auto;
+  margin: 6px 0 4px 18px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  cursor: zoom-in;
+  background: #fff;
+}
 
 /* Reproductor único de audio (narración, speak, resumen): visible y detenible. */
 .audio-player {

package/harness/packages/server/src/lib/agentRun.js

@@ -6,10 +6,10 @@ import { summarizeToolCall, previewToolResult } from './core.js';
 
 const FAILED_RE = /^Error|^Permiso denegado/i;
 
-/** Payload estandar de un tool_result para eventos SSE: preview + failed. */
+/** Payload estandar de un tool_result para eventos SSE: preview + failed (+ meta). */
 export function toolResultPayload(event) {
   const { preview, truncated } = previewToolResult(event.name, event.result);
-  return { preview, truncated, failed: FAILED_RE.test(String(event.result)) };
+  return { preview, truncated, failed: FAILED_RE.test(String(event.result)), meta: event.meta };
 }
 
 export function toolCallPayload(event) {

package/harness/packages/server/src/lib/channels/telegram.js

@@ -4,8 +4,18 @@
 // proyecto (una carpeta de la raiz configurada en la consola).
 
 import path from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, listProviderModels, PROVIDER_META, sintetizar, MAX_TEXTO } from '../core.js';
+import {
+  runAgent,
+  createTools,
+  resolveMode,
+  listProviderModels,
+  PROVIDER_META,
+  sintetizar,
+  MAX_TEXTO,
+  screenshotsDir,
+} from '../core.js';
 import { resolveExistingDir, listSubdirs } from '../workspace.js';
 import {
   combineToolset,
@@ -42,6 +52,72 @@ const HELP = [
   'Podés mandar texto, imágenes o notas de voz.',
 ].join('\n');
 
+function humanSize(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function oneLine(value, max = 400) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+
+/**
+ * Explica en una frase qué va a hacer el agente si se aprueba el permiso, en
+ * vez de volcar el JSON crudo (que para `write` mostraba medio archivo).
+ */
+export function describePermission(name, args = {}) {
+  const a = args && typeof args === 'object' ? args : {};
+  switch (name) {
+    case 'bash':
+      return { action: 'ejecutar un comando en el proyecto', detail: oneLine(a.command, 700) };
+    case 'write':
+      return {
+        action: `escribir el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.content ? `Contenido: ${humanSize(Buffer.byteLength(String(a.content)))}` : '',
+      };
+    case 'edit':
+      return {
+        action: `editar el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.oldString ? `Reemplaza: "${oneLine(a.oldString, 100)}"` : '',
+      };
+    case 'git_commit':
+      return { action: 'hacer un commit', detail: oneLine(a.message, 200) };
+    case 'screenshot':
+      return { action: 'sacar una captura de la página', detail: oneLine(a.url, 200) };
+    case 'console_errors':
+      return { action: 'revisar la consola de una página', detail: oneLine(a.url, 200) };
+    case 'fetch_url':
+      return { action: 'consultar una URL', detail: oneLine(a.url, 200) };
+    case 'read':
+      return { action: `leer ${oneLine(a.path, 120) || 'un archivo'}`, detail: '' };
+    default:
+      return { action: `usar la herramienta "${name}"`, detail: oneLine(JSON.stringify(a), 200) };
+  }
+}
+
+function permissionMessage(project, name, args) {
+  const { action, detail } = describePermission(name, args);
+  const lines = [`⚠ [${project}] Permiso: el agente quiere ${action}.`];
+  if (detail) lines.push('', detail);
+  lines.push('', '¿Qué hacemos?');
+  return lines.join('\n');
+}
+
+function permissionKeyboard(askId) {
+  return {
+    inline_keyboard: [
+      [
+        { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+        { text: 'Permitir todo', callback_data: `perm:${askId}:all` },
+      ],
+      [{ text: 'Denegar', callback_data: `perm:${askId}:deny` }],
+    ],
+  };
+}
+
 async function tg(token, method, payload) {
   const res = await fetch(`${API}/bot${token}/${method}`, {
     method: 'POST',
@@ -144,6 +220,7 @@ export function startTelegramChannel(
   const modelChoices = new Map();
   const projectChoices = new Map();
   const pendingInputs = new Map();
+  const askSessions = new Map(); // askId -> sessionId, para "Permitir todo"
   let running = true;
   let offset = 0;
 
@@ -194,6 +271,32 @@ export function startTelegramChannel(
     }
   }
 
+  /** Manda una imagen (una captura del tool `screenshot`). */
+  async function enviarFoto(chatId, buffer, caption) {
+    try {
+      const form = new FormData();
+      form.append('chat_id', chatId);
+      if (caption) form.append('caption', String(caption).slice(0, 1000));
+      form.append('photo', new Blob([buffer], { type: 'image/png' }), 'captura.png');
+      await tgForm(token, 'sendPhoto', form);
+    } catch (error) {
+      log(`telegram: foto falló: ${error?.message ?? error}`);
+    }
+  }
+
+  /** Entrega una captura guardada en la casa (por nombre, sin path traversal). */
+  async function enviarCaptura(chatId, name, caption) {
+    const safe = String(name ?? '');
+    if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(safe)) return;
+    let buffer;
+    try {
+      buffer = await readFile(path.join(screenshotsDir(), safe));
+    } catch {
+      return;
+    }
+    await enviarFoto(chatId, buffer, caption);
+  }
+
   // --- proyectos ------------------------------------------------------------
 
   /** Carpeta raíz para elegir proyecto: la predeterminada de la consola o el cwd. */
@@ -351,19 +454,15 @@ export function startTelegramChannel(
     }
 
     const onAsk = async (name, args) => {
+      // "Permitir todo" activa el auto-approve de la sesion (compartido con la
+      // consola): a partir de ahi no se vuelve a preguntar.
+      if (ctx.isAutoApprove?.(sessionId)) return true;
       const askId = randomUUID();
-      const preview = JSON.stringify(args ?? {}).slice(0, 300);
-      await send(chatId, `⚠ [${projectLabel(session)}] Permiso para ${name}\n${preview}`, {
-        reply_markup: {
-          inline_keyboard: [
-            [
-              { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-              { text: 'Denegar', callback_data: `perm:${askId}:deny` },
-            ],
-          ],
-        },
+      askSessions.set(askId, sessionId);
+      await send(chatId, permissionMessage(projectLabel(session), name, args), {
+        reply_markup: permissionKeyboard(askId),
       });
-      return ctx.approvals.ask(askId);
+      return ctx.approvals.ask(askId, { sessionId, name, args });
     };
 
     const local = createTools({
@@ -419,6 +518,9 @@ export function startTelegramChannel(
             }
           } else if (event.type === 'tool_result') {
             activity = `${event.name} ✓`;
+            if (event.name === 'screenshot' && event.meta?.screenshot?.name) {
+              enviarCaptura(chatId, event.meta.screenshot.name, event.meta.screenshot.url);
+            }
           } else {
             return;
           }
@@ -656,8 +758,12 @@ export function startTelegramChannel(
     let toast = '';
 
     if (kind === 'perm') {
-      ctx.approvals.decide(a, b === 'allow');
-      toast = b === 'allow' ? 'Permitido' : 'Denegado';
+      const all = b === 'all';
+      ctx.approvals.decide(a, b === 'allow' || all);
+      const sessionId = askSessions.get(a);
+      if (sessionId) askSessions.delete(a);
+      if (all && sessionId) ctx.setAutoApprove?.(sessionId, true);
+      toast = all ? 'Permitidos todos' : b === 'allow' ? 'Permitido' : 'Denegado';
     } else if (kind === 'proj') {
       if (a === 'root') {
         await selectProject(chatId, projectRoot());
@@ -755,7 +861,7 @@ export function startTelegramChannel(
     notify(sessionId, event) {
       if (ownSessions.has(sessionId)) return;
 
-      // La tool `speak` entrega audio en vivo a un chat vinculado.
+      // Las tools `speak` y `screenshot` entregan en vivo a un chat vinculado.
       if (event.type === 'tool_call') {
         if (event.data?.name !== 'speak') return;
         const linked = ctx.store.getSetting(reverseKey(sessionId));
@@ -767,6 +873,12 @@ export function startTelegramChannel(
         }
         return;
       }
+      if (event.type === 'tool_result' && event.data?.name === 'screenshot') {
+        const linked = ctx.store.getSetting(reverseKey(sessionId));
+        const shot = event.data?.meta?.screenshot;
+        if (linked && shot?.name) enviarCaptura(linked, shot.name, shot.url);
+        return;
+      }
 
       const targets = notifyTargets(sessionId);
       if (!targets.length) return;
@@ -785,17 +897,10 @@ export function startTelegramChannel(
       } else if (event.type === 'permission' && notifyConfig.permission) {
         const askId = event.data?.askId;
         if (!askId) return;
+        if (event.data?.sessionId) askSessions.set(askId, event.data.sessionId);
+        const text = permissionMessage(project, event.data?.name ?? 'una tool', event.data?.args);
         for (const chatId of targets) {
-          send(chatId, `[${project}] ⚠ Permiso para ${event.data?.name ?? 'una tool'}`, {
-            reply_markup: {
-              inline_keyboard: [
-                [
-                  { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-                  { text: 'Denegar', callback_data: `perm:${askId}:deny` },
-                ],
-              ],
-            },
-          }).catch(() => {});
+          send(chatId, text, { reply_markup: permissionKeyboard(askId) }).catch(() => {});
         }
       }
     },

package/harness/packages/server/src/routes/files.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { readJson, sendJson, sendError } from '../lib/http.js';
-import { staticServerChip } from '../lib/core.js';
+import { staticServerChip, screenshotsDir } from '../lib/core.js';
 import { isInside, localOk, requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
 const MAX_PREVIEW = 200 * 1024;
@@ -144,4 +144,28 @@ export function registerFiles(route, ctx) {
       port: proc.port,
     });
   });
+
+  // Capturas del tool `screenshot`: viven en la casa, no en el workspace.
+  route('GET', '/api/screenshots/:name', ({ req, res, params }) => {
+    const local = localOk(req);
+    if (!local && !ctx.authEnabled) {
+      return sendError(res, 403, 'Las capturas solo están disponibles en conexiones locales.');
+    }
+    const name = String(params.name ?? '');
+    if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(name)) return sendError(res, 400, 'Nombre de captura inválido.');
+    const file = path.join(screenshotsDir(), name);
+    let info;
+    try {
+      info = fs.statSync(file);
+    } catch {
+      return sendError(res, 404, 'La captura no existe.');
+    }
+    if (!info.isFile()) return sendError(res, 404, 'La captura no existe.');
+    res.writeHead(200, { 'Content-Type': 'image/png', 'Content-Length': info.size, 'Cache-Control': 'no-store' });
+    if (req.method === 'HEAD') {
+      res.end();
+      return;
+    }
+    fs.createReadStream(file).pipe(res);
+  });
 }

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

@@ -6,7 +6,7 @@ import { mkdtemp, mkdir, writeFile, readFile, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { createTamnoraServer } from '../src/index.js';
-import { setHome, ensureApp, readApp, writeApp, makeUser } from '../../core/src/index.js';
+import { setHome, ensureApp, readApp, writeApp, makeUser, screenshotsDir } from '../../core/src/index.js';
 import { completionFooter } from '../src/lib/channels/telegram.js';
 
 const fakeProvider = {
@@ -1792,7 +1792,21 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read', 'speak', 'task']);
+    assert.deepEqual(captured.tools, [
+      'console_errors',
+      'fetch_url',
+      'git_diff',
+      'git_log',
+      'git_status',
+      'glob',
+      'grep',
+      'list',
+      'preview_url',
+      'read',
+      'screenshot',
+      'speak',
+      'task',
+    ]);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();
@@ -2026,16 +2040,38 @@ test('truncates a session from a message id', async () => {
     const firstId = detail.messages[0].id;
     assert.ok(firstId);
 
-    const res = await fetch(`${base}/api/sessions/${sessionId}/truncate`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ fromId: firstId }),
-    });
-    assert.equal(res.status, 200);
-
-    detail = await (await fetch(`${base}/api/sessions/${sessionId}`)).json();
-    assert.equal(detail.messages.length, 0);
-  } finally {
-    await instance.close();
-  }
+    const res = await fetch(`${base}/api/sessions/${sessionId}/truncate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ fromId: firstId }),
+    });
+    assert.equal(res.status, 200);
+
+    detail = await (await fetch(`${base}/api/sessions/${sessionId}`)).json();
+    assert.equal(detail.messages.length, 0);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('serves browser screenshots from the home dir, confined to png names', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-shots-'));
+  const { instance, base } = await startServer({ cwd });
+  try {
+    const dir = screenshotsDir();
+    await mkdir(dir, { recursive: true });
+    const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    await writeFile(path.join(dir, 'abc-123.png'), png);
+
+    const ok = await fetch(`${base}/api/screenshots/abc-123.png`);
+    assert.equal(ok.status, 200);
+    assert.equal(ok.headers.get('content-type'), 'image/png');
+    assert.equal((await ok.arrayBuffer()).byteLength, png.length);
+
+    assert.equal((await fetch(`${base}/api/screenshots/bad.txt`)).status, 400);
+    assert.equal((await fetch(`${base}/api/screenshots/missing.png`)).status, 404);
+  } finally {
+    await instance.close();
+  }
 });
+

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

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { Store } from '../../core/src/index.js';
 import { createApprovalBroker } from '../src/lib/approvals.js';
 import { createPresence } from '../src/lib/presence.js';
-import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+import { startTelegramChannel, describePermission } from '../src/lib/channels/telegram.js';
 
 const reply = (data) => ({ ok: true, json: async () => data });
 
@@ -227,15 +227,36 @@ test('notify de permiso incluye el proyecto y los botones', async () => {
     log: () => {},
   });
   try {
-    channel.notify(sessionId, { type: 'permission', data: { askId: 'ask-1', name: 'bash' } });
-    await waitFor(() => mock.sent.some((m) => /Permiso para bash/.test(m.text ?? '')));
-    const msg = mock.sent.find((m) => /Permiso para bash/.test(m.text ?? ''));
+    channel.notify(sessionId, {
+      type: 'permission',
+      data: { askId: 'ask-1', sessionId, name: 'bash', args: { command: 'npm test' } },
+    });
+    await waitFor(() => mock.sent.some((m) => /Permiso:/.test(m.text ?? '')));
+    const msg = mock.sent.find((m) => /Permiso:/.test(m.text ?? ''));
     assert.match(msg.text, new RegExp(`\\[${path.basename(cwd)}\\]`));
+    assert.match(msg.text, /ejecutar un comando/);
+    assert.match(msg.text, /npm test/);
     const datas = msg.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
     assert.ok(datas.includes('perm:ask-1:allow'));
+    assert.ok(datas.includes('perm:ask-1:all'));
+    assert.ok(datas.includes('perm:ask-1:deny'));
   } finally {
     channel.stop();
     mock.restore();
     ctx.store.close();
   }
 });
+
+test('describePermission explica la accion sin volcar el JSON', () => {
+  assert.deepEqual(describePermission('bash', { command: 'npm test' }), {
+    action: 'ejecutar un comando en el proyecto',
+    detail: 'npm test',
+  });
+  const write = describePermission('write', { path: 'nota.txt', content: 'hola mundo' });
+  assert.match(write.action, /escribir el archivo nota\.txt/);
+  assert.match(write.detail, /Contenido: 10 B/);
+  assert.doesNotMatch(write.detail, /hola mundo/);
+  assert.match(describePermission('edit', { path: 'a.js', oldString: 'const a = 1;' }).detail, /const a = 1;/);
+  assert.match(describePermission('screenshot', { url: 'http://127.0.0.1:5173' }).detail, /127\.0\.0\.1/);
+  assert.match(describePermission('desconocida', { x: 1 }).action, /desconocida/);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "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",