@danieltmn/tamnora 0.9.3 → 0.9.4

package/CHANGELOG.md

@@ -5,6 +5,12 @@ 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

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/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,7 +10,7 @@ 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, diffRows } from './tools/diff.js';
 export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
@@ -52,6 +52,7 @@ export {
   setHome,
   homeDir,
   homePath,
+  screenshotsDir,
   appConfigPath,
   databaseFile,
   runtimePath,

package/harness/packages/core/src/tools/executors.js

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { resolveInRoot, toRel } from './paths.js';
 import { globToRegExp, walkFiles } from './glob.js';
 import { diffLines } from './diff.js';
+import { captureScreenshot, readConsole } from '../browser/index.js';
+import { screenshotsDir } from '../config/home.js';
 
 const MAX_READ_LINES = 2000;
 const MAX_LIST = 500;
@@ -419,6 +421,97 @@ export function speakTool(_root, { texto, voice, rate } = {}) {
   return `Audio pedido${opciones ? ` (${opciones})` : ''}: "${recortado}". El cliente lo reproduce o lo envía como nota de voz.`;
 }
 
+function normalizeHttpUrl(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return { error: 'falta "url".' };
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return { error: `URL inválida: "${raw}".` };
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return { error: 'Solo se admite http(s).' };
+  return { url: parsed.toString() };
+}
+
+function clampInt(value, fallback, min, max) {
+  const n = Math.round(Number(value));
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(Math.max(n, min), max);
+}
+
+/**
+ * Pide abrir una URL en el panel de vista previa de la consola. La entrega es
+ * del cliente (igual que `speak`): aca solo se valida la URL.
+ */
+export function previewUrlTool(_root, { url } = {}) {
+  const parsed = normalizeHttpUrl(url);
+  if (parsed.error) return `Error: ${parsed.error}`;
+  return `Vista previa pedida: ${parsed.url}. La consola la abre en el panel de vista previa.`;
+}
+
+/**
+ * Captura de pantalla con el navegador headless del sistema. La guarda en la
+ * casa (`screenshots/`) y devuelve un `meta.screenshot` para que la consola la
+ * muestre y Telegram la mande como foto.
+ */
+export async function screenshotTool(_root, { url, fullPage, width, height } = {}) {
+  const parsed = normalizeHttpUrl(url);
+  if (parsed.error) return `Error: ${parsed.error}`;
+  const size = {
+    width: clampInt(width, 1280, 320, 3840),
+    height: clampInt(height, 720, 240, 2160),
+  };
+
+  let shot;
+  try {
+    shot = await captureScreenshot(parsed.url, { fullPage: Boolean(fullPage), ...size });
+  } catch (error) {
+    return `Error capturando ${parsed.url}: ${error?.message ?? error}`;
+  }
+
+  let name;
+  try {
+    const dir = screenshotsDir();
+    await mkdir(dir, { recursive: true });
+    name = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`;
+    await writeFile(path.join(dir, name), shot.buffer);
+  } catch (error) {
+    return `Error guardando la captura: ${error?.message ?? error}`;
+  }
+
+  const errors = shot.consoleErrors ?? [];
+  const head = `Captura de ${parsed.url} → capturas/${name} (${size.width}x${size.height}, ${Math.round(shot.buffer.length / 1024)} KB)`;
+  const detail = errors.length
+    ? `Errores de consola al cargar (${errors.length}):\n${errors.slice(0, 10).map((e) => `- ${e.text}`).join('\n')}`
+    : 'Sin errores de consola al cargar.';
+  return {
+    content: `${head}\n${detail}`,
+    meta: { screenshot: { name, url: parsed.url, width: size.width, height: size.height } },
+  };
+}
+
+/** Errores y mensajes de consola de una pagina (ejecutando su JS). */
+export async function consoleTool(_root, { url, waitMs } = {}) {
+  const parsed = normalizeHttpUrl(url);
+  if (parsed.error) return `Error: ${parsed.error}`;
+
+  let result;
+  try {
+    result = await readConsole(parsed.url, { waitMs: clampInt(waitMs, 1500, 0, 15000) });
+  } catch (error) {
+    return `Error leyendo la consola de ${parsed.url}: ${error?.message ?? error}`;
+  }
+
+  const { errors, messages } = result;
+  const head = errors.length
+    ? `Consola de ${parsed.url}: ${errors.length} error(es), ${messages.length} mensaje(s).`
+    : `Consola de ${parsed.url}: sin errores (${messages.length} mensaje(s)).`;
+  if (!messages.length) return head;
+  const shown = messages.slice(0, 100).map((m) => `[${m.level}] ${m.text}`);
+  return [head, ...shown].join('\n');
+}
+
 export const EXECUTORS = {
   read: readTool,
   write: writeTool,
@@ -433,4 +526,7 @@ export const EXECUTORS = {
   git_log: gitLogTool,
   git_commit: gitCommitTool,
   speak: speakTool,
+  preview_url: previewUrlTool,
+  screenshot: screenshotTool,
+  console_errors: consoleTool,
 };

package/harness/packages/core/src/tools/labels.js

@@ -50,6 +50,10 @@ export function summarizeToolCall(name, args = {}) {
     }
     case 'fetch_url':
       return shorten(a.url, 90);
+    case 'screenshot':
+    case 'console_errors':
+    case 'preview_url':
+      return shorten(a.url, 90);
     case 'speak':
       return shorten(a.texto, 90);
     case 'git_diff':

package/harness/packages/core/src/tools/permissions.js

@@ -14,6 +14,9 @@ export const DEFAULT_PERMISSIONS = {
   git_log: 'allow',
   fetch_url: 'allow',
   speak: 'allow',
+  screenshot: 'allow',
+  console_errors: 'allow',
+  preview_url: 'allow',
   write: 'ask',
   edit: 'ask',
   bash: 'ask',
@@ -43,6 +46,7 @@ function subjectFor(name, args) {
   if (name === 'bash') return args?.command ?? '';
   if (name === 'git_commit') return args?.message ?? '';
   if (name === 'fetch_url') return args?.url ?? '';
+  if (name === 'screenshot' || name === 'console_errors' || name === 'preview_url') return args?.url ?? '';
   return args?.path ?? '';
 }
 

package/harness/packages/core/src/tools/schema.js

@@ -150,6 +150,53 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'screenshot',
+      description:
+        'Take a screenshot of a web page with a headless browser (renders JavaScript). Use it to show the user a preview of a page (e.g. a local dev server like http://127.0.0.1:5173) or to inspect it visually. Returns the console errors seen while loading.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Absolute http(s) URL to capture' },
+          fullPage: { type: 'boolean', description: 'Capture the full scrollable page (default: viewport)' },
+          width: { type: 'integer', description: 'Viewport width in px (default 1280)' },
+          height: { type: 'integer', description: 'Viewport height in px (default 720)' },
+        },
+        required: ['url'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'console_errors',
+      description:
+        'Open a web page with a headless browser (executes JavaScript) and return its console messages and errors. Use it to check a page for runtime errors.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Absolute http(s) URL' },
+          waitMs: { type: 'integer', description: 'Extra ms to wait after load for async errors (default 1500)' },
+        },
+        required: ['url'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'preview_url',
+      description:
+        'Open a URL in the console preview panel for the user. Use it to show a page or dev server without leaving the chat.',
+      parameters: {
+        type: 'object',
+        properties: { url: { type: 'string', description: 'Absolute http(s) URL to preview' } },
+        required: ['url'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {