@danieltmn/tamnora 0.9.3 → 0.9.5

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

@@ -17,6 +17,7 @@ import {
   toolResultPayload,
 } from '../lib/agentRun.js';
 import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
+import { resolveAdvisor, advisorShouldRun, consultAdvisor } from '../lib/advisor.js';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -318,6 +319,35 @@ export function registerChat(route, ctx) {
             durationMs,
             say: fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }),
           });
+
+        // El asesor va despues del `done` pero antes del `finally`, asi el run
+        // sigue vivo y el evento llega/persiste. Puede quedarse callado.
+        const advisorOptions = resolveAdvisor(ctx.app);
+        if (
+          result.stopReason !== 'aborted' &&
+          advisorOptions.enabled &&
+          advisorShouldRun({ toolCalls, answer: result.content })
+        ) {
+          const advice = await consultAdvisor({
+            provider,
+            config,
+            model,
+            signal: ctx.runs.signal(sessionId),
+            userInput: input,
+            answer: result.content,
+            messages: newMessages,
+            options: advisorOptions,
+          });
+          if (advice?.speak) {
+            ctx.store.addMessage(sessionId, {
+              role: 'assistant',
+              name: 'advisor',
+              content: advice.text,
+              mode: advice.kind,
+            });
+            ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
+          }
+        }
       } catch (error) {
         partials.flush();
         if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', { say: fraseFin({ stopReason: 'aborted' }) });

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/src/routes/tts.js

@@ -39,7 +39,7 @@ export function registerTts(route, ctx) {
     if ('rate' in body) next.rate = sanearRate(body.rate, actual.rate);
     if (body.announce && typeof body.announce === 'object') {
       const announce = { ...actual.announce };
-      for (const key of ['start', 'tools', 'end']) {
+      for (const key of ['start', 'tools', 'end', 'advice', 'answer']) {
         if (key in body.announce) announce[key] = body.announce[key] === true;
       }
       next.announce = announce;

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

@@ -0,0 +1,43 @@
+// Alerta de version nueva y actualizacion con un click desde la consola.
+//
+// `GET /api/update` es solo informacion (cacheada). `POST /api/update` es
+// privilegiado: **solo loopback y sin tunel** (`requireLocal`), igual que
+// shell/git/carpetas. El server responde y se apaga; un script detached espera
+// su muerte, instala la version nueva y lo vuelve a levantar.
+
+import { sendJson, sendError } from '../lib/http.js';
+import { requireLocal } from '../lib/workspace.js';
+import { checkUpdate, spawnSelfUpdate } from '../lib/update.js';
+
+export function registerUpdate(route, ctx) {
+  route('GET', '/api/update', async ({ res, query }) => {
+    const force = query.get('force') === '1';
+    sendJson(res, 200, await checkUpdate({ force }));
+  });
+
+  route('POST', '/api/update', async ({ req, res }) => {
+    if (!requireLocal(req, res, 'Actualizar solo esta permitido en la conexion local.')) return;
+
+    const info = await checkUpdate({ force: true });
+    if (!info.latest) return sendError(res, 502, info.error || 'No pude consultar la ultima version.');
+    if (!info.updateAvailable) {
+      return sendJson(res, 200, { ok: true, upToDate: true, current: info.current, latest: info.latest });
+    }
+
+    const spawnUpdater = ctx.spawnUpdater ?? spawnSelfUpdate;
+    const started = spawnUpdater({
+      pid: process.pid,
+      port: ctx.serverInfo?.port,
+      host: ctx.serverInfo?.host,
+      cwd: ctx.cwd,
+      target: info.latest,
+    });
+    if (!started.ok) return sendError(res, 500, started.error);
+
+    sendJson(res, 202, { ok: true, updating: true, from: info.current, to: info.latest });
+    // Soltar los archivos antes de que npm los reemplace.
+    setTimeout(() => {
+      Promise.resolve(ctx.shutdown?.()).catch(() => process.exit(0));
+    }, 800);
+  });
+}

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

@@ -39,6 +39,8 @@ import { registerChannels } from './routes/channels.js';
 import { registerProfile } from './routes/profile.js';
 import { registerTts } from './routes/tts.js';
 import { registerTranscribe } from './routes/transcribe.js';
+import { registerUpdate } from './routes/update.js';
+import { registerAdvisor } from './routes/advisor.js';
 import { registerProcs } from './routes/procs.js';
 import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
@@ -186,6 +188,13 @@ export async function createTamnoraServer({
     mergedMcpServers,
     procs,
     procsEnabled,
+    // Se completa en `listen()` con el puerto/host reales (util para reiniciar
+    // el server tras una actualizacion).
+    serverInfo: {
+      port: port ?? config.server?.port ?? 4517,
+      host: host ?? config.server?.host ?? '127.0.0.1',
+      url: '',
+    },
   };
 
   ctx.systemPromptFor = createPromptBuilder({
@@ -234,6 +243,8 @@ export async function createTamnoraServer({
   registerProfile(route, ctx);
   registerTts(route, ctx);
   registerTranscribe(route, ctx);
+  registerAdvisor(route, ctx);
+  registerUpdate(route, ctx);
   registerProcs(route, ctx);
   registerShell(route, ctx);
   const preview = registerPreview(route, ctx);
@@ -320,11 +331,13 @@ export async function createTamnoraServer({
         options.host ?? host ?? config.server?.host ?? '127.0.0.1',
         () => {
           const address = server.address();
-          resolve({
+          const info = {
             host: address.address,
             port: address.port,
             url: `http://${address.address === '::' ? '127.0.0.1' : address.address}:${address.port}`,
-          });
+          };
+          ctx.serverInfo = info;
+          resolve(info);
         }
       );
     });
@@ -354,5 +367,16 @@ export async function createTamnoraServer({
     }
   };
 
+  // Apagado ordenado pedido desde una ruta (actualizacion con un click): cierra
+  // el server y termina el proceso para que npm pueda reemplazar los archivos.
+  ctx.shutdown = async () => {
+    try {
+      await close();
+    } catch {
+      /* ya cerrado */
+    }
+    process.exit(0);
+  };
+
   return { server, config, store, ctx, listen, close, staticDir: staticDir ?? DEFAULT_PUBLIC_DIR };
 }

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

@@ -0,0 +1,205 @@
+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 {
+  resolveAdvisor,
+  advisorShouldRun,
+  collectChangedFiles,
+  collectToolSummary,
+  buildAdvisorPrompt,
+  consultAdvisor,
+} from '../src/lib/advisor.js';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+
+const editMessages = () => [
+  {
+    role: 'assistant',
+    content: '',
+    tool_calls: [
+      { id: 'c1', function: { name: 'edit', arguments: JSON.stringify({ path: 'src/a.js' }) } },
+    ],
+  },
+  { role: 'tool', tool_call_id: 'c1', name: 'edit', content: '- const token = "secreto"\n+ const token = process.env.TOKEN' },
+];
+
+test('resolveAdvisor mezcla defaults y sanitiza', () => {
+  assert.equal(resolveAdvisor({}).enabled, false);
+  const saved = resolveAdvisor({ advisor: { enabled: true, notes: 'x', maxWords: 999 } });
+  assert.equal(saved.enabled, true);
+  assert.equal(saved.code, true);
+  assert.equal(saved.maxWords, 120);
+  const off = resolveAdvisor({ advisor: { code: false, explain: false, advice: false, maxWords: 5 } });
+  assert.equal(off.maxWords, 10);
+  assert.equal(off.code, false);
+});
+
+test('advisorShouldRun exige tools o respuesta larga', () => {
+  assert.equal(advisorShouldRun({ toolCalls: 0, answer: 'corto' }), false);
+  assert.equal(advisorShouldRun({ toolCalls: 1, answer: '' }), true);
+  assert.equal(advisorShouldRun({ toolCalls: 0, answer: 'x'.repeat(201) }), true);
+});
+
+test('collectChangedFiles arma path + diff de write/edit', () => {
+  const files = collectChangedFiles(editMessages());
+  assert.equal(files.length, 1);
+  assert.equal(files[0].path, 'src/a.js');
+  assert.match(files[0].diff, /secreto/);
+});
+
+test('collectToolSummary lista las tools del turno', () => {
+  const summary = collectToolSummary(editMessages());
+  assert.equal(summary.length, 1);
+  assert.match(summary[0], /^edit:/);
+});
+
+test('buildAdvisorPrompt respeta los toggles y las notas', () => {
+  const { system, user } = buildAdvisorPrompt({
+    userInput: 'hola',
+    answer: 'listo',
+    toolSummary: ['edit: src/a.js'],
+    changedFiles: [{ path: 'src/a.js', diff: '- x\n+ y' }],
+    options: { code: false, explain: true, advice: true, notes: 'avisame de secretos', maxWords: 20 },
+  });
+  assert.doesNotMatch(system, /problema real en el codigo/);
+  assert.match(system, /explicar un proceso/);
+  assert.match(system, /avisame de secretos/);
+  assert.match(user, /PEDIDO DEL USUARIO/);
+  assert.match(user, /src\/a\.js/);
+});
+
+const fakeProvider = (content) => ({ streamChat: async () => ({ content }) });
+
+test('consultAdvisor interpreta speak:true', async () => {
+  const advice = await consultAdvisor({
+    provider: fakeProvider('{"speak":true,"kind":"code","text":"Ojo con el token en src/a.js."}'),
+    config: {},
+    model: 'x',
+    messages: editMessages(),
+    options: { code: true, explain: true, advice: true, maxWords: 40 },
+  });
+  assert.equal(advice.speak, true);
+  assert.equal(advice.kind, 'code');
+  assert.match(advice.text, /token/);
+});
+
+test('consultAdvisor respeta speak:false, JSON invalido y errores', async () => {
+  const off = await consultAdvisor({
+    provider: fakeProvider('{"speak":false,"text":""}'),
+    config: {},
+    model: 'x',
+    messages: [],
+    options: {},
+  });
+  assert.equal(off.speak, false);
+  assert.equal(
+    await consultAdvisor({ provider: fakeProvider('no json'), config: {}, model: 'x', messages: [], options: {} }),
+    null
+  );
+  const boom = {
+    streamChat: async () => {
+      throw new Error('boom');
+    },
+  };
+  assert.equal(await consultAdvisor({ provider: boom, config: {}, model: 'x', messages: [], options: {} }), null);
+});
+
+test('consultAdvisor recorta a maxWords', async () => {
+  const long = 'palabra '.repeat(50).trim();
+  const advice = await consultAdvisor({
+    provider: fakeProvider(JSON.stringify({ speak: true, kind: 'advice', text: long })),
+    config: {},
+    model: 'x',
+    messages: [],
+    options: { maxWords: 10, code: true, explain: true, advice: true },
+  });
+  assert.ok(advice.text.split(' ').length <= 11);
+  assert.match(advice.text, /…$/);
+});
+
+test('GET/PUT /api/advisor/settings y POST /api/advisor/test con proveedor inyectado', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-advisor-'));
+  setHome(cwd);
+  let reply = '{"speak":true,"kind":"code","text":"Cuidado con el secreto."}';
+  const provider = { streamChat: async () => ({ content: reply }) };
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  instance.ctx.store.setSetting('activeProvider', 'fake');
+  instance.ctx.store.setSetting('activeModel', 'test-model');
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const initial = await (await fetch(`${base}/api/advisor/settings`)).json();
+    assert.equal(initial.enabled, false);
+
+    const put = await fetch(`${base}/api/advisor/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: true, code: false, maxWords: 500 }),
+    });
+    const saved = await put.json();
+    assert.equal(saved.enabled, true);
+    assert.equal(saved.code, false);
+    assert.equal(saved.maxWords, 120);
+
+    const on = await (await fetch(`${base}/api/advisor/test`, { method: 'POST' })).json();
+    assert.equal(on.speak, true);
+    assert.match(on.text, /secreto/);
+
+    reply = '{"speak":false,"text":""}';
+    const off = await (await fetch(`${base}/api/advisor/test`, { method: 'POST' })).json();
+    assert.equal(off.speak, false);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('el asesor emite el evento advice al cerrar el turno', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-advice-'));
+  setHome(cwd);
+  let calls = 0;
+  const provider = {
+    id: 'fake',
+    streamChat: async (_config, { onEvent } = {}) => {
+      calls += 1;
+      if (calls === 1) {
+        const text = `Listo. ${'x'.repeat(220)}`;
+        onEvent?.({ type: 'text', delta: text, full: text });
+        return { content: text, reasoning: '', toolCalls: [] };
+      }
+      return { content: '{"speak":true,"kind":"code","text":"Cuidado con el token."}', reasoning: '', toolCalls: [] };
+    },
+  };
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  instance.ctx.app = {
+    ...instance.ctx.app,
+    advisor: { enabled: true, code: true, explain: true, advice: true, notes: '', maxWords: 40 },
+  };
+  instance.ctx.store.setSetting('activeProvider', 'fake');
+  instance.ctx.store.setSetting('activeModel', 'test-model');
+  const info = await instance.listen({ port: 0 });
+  try {
+    const res = await fetch(`${info.url}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'quién soy', model: 'test-model', provider: 'fake' }),
+    });
+    const body = await res.text();
+    assert.equal(calls, 2);
+    assert.match(body, /event: advice/);
+    assert.match(body, /Cuidado con el token/);
+  } finally {
+    await instance.close();
+  }
+});

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

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { renderMarkdown, highlight } from '../public/markdown.js';
+import { renderMarkdown, highlight, speechText } from '../public/markdown.js';
 
 test('escapes raw HTML from model output', () => {
   const html = renderMarkdown('<script>alert(1)</script>');
@@ -67,3 +67,45 @@ test('a lone pipe line without a delimiter row stays a paragraph', () => {
 test('highlight escapes code content', () => {
   assert.equal(highlight('a < b', 'bash'), 'a &lt; b');
 });
+
+test('speechText saca bloques de codigo y tablas', () => {
+  const md = [
+    'Te dejo el resumen.',
+    '',
+    '```js',
+    'const x = 1;',
+    '```',
+    '',
+    'Y una tabla:',
+    '',
+    '| a | b |',
+    '| - | - |',
+    '| 1 | 2 |',
+    '',
+    'Fin.',
+  ].join('\n');
+  const spoken = speechText(md);
+  assert.doesNotMatch(spoken, /const x/);
+  assert.doesNotMatch(spoken, /1 \| 2/);
+  assert.match(spoken, /Te dejo el resumen\./);
+  assert.match(spoken, /Fin\./);
+});
+
+test('speechText limpia marcas de markdown y aplasta espacios', () => {
+  const spoken = speechText('# Título\n\n**Nombre:** Daniel\n\n- uno\n- dos');
+  assert.equal(spoken, 'Título Nombre: Daniel uno dos');
+});
+
+test('speechText mantiene el texto de inline code', () => {
+  assert.equal(speechText('Corré `npm test` y listo.'), 'Corré npm test y listo.');
+});
+
+test('speechText recorta en un limite con maxChars', () => {
+  const spoken = speechText(`${'hola '.repeat(40)}`, { maxChars: 50 });
+  assert.ok(spoken.length <= 51);
+  assert.match(spoken, /…$/);
+});
+
+test('speechText devuelve vacio si solo hay codigo', () => {
+  assert.equal(speechText('```\nsolo codigo\n```'), '');
+});

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/);
+});