@danieltmn/tamnora 0.9.2 → 0.9.4

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

@@ -7,7 +7,9 @@ const MAX_CELLS = 1_500_000;
 
 function splitLines(text) {
   if (text === '' || text == null) return [];
-  return String(text).replace(/\r\n/g, '\n').split('\n');
+  const lines = String(text).replace(/\r\n/g, '\n').split('\n');
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
 }
 
 function computeOps(a, b) {
@@ -88,3 +90,70 @@ export function diffLines(oldText, newText, { context = 3, maxLines = 200 } = {}
   if (truncated) out.push('  … (diff truncado)');
   return out.join('\n');
 }
+
+/**
+ * Diff estructurado para una vista lado a lado (dos columnas): devuelve filas
+ * con la linea vieja (izquierda) y la nueva (derecha) ya numeradas. Las
+ * supresiones y adiciones de un mismo bloque se emparejan en la misma fila.
+ *
+ * @returns {Array<{type:'ctx'|'mod'|'del'|'add'|'skip', left:({no:number,text:string}|null), right:({no:number,text:string}|null)}>}
+ *   [] si no hay cambios.
+ */
+export function diffRows(oldText, newText, { context = 3, maxRows = 400 } = {}) {
+  const ops = computeOps(splitLines(oldText), splitLines(newText));
+  const changes = ops.map((o, idx) => (o.t === 'eq' ? -1 : idx)).filter((idx) => idx >= 0);
+  if (!changes.length) return [];
+
+  const keep = new Array(ops.length).fill(false);
+  for (const idx of changes) {
+    for (let j = Math.max(0, idx - context); j <= Math.min(ops.length - 1, idx + context); j++) keep[j] = true;
+  }
+
+  const rows = [];
+  let oldNo = 1;
+  let newNo = 1;
+  let pending = [];
+  let skipped = false;
+
+  const flush = () => {
+    const dels = pending.filter((p) => p.t === 'del');
+    const adds = pending.filter((p) => p.t === 'add');
+    const total = Math.max(dels.length, adds.length);
+    for (let i = 0; i < total; i++) {
+      const d = dels[i] ?? null;
+      const a = adds[i] ?? null;
+      rows.push({
+        type: d && a ? 'mod' : d ? 'del' : 'add',
+        left: d ? { no: d.no, text: d.line } : null,
+        right: a ? { no: a.no, text: a.line } : null,
+      });
+    }
+    pending = [];
+  };
+
+  for (let idx = 0; idx < ops.length; idx++) {
+    const op = ops[idx];
+    if (op.t === 'eq') {
+      flush();
+      if (keep[idx]) {
+        rows.push({ type: 'ctx', left: { no: oldNo, text: op.line }, right: { no: newNo, text: op.line } });
+        skipped = false;
+      } else if (!skipped) {
+        rows.push({ type: 'skip', left: null, right: null });
+        skipped = true;
+      }
+      oldNo++;
+      newNo++;
+    } else if (op.t === 'del') {
+      pending.push({ t: 'del', line: op.line, no: oldNo++ });
+    } else {
+      pending.push({ t: 'add', line: op.line, no: newNo++ });
+    }
+  }
+  flush();
+
+  if (rows.length > maxRows) {
+    return rows.slice(0, maxRows).concat({ type: 'skip', left: null, right: null });
+  }
+  return rows;
+}

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: {

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/diff.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { diffLines } from '../src/index.js';
+import { diffLines, diffRows } from '../src/index.js';
 
 test('diffLines reports added and removed lines with context', () => {
   const diff = diffLines('a\nb\nc\n', 'a\nB\nc\n');
@@ -18,3 +18,26 @@ test('diffLines marks a new file as additions', () => {
   assert.match(diff, /^\+ l1$/m);
   assert.match(diff, /^\+ l2$/m);
 });
+
+test('diffRows pairs a removed and an added line side by side', () => {
+  const rows = diffRows('a\nb\nc\n', 'a\nB\nc\n');
+  const mod = rows.find((r) => r.type === 'mod');
+  assert.equal(mod.left.text, 'b');
+  assert.equal(mod.left.no, 2);
+  assert.equal(mod.right.text, 'B');
+  assert.equal(mod.right.no, 2);
+  assert.ok(rows.some((r) => r.type === 'ctx' && r.left.no === 1 && r.right.no === 1));
+});
+
+test('diffRows numbers additions for a new file', () => {
+  const rows = diffRows('', 'l1\nl2\n');
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].type, 'add');
+  assert.equal(rows[0].left, null);
+  assert.equal(rows[0].right.text, 'l1');
+  assert.equal(rows[1].right.no, 2);
+});
+
+test('diffRows returns an empty list when there are no changes', () => {
+  assert.deepEqual(diffRows('x\ny\n', 'x\ny\n'), []);
+});

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