@danieltmn/tamnora 0.9.2 → 0.9.4

package/CHANGELOG.md

@@ -5,6 +5,19 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.9.4] - 2026-10-07
+
+### Cambios
+
+- feat: navegador headless (screenshot/console_errors) y permisos de Telegram
+
+## [0.9.3] - 2026-10-07
+
+### Cambios
+
+- feat(telegram): audio solo cuando el usuario lo pide
+- feat: diff lado a lado en TUI, proveedores Anthropic/Gemini y mejoras de consola
+
 ## [0.9.2] - 2026-10-07
 
 ### Cambios

package/README.md

@@ -5,8 +5,13 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
 
 - **Sin dependencias**: solo modulos de Node (`node:sqlite`, `node:crypto`, ...).
 - **Local**: corre en tu maquina y guarda el estado en tu casa local.
-- **Multi-proveedor**: OpenRouter, OpenAI, proveedores compatibles (DeepSeek,
-  Groq, Mistral, xAI, Together, Fireworks, Cerebras, Perplexity) y Ollama.
+- **Multi-proveedor**: OpenRouter, OpenAI, Anthropic (Claude), Google Gemini,
+  proveedores compatibles (DeepSeek, Groq, Mistral, xAI, Together, Fireworks,
+  Cerebras, Perplexity) y Ollama.
+- **Navegador headless**: tools `screenshot` y `console_errors` (renderiza JS y
+  saca una captura PNG o lista los errores de consola) y `preview_url`.
+- **Voz**: el agente narra su progreso y puede mandar audio bajo pedido
+  (`speak`, `/audioresumen`).
 
 ## Instalacion
 
@@ -39,7 +44,8 @@ tamnora tui --mode plan   # modo plan: solo lectura, sin escritura ni bash
 Atajos: `enter` enviar · `↑/↓` historial · `←/→` cursor · `home/end` inicio/fin ·
 `pgup/pgdn` scroll · `ctrl+l` limpiar · `ctrl+c` cancelar/salir · `/salir`,
 `/limpiar`. El pegado de bloques multilinea entra como un solo texto y el header
-muestra el contexto usado (`ctx <tokens>`).
+muestra el contexto usado (`ctx <tokens>`). Las tools `write`/`edit` muestran un
+**diff lado a lado** (viejo en rojo, nuevo en verde, con numeros de linea).
 
 ### Server como servicio
 
@@ -91,6 +97,11 @@ menu "mas" (los tres puntitos). En el chat:
 - **Runs durables**: cerrar el celular o cortar la red **no cancela** el turno; al
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
   el boton de detener (o `POST /api/sessions/:id/stop`).
+- **Audio**: un unico reproductor encola la narracion, el tool `speak` y
+  `/audioresumen`, y reproduce de a uno con pausa y detener.
+- **Comandos**: el input muestra un menu al escribir `/` (`/new`, `/init`, `/goal`,
+  `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/kill`, `/help`).
+- **Capturas**: el tool `screenshot` muestra la imagen inline en su tarjeta.
 
 ### Preview
 
@@ -136,10 +147,15 @@ Con un token de bot (`telegram.token` en `tamnora.json`, `app.json` o
 `TAMNORA_TELEGRAM_TOKEN`) podes manejar el harness desde el chat. Cada chat mapea
 a una sesion y el bot soporta:
 
-- texto, **imagenes** y **notas de voz** (transcripcion con `telegram.transcribeModel`,
-  default `whisper-1`, via `POST {baseUrl}/audio/transcriptions`);
-- aprobaciones `ask` con **botones inline** (permitir/denegar);
-- comandos `/new`, `/status`, `/model`, `/provider`, `/mode`, `/stop`, `/help`;
+- texto, **imagenes** (entrantes y salientes: el tool `screenshot` llega como foto)
+  y **notas de voz** (transcripcion con `telegram.transcribeModel`, default
+  `whisper-1`, via `POST {baseUrl}/audio/transcriptions`);
+- aprobaciones `ask` con **botones inline** y una explicacion de lo que va a hacer
+  el agente (`Permitir` / `Permitir todo` / `Denegar`); "Permitir todo" deja de
+  preguntar por el resto de la sesion;
+- el bot **solo manda audio cuando lo pedis** (tool `speak` o `/audioresumen`);
+- comandos `/new`, `/resumen`, `/audioresumen`, `/status`, `/model`, `/provider`,
+  `/mode`, `/stop`, `/help`;
 - **notificaciones**: si un run de la consola pertenece a una sesion vinculada a un
   chat, el canal avisa el fin, los errores, los subagentes y los permisos.
 
@@ -161,11 +177,15 @@ entorno completo, `"inheritEnv": true`.
 ## Tools
 
 Tools locales confinadas al workspace (`read`, `list`, `glob`, `grep`, `write`,
-`edit`, `bash`, `fetch_url`) y de Git (`git_status`, `git_diff`, `git_log`,
+`edit`, `bash`, `fetch_url`), de navegador (`screenshot`, `console_errors`,
+`preview_url`), de voz (`speak`) y de Git (`git_status`, `git_diff`, `git_log`,
 `git_commit`), con permisos `allow`/`ask`/`deny` por tool o por patron.
+
 `fetch_url` lee URLs (HTML a texto) y avisa cuando un sitio exige JavaScript o
-esta detras de Cloudflare; para esos casos, registra un MCP de navegador (por
-ejemplo Playwright).
+esta detras de Cloudflare; para esos casos las tools `screenshot` / `console_errors`
+usan el **Chrome/Edge/Chromium del sistema** como navegador headless (sin
+dependencias): sacan una captura PNG y recolectan los errores de consola. Para
+automatizacion mas completa, registra un MCP (por ejemplo Playwright).
 
 ## Subagentes
 

package/harness/packages/cli/src/tui/app.js

@@ -1,7 +1,8 @@
 // Full-screen terminal console (opencode/codex-like), zero dependencies.
 // Alt-screen + raw input + incremental rendering; reuses the harness engine.
 
-import { createTools } from '../lib/core.js';
+import { readFileSync } from 'node:fs';
+import { createTools, diffRows, resolveInRoot } from '../lib/core.js';
 import { runTurn } from '../lib/runtime.js';
 import { parseKeys } from './keys.js';
 import { render } from './layout.js';
@@ -67,6 +68,15 @@ export function runTui({
     tools: [],
   });
 
+  const readWorkspaceFile = (rel) => {
+    if (!rel) return '';
+    try {
+      return readFileSync(resolveInRoot(toolOptions.root, rel), 'utf8');
+    } catch {
+      return '';
+    }
+  };
+
   const onAsk = (name, args) =>
     new Promise((resolve) => {
       state.pendingAsk = { name, detail: args?.command ?? args?.path ?? '', resolve };
@@ -186,10 +196,19 @@ export function runTui({
           } else if (event.type === 'stall') {
             if (!sawText) assistant.text = `⚠ ${event.seconds} s sin respuesta del modelo (proveedor caído o muy lento). Sigo esperando...`;
           } else if (event.type === 'tool_call') {
-            assistant.tools.push({ name: event.name, args: JSON.stringify(event.args) });
+            const tool = { name: event.name, args: JSON.stringify(event.args), path: event.args?.path };
+            if (event.name === 'write' || event.name === 'edit') {
+              tool.oldContent = readWorkspaceFile(event.args?.path);
+            }
+            assistant.tools.push(tool);
           } else if (event.type === 'tool_result') {
             const tool = assistant.tools[assistant.tools.length - 1];
-            if (tool) tool.result = String(event.result).slice(0, 2000);
+            if (tool) {
+              tool.result = String(event.result).slice(0, 2000);
+              if (tool.oldContent !== undefined) {
+                tool.diff = diffRows(tool.oldContent, readWorkspaceFile(tool.path), { maxRows: 400 });
+              }
+            }
           }
           draw();
         },

package/harness/packages/cli/src/tui/layout.js

@@ -48,6 +48,53 @@ function clip(text, width) {
   return arr.length <= width ? text : arr.slice(0, width).join('');
 }
 
+function sanitize(text) {
+  return String(text ?? '').replace(/\t/g, '    ');
+}
+
+// Una columna del diff: numero de linea dim y contenido rojo (viejo) / verde
+// (nuevo) / normal (contexto). Devuelve texto con ANSI ya resuelto (raw).
+function diffSide(cell, kind, numW, contentW) {
+  if (!cell) return color.dim(' '.repeat(numW + 3 + contentW));
+  const num = String(cell.no).padStart(numW);
+  const text = clip(sanitize(cell.text), contentW);
+  const pad = ' '.repeat(Math.max(0, contentW - chars(text).length));
+  const sign = kind === 'del' ? '-' : kind === 'add' ? '+' : ' ';
+  const paint = kind === 'del' ? color.red : kind === 'add' ? color.green : (t) => t;
+  return color.dim(`${num} `) + paint(`${sign} ${text}`) + pad;
+}
+
+// Arma las lineas del diff lado a lado. Devuelve null si el ancho es muy chico
+// (en ese caso el que llama cae al diff de una sola columna).
+function buildDiff(diff, width) {
+  const indent = 2;
+  const mid = ' │ ';
+  const maxNo = diff.reduce((m, row) => Math.max(m, row.left?.no ?? 0, row.right?.no ?? 0), 1);
+  const numW = Math.max(3, String(maxNo).length);
+  const colW = Math.floor((width - indent - mid.length) / 2);
+  const contentW = colW - numW - 3;
+  if (contentW < 6) return null;
+
+  const out = [];
+  for (const row of diff) {
+    if (row.type === 'skip') {
+      out.push({ text: `${' '.repeat(indent)}${color.dim('…')}`, raw: true });
+      continue;
+    }
+    const leftKind = row.type === 'add' ? 'blank' : row.type === 'ctx' ? 'ctx' : 'del';
+    const rightKind = row.type === 'del' ? 'blank' : row.type === 'ctx' ? 'ctx' : 'add';
+    const line =
+      ' '.repeat(indent) +
+      diffSide(row.left, leftKind, numW, contentW) +
+      color.dim(mid) +
+      diffSide(row.right, rightKind, numW, contentW);
+    out.push({ text: line, raw: true });
+  }
+  return out;
+}
+
+const TOOL_LABELS = { write: 'Write', edit: 'Edit' };
+
 function buildBody(state, width) {
   const out = [];
   for (const message of state.messages) {
@@ -62,6 +109,12 @@ function buildBody(state, width) {
       for (const line of wrapText(message.text, width - 2)) out.push({ text: `  ${line}`, style: 'assistant' });
     }
     for (const tool of message.tools ?? []) {
+      const diff = tool.diff?.length ? buildDiff(tool.diff, width) : null;
+      if (diff) {
+        out.push({ text: `  ✎ ${TOOL_LABELS[tool.name] ?? tool.name} ${tool.path ?? ''}`.trimEnd(), style: 'tool' });
+        out.push(...diff);
+        continue;
+      }
       out.push({ text: `  ⚙ ${tool.name} ${clip(tool.args ?? '', width - 8)}`, style: 'tool' });
       if (tool.result !== undefined) {
         for (const line of wrapText(tool.result, width - 6)) out.push({ text: `    → ${line}`, style: 'dim' });
@@ -121,8 +174,12 @@ export function render(state, { cols = 80, rows = 24 } = {}) {
   const parts = [];
   for (let i = 0; i < rows; i++) {
     const entry = lines[i] ?? { text: '', style: 'dim' };
-    const style = THEME[entry.style] ?? THEME.assistant;
-    parts.push(moveTo(i + 1, 1), '\x1b[2K', style(clip(entry.text, width)));
+    parts.push(moveTo(i + 1, 1), '\x1b[2K');
+    if (entry.raw) parts.push(entry.text);
+    else {
+      const style = THEME[entry.style] ?? THEME.assistant;
+      parts.push(style(clip(entry.text, width)));
+    }
   }
 
   const cursorCol = state.pendingAsk ? 2 : Math.min(width, chars(`  ❯ ${before}`).length + 1);

package/harness/packages/cli/test/tui.test.js

@@ -81,6 +81,36 @@ test('render places the cursor at inputCursor', () => {
   assert.equal(cursor.col, 6);
 });
 
+test('render shows a side-by-side diff for write/edit', () => {
+  const state = {
+    header: { provider: 'p', model: 'm', cwd: '/x' },
+    messages: [
+      {
+        role: 'assistant',
+        text: '',
+        tools: [
+          {
+            name: 'edit',
+            args: '{"path":"a.js"}',
+            path: 'a.js',
+            diff: [
+              { type: 'ctx', left: { no: 1, text: 'const a = 1;' }, right: { no: 1, text: 'const a = 1;' } },
+              { type: 'mod', left: { no: 2, text: 'const b = 2;' }, right: { no: 2, text: 'const b = 3;' } },
+            ],
+          },
+        ],
+      },
+    ],
+    input: '',
+    streaming: false,
+    pendingAsk: null,
+  };
+  const { frame } = render(state, { cols: 80, rows: 20 });
+  assert.match(frame, /Edit a\.js/);
+  assert.match(frame, /const b = 2;/);
+  assert.match(frame, /const b = 3;/);
+});
+
 test('render scrolls the viewport', () => {
   const messages = Array.from({ length: 40 }, (_, i) => ({ role: 'assistant', text: `linea ${i}`, tools: [] }));
   const base = { header: { provider: 'p', model: 'm', cwd: '/x' }, input: '', streaming: false, pendingAsk: null };

package/harness/packages/core/src/agent/modes.js

@@ -13,7 +13,20 @@ export const MODES = {
     id: 'plan',
     label: 'Plan',
     description: 'Solo lectura: investiga y propone un plan, sin modificar nada.',
-    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'speak', 'git_status', 'git_diff', 'git_log'],
+    tools: [
+      'read',
+      'list',
+      'glob',
+      'grep',
+      'fetch_url',
+      'speak',
+      'screenshot',
+      'console_errors',
+      'preview_url',
+      'git_status',
+      'git_diff',
+      'git_log',
+    ],
     systemPrompt:
       'Estás en modo PLAN: no modifiques archivos ni ejecutes comandos. Investigá el proyecto con las herramientas de solo lectura y respondé con un plan concreto y accionable.',
   },

package/harness/packages/core/src/agent/runAgent.js

@@ -215,12 +215,19 @@ export async function runAgent({
         }
       }
 
-      onEvent?.({ type: 'tool_result', id: call.id, name, result: output });
+      const normalized = normalizeToolOutput(output);
+      onEvent?.({
+        type: 'tool_result',
+        id: call.id,
+        name,
+        result: normalized.content,
+        meta: normalized.meta,
+      });
       working.push({
         role: 'tool',
         tool_call_id: call.id,
         name,
-        content: typeof output === 'string' ? output : JSON.stringify(output),
+        content: normalized.content,
       });
     }
 
@@ -315,6 +322,20 @@ function createStallGuard(onEvent, stallWarnMs) {
   };
 }
 
+/**
+ * Normaliza el resultado de un tool a `{ content, meta }`. Un executor puede
+ * devolver un string (lo normal) o `{ content, meta }` cuando necesita mandar
+ * metadata al cliente sin ensuciar lo que ve el modelo (p. ej. una captura).
+ */
+export function normalizeToolOutput(output) {
+  if (typeof output === 'string') return { content: output };
+  if (output && typeof output === 'object' && typeof output.content === 'string') {
+    return { content: output.content, meta: output.meta };
+  }
+  if (output == null) return { content: '' };
+  return { content: JSON.stringify(output) };
+}
+
 async function defaultExecute(name) {
   return `Error: la herramienta "${name}" no está disponible todavía (se agrega en la Fase 1).`;
 }

package/harness/packages/core/src/browser/index.js

@@ -0,0 +1,289 @@
+// Navegador headless sin dependencias: usa el Chrome/Edge/Chromium del sistema y
+// lo maneja por el protocolo DevTools (CDP) sobre el WebSocket global de Node
+// 22+ (el mismo recurso que usa el cliente de TTS de Edge). Permite sacar una
+// captura de una pagina y leer los errores de consola, que es lo que un
+// `fetch_url` (GET crudo, sin JS) no puede hacer.
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+const LAUNCH_TIMEOUT_MS = 15000;
+
+function winPaths() {
+  const roots = [process.env['ProgramFiles'], process.env['ProgramFiles(x86)'], process.env.LOCALAPPDATA].filter(Boolean);
+  const out = [];
+  for (const root of roots) {
+    out.push(path.join(root, 'Google', 'Chrome', 'Application', 'chrome.exe'));
+    out.push(path.join(root, 'Microsoft', 'Edge', 'Application', 'msedge.exe'));
+  }
+  return out;
+}
+
+const CANDIDATES = {
+  win32: winPaths(),
+  darwin: [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  ],
+  linux: [
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+    '/usr/bin/microsoft-edge',
+    '/snap/bin/chromium',
+  ],
+};
+
+/** Ruta al navegador headless, o null. `TAMNORA_BROWSER` la forca. */
+export function findBrowserPath() {
+  const override = process.env.TAMNORA_BROWSER;
+  if (override && existsSync(override)) return override;
+  for (const candidate of CANDIDATES[process.platform] ?? []) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function launchBrowser(bin) {
+  return new Promise((resolve, reject) => {
+    const profile = mkdtempSync(path.join(tmpdir(), 'tamnora-browser-'));
+    const args = [
+      '--headless=new',
+      '--disable-gpu',
+      '--hide-scrollbars',
+      '--no-first-run',
+      '--no-default-browser-check',
+      '--disable-extensions',
+      '--disable-background-networking',
+      '--remote-debugging-port=0',
+      `--user-data-dir=${profile}`,
+      'about:blank',
+    ];
+    let child;
+    try {
+      child = spawn(bin, args, { stdio: ['ignore', 'ignore', 'pipe'], windowsHide: true });
+    } catch (error) {
+      reject(new Error(`no se pudo ejecutar el navegador: ${error.message}`));
+      return;
+    }
+
+    let settled = false;
+    let stderr = '';
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const timer = setTimeout(
+      () => finish(() => reject(new Error('el navegador no arrancó (timeout de DevTools)'))),
+      LAUNCH_TIMEOUT_MS
+    );
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+      const match = /DevTools listening on (ws:\/\/\S+)/.exec(stderr);
+      if (match) finish(() => resolve({ child, wsUrl: match[1], profile }));
+    });
+    child.on('error', (error) => finish(() => reject(new Error(`no se pudo ejecutar el navegador: ${error.message}`))));
+    child.on('exit', () => finish(() => reject(new Error('el navegador se cerró antes de estar listo'))));
+  });
+}
+
+class CdpConnection {
+  constructor(ws) {
+    this.ws = ws;
+    this.seq = 0;
+    this.pending = new Map();
+    this.listeners = new Set();
+    ws.addEventListener('message', (event) => {
+      let message;
+      try {
+        message = JSON.parse(typeof event.data === 'string' ? event.data : String(event.data));
+      } catch {
+        return;
+      }
+      if (message.id && this.pending.has(message.id)) {
+        const { resolve, reject } = this.pending.get(message.id);
+        this.pending.delete(message.id);
+        if (message.error) reject(new Error(message.error.message || 'error de CDP'));
+        else resolve(message.result ?? {});
+      } else {
+        for (const listener of this.listeners) listener(message);
+      }
+    });
+  }
+
+  open() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('timeout conectando al navegador')), 10000);
+      this.ws.addEventListener('open', () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+      this.ws.addEventListener('error', () => {
+        clearTimeout(timer);
+        reject(new Error('no se pudo conectar al navegador'));
+      }, { once: true });
+    });
+  }
+
+  send(method, params = {}, sessionId) {
+    const id = ++this.seq;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+    });
+  }
+
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+      /* nada */
+    }
+  }
+}
+
+function describeArg(arg) {
+  if (!arg) return '';
+  if ('value' in arg) {
+    return typeof arg.value === 'string' ? arg.value : JSON.stringify(arg.value);
+  }
+  if (arg.description) return arg.description;
+  if (arg.preview?.properties?.length) {
+    return arg.preview.properties.map((p) => `${p.name}: ${p.value}`).join(', ');
+  }
+  return String(arg.type ?? '');
+}
+
+async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true } = {}) {
+  const cdp = new CdpConnection(new WebSocket(wsUrl));
+  await cdp.open();
+  const { targetId } = await cdp.send('Target.createTarget', { url: 'about:blank' });
+  const { sessionId } = await cdp.send('Target.attachToTarget', { targetId, flatten: true });
+
+  const messages = [];
+  const push = (level, text) => {
+    const value = String(text ?? '').replace(/\s+/g, ' ').trim();
+    if (value) messages.push({ level, text: value });
+  };
+  if (collectMessages) {
+    cdp.on((message) => {
+      if (message.sessionId && message.sessionId !== sessionId) return;
+      if (message.method === 'Runtime.consoleAPICalled') {
+        const level = message.params.type === 'warning' ? 'warning' : message.params.type;
+        push(level, (message.params.args ?? []).map(describeArg).join(' '));
+      } else if (message.method === 'Runtime.exceptionThrown') {
+        const details = message.params.exceptionDetails ?? {};
+        push('error', details.exception?.description || details.text || 'excepción');
+      } else if (message.method === 'Log.entryAdded') {
+        const entry = message.params.entry ?? {};
+        if (entry.level === 'error' || entry.level === 'warning') push(entry.level, entry.text);
+      }
+    });
+  }
+
+  await cdp.send('Page.enable', {}, sessionId);
+  await cdp.send('Runtime.enable', {}, sessionId);
+  await cdp.send('Log.enable', {}, sessionId).catch(() => {});
+
+  const loaded = new Promise((resolve) => {
+    const off = cdp.on((message) => {
+      if (message.method === 'Page.loadEventFired' && message.sessionId === sessionId) {
+        off();
+        resolve();
+      }
+    });
+  });
+  await cdp.send('Page.navigate', { url }, sessionId);
+  await Promise.race([loaded, delay(timeoutMs)]);
+
+  return { cdp, sessionId, targetId, messages };
+}
+
+/** Cierra el navegador y sus hijos. En Windows `child.kill` no mata el arbol. */
+function killBrowser(child) {
+  if (!child || child.killed) return;
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    } catch {
+      /* nada */
+    }
+  } else {
+    try {
+      child.kill('SIGKILL');
+    } catch {
+      /* nada */
+    }
+  }
+}
+
+async function withBrowser(url, options, run) {
+  const bin = findBrowserPath();
+  if (!bin) {
+    throw new Error('no encontré Chrome/Edge/Chromium; definí TAMNORA_BROWSER con la ruta al ejecutable');
+  }
+  const { child, wsUrl, profile } = await launchBrowser(bin);
+  try {
+    const page = await openPage(wsUrl, url, options);
+    try {
+      return await run(page);
+    } finally {
+      page.cdp.close();
+    }
+  } finally {
+    killBrowser(child);
+    // Chrome tarda en soltar el profile: darle un respiro y no fallar si queda.
+    await delay(200);
+    try {
+      rmSync(profile, { recursive: true, force: true });
+    } catch {
+      /* profile bloqueado: queda en temp, no es fatal */
+    }
+  }
+}
+
+/**
+ * Captura PNG de una URL. Devuelve `{ buffer, width, height, consoleErrors }`.
+ */
+export async function captureScreenshot(url, { fullPage = false, width = 1280, height = 720, waitMs = 800, timeoutMs } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true }, async ({ cdp, sessionId, messages }) => {
+    await cdp
+      .send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false }, sessionId)
+      .catch(() => {});
+    if (waitMs > 0) await delay(waitMs);
+    const shot = await cdp.send(
+      'Page.captureScreenshot',
+      { format: 'png', captureBeyondViewport: Boolean(fullPage) },
+      sessionId
+    );
+    const errors = messages.filter((m) => m.level === 'error');
+    return { buffer: Buffer.from(shot.data, 'base64'), width, height, consoleErrors: errors };
+  });
+}
+
+/**
+ * Abre una URL y devuelve los mensajes de consola. `{ messages, errors }`.
+ */
+export async function readConsole(url, { waitMs = 1500, timeoutMs } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true }, async ({ messages }) => {
+    if (waitMs > 0) await delay(waitMs);
+    const errors = messages.filter((m) => m.level === 'error');
+    return { messages, errors };
+  });
+}

package/harness/packages/core/src/config/home.js

@@ -39,6 +39,11 @@ export function homePath(...parts) {
   return path.join(homeDir(), ...parts);
 }
 
+/** Carpeta de capturas del navegador (la sirve la consola y la usa Telegram). */
+export function screenshotsDir() {
+  return homePath('screenshots');
+}
+
 export function appConfigPath() {
   return homePath('app.json');
 }

package/harness/packages/core/src/index.js

@@ -10,9 +10,9 @@ export {
 } from './redact.js';
 export { resolveApiKey, resolveEnvMap } from './config/secrets.js';
 export { ensureUtf8Console } from './console.js';
-export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments } from './agent/runAgent.js';
+export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments, normalizeToolOutput } from './agent/runAgent.js';
 export { estimateTokens, trimContext } from './agent/context.js';
-export { diffLines } from './tools/diff.js';
+export { diffLines, diffRows } from './tools/diff.js';
 export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
 export { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
@@ -52,6 +52,7 @@ export {
   setHome,
   homeDir,
   homePath,
+  screenshotsDir,
   appConfigPath,
   databaseFile,
   runtimePath,

package/harness/packages/core/src/providers/presets.js

@@ -9,6 +9,10 @@ function preset(id, label, baseUrl) {
 export const OPENAI_COMPATIBLE_PRESETS = [
   preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
   preset('openai', 'OpenAI', 'https://api.openai.com/v1'),
+  // Anthropic y Gemini exponen una capa compatible con OpenAI (chat/completions
+  // + tools) que usa el mismo Bearer; sirven con este adaptador sin cambios.
+  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1'),
+  preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai'),
   preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
   preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),
   preset('xai', 'xAI (Grok)', 'https://api.x.ai/v1'),