@danieltmn/tamnora 0.21.2 → 0.23.0

package/CHANGELOG.md

@@ -5,6 +5,34 @@ 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.23.0] - 2026-10-28
+
+### Cambios
+
+- feat(ajustes): expone maxOutputTokens y promptCaching en la pestana Limites
+- feat(consola): el logo acompana el esquema del tema, y el browser puede emular color y correr un pre-script
+- refactor(consola): extrae las tarjetas de chat.js a cards.js
+- test(consola): valida el grafo de modulos y la carga real en navegador headless
+- feat: canary de servicios vivos en pnpm y en cron de GitHub
+- feat(doctor): --voz prueba el servicio de voz y distingue voz rota de servicio caido
+- fix(voz): reintenta un fallo de conexion de la sintesis, sin reintentar rechazos
+- fix(test): el arranque de procs espera la condicion, no un tiempo fijo
+- refactor(consola): extrae el formato puro de chat.js a chatFormat.js, con tests
+- refactor(telegram): parte el canal en api, text, permissions, media, projects, run y commands
+- fix(voz): EDGE_VERSION acompana al endpoint nuevo y agrega un canary de servicios vivos
+- chore: quita document.md desactualizado (decia 0.11.3) y normaliza los fin de linea
+- fix: node:sqlite necesita Node >= 22.13 y el warning experimental se filtra en los bins
+- refactor(consola): unifica la navegacion en el menu mas y devuelve el foco al cerrarlo
+
+## [0.22.0] - 2026-10-22
+
+### Cambios
+
+- docs: AGENTS.md al dia con la auditoria, los modulos de la consola y el preview opt-in
+- refactor(test): parte server.test.js en archivos por dominio
+- refactor(consola): parte app.js en modulos y pule la UX
+- fix: cierra los hallazgos de seguridad de la auditoria y agrega regresiones
+
 ## [0.21.2] - 2026-10-20
 
 ### Cambios

package/README.md

@@ -40,7 +40,7 @@ npx @danieltmn/tamnora --help
 npm i -g @danieltmn/tamnora
 ```
 
-Requiere **Node.js >= 22.5** (por `node:sqlite`).
+Requiere **Node.js >= 22.13** (por `node:sqlite`).
 
 ## Uso rapido
 
@@ -184,6 +184,8 @@ Los tres se renderizan en vivo y se reconstruyen al recargar la consola.
   server resume lo viejo y sigue con el resumen + lo reciente, sin borrar nada.
 - **`max_tokens` por ronda** (`maxOutputTokens`) y **prompt caching** opt-in
   (`promptCaching`, `cache_control` en Anthropic y `prompt_cache_key` en OpenAI).
+  Ambos se ajustan en la pestaña **Límites** de la consola o con `PUT /api/settings`
+  (no solo por `tamnora.json`).
 
 ### Hooks y plugins
 

package/SECURITY.md

@@ -59,7 +59,7 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
 
 ## Buenas practicas
 
-- Mantene Node actualizado (`node:sqlite` requiere Node >= 22.5).
+- Mantene Node actualizado (`node:sqlite` requiere Node >= 22.13).
 - No commitees `.env`, `tamnora.json`, bases `.db` ni `.npmrc`; estan en
   `.gitignore`.
 - Rota cualquier credencial que se haya compartido en texto plano.

package/harness/packages/cli/bin/tamnora.mjs

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
-import { runCli } from '../src/cli.js';
+// node:sqlite sigue siendo "experimental" en Node 22, que avisa aunque ande. El
+// aviso no le aporta nada al usuario, asi que se filtra aca (lo que no sea un
+// warning de Node se imprime igual).
+process.on('warning', (warning) => {
+  if (warning.name !== 'ExperimentalWarning') console.warn(warning.stack ?? warning);
+});
+const { runCli } = await import('../src/cli.js');
 
 runCli(process.argv.slice(2))
   .then((code) => {

package/harness/packages/cli/src/commands/doctor.js

@@ -10,23 +10,28 @@ import {
   readPackageVersion,
   compareVersions,
   fetchLatestVersion,
+  sintetizar,
 } from '../../../core/src/index.js';
 import { parse } from '../lib/util.js';
 import { pidAlive, readRuntime } from '../lib/daemon.js';
 
-const OPTIONS = { home: { type: 'string' }, help: { type: 'boolean', short: 'h' } };
+const OPTIONS = {
+  home: { type: 'string' },
+  voz: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
 
 export async function doctorCommand(argv) {
   const { values } = parse(argv, OPTIONS);
   if (values.help) {
-    console.log('Uso: tamnora doctor [--home <path>]\n\nVerifica Node, la casa, el puerto y la base.');
+    console.log('Uso: tamnora doctor [--home <path>] [--voz]\n\nVerifica Node, la casa, el puerto y la base. Con --voz prueba tambien el servicio de voz.');
     return 0;
   }
 
   const [maj, min] = process.versions.node.split('.').map((n) => parseInt(n, 10));
-  const nodeOk = maj > 22 || (maj === 22 && min >= 5);
+  const nodeOk = maj > 22 || (maj === 22 && min >= 13);
   const checks = [
-    [`Node ${process.versions.node}`, nodeOk, nodeOk ? '' : 'requiere Node >= 22.5 (node:sqlite)'],
+    [`Node ${process.versions.node}`, nodeOk, nodeOk ? '' : 'requiere Node >= 22.13 (node:sqlite)'],
   ];
 
   const cfgOk = homeExists();
@@ -69,6 +74,10 @@ export async function doctorCommand(argv) {
   if (serverLive) checks.push([`server (pid ${rt.pid})`, true, rt.url || '']);
   checks.push([`logs`, true, serverLogPath()]);
 
+  // El servicio de voz es un servicio externo sin contrato: se prueba solo si se
+  // pide, porque toca la red y tarda un par de segundos.
+  if (values.voz) checks.push(await checkVoz());
+
   let ok = true;
   for (const [name, pass, hint] of checks) {
     console.log(`${pass ? '  OK  ' : ' FALTA'}  ${name}${hint ? `  ->  ${hint}` : ''}`);
@@ -85,3 +94,32 @@ function isPortFree(port, host) {
     server.listen(port, host);
   });
 }
+
+/**
+ * Prueba el servicio de voz sintetizando una frase. Si la voz configurada no
+ * responde, se prueba la voz por defecto: asi se distingue "el servicio esta
+ * caido" de "esta voz ya no existe".
+ *
+ * Entre intentos hay que esperar: el servicio se queja (fallo de handshake) si
+ * se le abren varias conexiones seguidas, y sin la pausa un fallo transitorio
+ * hace parecer que la voz no existe.
+ */
+async function checkVoz() {
+  const voz = readApp()?.tts?.voice || '';
+  const etiqueta = voz ? `voz (${voz})` : 'voz';
+  const esperar = () => new Promise((resolve) => setTimeout(resolve, 3000));
+  try {
+    const mp3 = await sintetizar('prueba de voz', voz ? { voice: voz } : {});
+    return [etiqueta, true, `${mp3.length} bytes`];
+  } catch (error) {
+    const detalle = error?.message ?? error;
+    if (!voz) return [etiqueta, false, `el servicio no responde: ${detalle}`];
+    await esperar();
+    try {
+      await sintetizar('prueba de voz');
+      return [etiqueta, false, `esa voz no responde (${detalle}); la voz por defecto si: cambia la voz en Ajustes`];
+    } catch {
+      return [etiqueta, false, `el servicio no responde: ${detalle}`];
+    }
+  }
+}

package/harness/packages/cli/src/commands/repl.js

@@ -166,6 +166,7 @@ export async function replCommand(argv) {
         maxTokens: config.maxTokens,
         maxDurationMs: config.maxDurationMs,
         maxOutputTokens: config.maxOutputTokens,
+        promptCaching: config.promptCaching === true,
         tools: toolDefs,
         execute,
         onEvent: printer.onEvent,

package/harness/packages/cli/src/commands/run.js

@@ -119,6 +119,7 @@ export async function runCommand(argv) {
       maxTokens: config.maxTokens,
       maxDurationMs: config.maxDurationMs,
       maxOutputTokens: config.maxOutputTokens,
+      promptCaching: config.promptCaching === true,
       signal: controller.signal,
       tools: toolDefs,
       execute,

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

@@ -101,6 +101,7 @@ export async function tuiCommand(argv) {
     maxTokens: config.maxTokens,
     maxDurationMs: config.maxDurationMs,
     maxOutputTokens: config.maxOutputTokens,
+    promptCaching: config.promptCaching === true,
     toolOptions: {
       root: cwd,
       enabled: enabledFor(mode),

package/harness/packages/cli/src/lib/runtime.js

@@ -77,6 +77,7 @@ export async function runTurn({
   maxTokens,
   maxDurationMs,
   maxOutputTokens,
+  promptCaching,
   stallWarnMs,
   signal,
   execute,
@@ -104,6 +105,7 @@ export async function runTurn({
     maxTokens,
     maxDurationMs,
     maxOutputTokens,
+    promptCaching,
     stallWarnMs,
     signal,
     onEvent,

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

@@ -24,6 +24,7 @@ export function runTui({
   maxTokens,
   maxDurationMs,
   maxOutputTokens,
+  promptCaching,
   toolOptions,
   store,
   sessionId,
@@ -207,6 +208,7 @@ export function runTui({
         maxTokens,
         maxDurationMs,
         maxOutputTokens,
+        promptCaching,
         signal: controller.signal,
         tools: toolset.definitions,
         execute: toolset.execute,

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

@@ -1,4 +1,5 @@
 import { withRetry, isRetryableError } from '../providers/resilience.js';
+import { redactSecrets, redactDeep } from '../redact.js';
 import { trimContext, estimateTokens } from './context.js';
 
 // 0 = sin limite de rondas: el loop sigue hasta que el modelo deja de pedir
@@ -66,6 +67,7 @@ export async function runAgent({
   retryDelayMs = 500,
   contextTokens = 0,
   onLifecycle,
+  redactExtra = [],
 }) {
   const working = [...messages];
   // Mensajes efimeros (p. ej. reglas por path inyectadas en runtime): entran al
@@ -234,7 +236,7 @@ export async function runAgent({
         }
       }
 
-      const normalized = normalizeToolOutput(output);
+      const normalized = normalizeToolOutput(output, { extra: redactExtra });
       onEvent?.({
         type: 'tool_result',
         id: call.id,
@@ -357,14 +359,16 @@ 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).
+ * El contenido va redactado (`redactSecrets`): un tool result que pegue una
+ * API key no puede llegar al historial, la UI ni los canales.
  */
-export function normalizeToolOutput(output) {
-  if (typeof output === 'string') return { content: output };
+export function normalizeToolOutput(output, opts = {}) {
+  if (typeof output === 'string') return { content: redactSecrets(output, opts) };
   if (output && typeof output === 'object' && typeof output.content === 'string') {
-    return { content: output.content, meta: output.meta };
+    return { content: redactSecrets(output.content, opts), meta: redactDeep(output.meta, opts) };
   }
   if (output == null) return { content: '' };
-  return { content: JSON.stringify(output) };
+  return { content: redactSecrets(JSON.stringify(output), opts) };
 }
 
 async function defaultExecute(name) {

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

@@ -53,7 +53,7 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function assertAllowedUrl(raw) {
+function assertAllowedUrl(raw, allowPrivate = false) {
   let parsed;
   try {
     parsed = new URL(String(raw));
@@ -63,16 +63,18 @@ function assertAllowedUrl(raw) {
   if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
     throw new Error(`Solo se admite http(s): ${raw}`);
   }
-  if (isBlockedHost(parsed.hostname)) {
+  // `allowPrivate` es para abrir nuestro **propio** server local (el smoke test
+  // de la consola). Las tools no lo usan: ahi la guarda anti-SSRF es total.
+  if (!allowPrivate && isBlockedHost(parsed.hostname)) {
     throw new Error(`host bloqueado (${normalizeHost(parsed.hostname)}).`);
   }
 }
 
-function isBlockedNavigation(raw) {
+function isBlockedNavigation(raw, allowPrivate = false) {
   try {
     const parsed = new URL(String(raw));
     if (!parsed.hostname) return parsed.protocol === 'file:';
-    return isBlockedHost(parsed.hostname);
+    return !allowPrivate && isBlockedHost(parsed.hostname);
   } catch {
     return false;
   }
@@ -196,7 +198,7 @@ function describeArg(arg) {
   return String(arg.type ?? '');
 }
 
-async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true } = {}) {
+async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true, allowPrivate = false } = {}) {
   const cdp = new CdpConnection(new WebSocket(wsUrl));
   await cdp.open();
   const { targetId } = await cdp.send('Target.createTarget', { url: 'about:blank' });
@@ -240,7 +242,7 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
     if (message.method !== 'Page.frameNavigated' || message.sessionId !== sessionId) return;
     const frame = message.params?.frame;
     if (!frame || frame.parentId || !frame.url || frame.url === 'about:blank') return;
-    if (isBlockedNavigation(frame.url)) blockedUrl = frame.url;
+    if (isBlockedNavigation(frame.url, allowPrivate)) blockedUrl = frame.url;
   });
   try {
     await cdp.send('Page.navigate', { url }, sessionId);
@@ -256,7 +258,7 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
         sessionId
       );
       const finalUrl = String(result?.value ?? '');
-      if (finalUrl && isBlockedNavigation(finalUrl)) blockedUrl = finalUrl;
+      if (finalUrl && isBlockedNavigation(finalUrl, allowPrivate)) blockedUrl = finalUrl;
     } catch {
       /* sin runtime disponible: nos quedamos con los eventos de navegacion */
     }
@@ -287,7 +289,7 @@ function killBrowser(child) {
 }
 
 async function withBrowser(url, options, run) {
-  assertAllowedUrl(url);
+  assertAllowedUrl(url, options.allowPrivate === true);
   const bin = findBrowserPath();
   if (!bin) {
     throw new Error('no encontré Chrome/Edge/Chromium; definí TAMNORA_BROWSER con la ruta al ejecutable');
@@ -315,11 +317,23 @@ async function withBrowser(url, options, run) {
 /**
  * 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 }) => {
+export async function captureScreenshot(url, { fullPage = false, width = 1280, height = 720, waitMs = 800, timeoutMs, allowPrivate = false, preScript = '', colorScheme = '' } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true, allowPrivate }, async ({ cdp, sessionId, messages }) => {
     await cdp
       .send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false }, sessionId)
       .catch(() => {});
+    // Para paginas que se tematizan con `prefers-color-scheme` (el sitio, no la
+    // consola): emula el esquema del sistema.
+    if (colorScheme) {
+      await cdp.send('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: colorScheme }] }, sessionId).catch(() => {});
+    }
+    let preScriptResult = null;
+    if (preScript) {
+      const evaluado = await cdp
+        .send('Runtime.evaluate', { expression: preScript, returnByValue: true, awaitPromise: true }, sessionId)
+        .catch(() => null);
+      preScriptResult = evaluado?.result?.value ?? evaluado?.value ?? null;
+    }
     if (waitMs > 0) await delay(waitMs);
     const shot = await cdp.send(
       'Page.captureScreenshot',
@@ -327,15 +341,15 @@ export async function captureScreenshot(url, { fullPage = false, width = 1280, h
       sessionId
     );
     const errors = messages.filter((m) => m.level === 'error');
-    return { buffer: Buffer.from(shot.data, 'base64'), width, height, consoleErrors: errors };
+    return { buffer: Buffer.from(shot.data, 'base64'), width, height, consoleErrors: errors, preScriptResult };
   });
 }
 
 /**
  * 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 }) => {
+export async function readConsole(url, { waitMs = 1500, timeoutMs, allowPrivate = false } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true, allowPrivate }, async ({ messages }) => {
     if (waitMs > 0) await delay(waitMs);
     const errors = messages.filter((m) => m.level === 'error');
     return { messages, errors };

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

@@ -83,6 +83,7 @@ export {
   bashGuard,
   resolveInRoot,
   toRel,
+  realpathDeep,
   MCP_ROUTER_NAME,
   MCP_AUTO_THRESHOLD,
   useLazyMcp,

package/harness/packages/core/src/mcp/stdio.js

@@ -26,6 +26,20 @@ function shouldUseShell(server, command) {
   return true;
 }
 
+// Con `shell: true` Node concatena los args sin escapar: un arg con
+// metacaracteres (`&`, `|`, `<`, `>`, `^`, `%`, `!`) inyectaria comandos. Misma
+// regla que `lib/procs.js` del server.
+const SAFE_SHELL_ARG = /^[^&|<>^%!"\r\n]+$/;
+
+function assertSafeShellArgs(server, command, args = []) {
+  if (!shouldUseShell(server, command)) return;
+  for (const arg of args) {
+    if (!SAFE_SHELL_ARG.test(String(arg))) {
+      throw new Error(`MCP stdio: argumento no permitido con shell en Windows: "${arg}".`);
+    }
+  }
+}
+
 // Variables minimas para que un proceso hijo comun (node, npx, uvx) arranque.
 const BASE_ENV_KEYS = [
   'PATH',
@@ -73,6 +87,7 @@ export function childEnv(server = {}) {
 export async function connectMcpStdioServer(server, { signal, timeout = 30000 } = {}) {
   const command = server.command;
   if (!command) throw new Error(`MCP stdio: falta "command" en el servidor ${server.id ?? ''}`);
+  assertSafeShellArgs(server, command, server.args ?? []);
 
   const child = spawn(command, server.args ?? [], {
     cwd: server.cwd,

package/harness/packages/core/src/net/hosts.js

@@ -3,6 +3,7 @@
 // `fetch_url` (tambien en cada redirect) y el navegador headless.
 
 import net from 'node:net';
+import { lookup } from 'node:dns/promises';
 
 const BLOCKED_SUFFIXES = ['.localhost', '.local', '.internal', '.intranet', '.lan', '.home.arpa'];
 
@@ -109,3 +110,72 @@ export function checkHttpUrl(value) {
   }
   return { url: parsed.toString(), parsed };
 }
+
+/**
+ * Validacion para `preview_url`: la vista previa embebe un dev server, que casi
+ * siempre es local (127.0.0.1, LAN), asi que NO aplica la guarda de hosts
+ * privados de `checkHttpUrl`. Se bloquean igual los hosts de metadatos de la
+ * nube y las direcciones link-local/multicast.
+ */
+export function checkPreviewUrl(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).' };
+  }
+  const host = normalizeHost(parsed.hostname);
+  if (!host) return { error: 'URL inválida (sin host).' };
+  if (host === 'metadata' || host.endsWith('.internal')) {
+    return { error: `host bloqueado (${host}).` };
+  }
+  if (net.isIP(host) && isLinkLocalOrReserved(host)) {
+    return { error: `host bloqueado (${host}).` };
+  }
+  return { url: parsed.toString(), parsed };
+}
+
+function isLinkLocalOrReserved(address) {
+  const value = normalizeHost(address);
+  const family = net.isIP(value);
+  if (family === 4) {
+    const [a, b] = parseV4(value) ?? [];
+    return a === 0 || (a === 169 && b === 254) || a >= 224;
+  }
+  if (family === 6) {
+    const groups = parseV6(value) ?? [];
+    const [g0] = groups;
+    return groups.every((g) => g === 0) || (g0 & 0xffc0) === 0xfe80 || (g0 & 0xff00) === 0xff00;
+  }
+  return true;
+}
+
+/**
+ * Como `checkHttpUrl`, pero ademas resuelve el hostname y valida las IPs: un
+ * dominio publico que resuelva a una IP interna (DNS rebinding) no pasa. Vale
+ * para la URL inicial y para cada redirect.
+ */
+export async function checkHttpUrlResolved(value) {
+  const checked = checkHttpUrl(value);
+  if (checked.error) return checked;
+  const host = normalizeHost(checked.parsed.hostname);
+  if (net.isIP(host)) return checked;
+  let addresses;
+  try {
+    addresses = await lookup(host, { all: true });
+  } catch {
+    return { error: `No pude resolver el host "${host}".` };
+  }
+  if (!addresses.length) return { error: `No pude resolver el host "${host}".` };
+  for (const { address } of addresses) {
+    if (isBlockedAddress(address)) {
+      return { error: `host bloqueado (${host} resuelve a ${normalizeHost(address)}).` };
+    }
+  }
+  return checked;
+}

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

@@ -17,6 +17,8 @@ const SECRET_PATTERNS = [
   /AIza[0-9A-Za-z_-]{30,}/g,
   /xox[baprs]-[A-Za-z0-9-]{10,}/g,
   /ya29\.[A-Za-z0-9_-]{20,}/g,
+  /gsk_[A-Za-z0-9]{20,}/g, // Groq
+  /\b\d{8,10}:[A-Za-z0-9_-]{30,}\b/g, // token de bot de Telegram
   /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
 ];
 

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

@@ -7,7 +7,7 @@ import { diffLines } from './diff.js';
 import { captureScreenshot, readConsole } from '../browser/index.js';
 import { screenshotsDir } from '../config/home.js';
 import { scrubEnv } from '../redact.js';
-import { checkHttpUrl, isBlockedHost, normalizeHost } from '../net/hosts.js';
+import { checkHttpUrlResolved, checkPreviewUrl } from '../net/hosts.js';
 
 const MAX_READ_LINES = 2000;
 const MAX_LIST = 500;
@@ -98,7 +98,7 @@ function formatBody(head, text, limit) {
 }
 
 export async function fetchUrlTool(_root, { url, maxLength, raw } = {}) {
-  const checked = checkHttpUrl(url);
+  const checked = await checkHttpUrlResolved(url);
   if (checked.error) return `Error: ${checked.error}`;
   let target = checked.parsed;
 
@@ -129,9 +129,8 @@ export async function fetchUrlTool(_root, { url, maxLength, raw } = {}) {
       if (next.protocol !== 'http:' && next.protocol !== 'https:') {
         return `Error: redirección a un protocolo no permitido (${next.protocol}).`;
       }
-      if (isBlockedHost(next.hostname)) {
-        return `Error: host bloqueado (${normalizeHost(next.hostname)}).`;
-      }
+      const recheck = await checkHttpUrlResolved(next.toString());
+      if (recheck.error) return `Error: ${recheck.error}`;
       try {
         await res.body?.cancel();
       } catch {
@@ -331,7 +330,8 @@ export function bashTool(root, { command, timeout } = {}, { signal } = {}) {
     let settled = false;
     let timer = null;
     const append = (chunk) => {
-      if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
+      const room = MAX_BASH_OUTPUT - output.length;
+      if (room > 0) output += chunk.toString().slice(0, room);
     };
 
     const finish = (text) => {
@@ -374,7 +374,8 @@ function runGit(root, args) {
     let output = '';
     let settled = false;
     const append = (chunk) => {
-      if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
+      const room = MAX_BASH_OUTPUT - output.length;
+      if (room > 0) output += chunk.toString().slice(0, room);
     };
     child.stdout?.on('data', append);
     child.stderr?.on('data', append);
@@ -399,7 +400,14 @@ export function gitStatusTool(root) {
 export function gitDiffTool(root, { path: p, staged, ref } = {}) {
   const args = ['diff', '--no-color'];
   if (staged) args.push('--staged');
-  if (ref) args.push(String(ref));
+  if (ref) {
+    // Un "ref" que empieza con '-' no es un ref: git lo tomaria como opcion
+    // (`--output=`, `--ext-diff`) y escribiria/ejecutaria cosas, siendo
+    // `git_diff` una tool de solo lectura con permiso `allow`.
+    const value = String(ref);
+    if (value.startsWith('-')) return 'Error: "ref" inválido (no puede empezar con "-").';
+    args.push(value);
+  }
   if (p) args.push('--', String(p));
   return runGit(root, args);
 }
@@ -436,19 +444,6 @@ export function speakTool(_root, { texto, voice, rate, pitch } = {}) {
   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;
@@ -460,7 +455,7 @@ function clampInt(value, fallback, min, max) {
  * del cliente (igual que `speak`): aca solo se valida la URL.
  */
 export function previewUrlTool(_root, { url } = {}) {
-  const parsed = normalizeHttpUrl(url);
+  const parsed = checkPreviewUrl(url);
   if (parsed.error) return `Error: ${parsed.error}`;
   return `Vista previa pedida: ${parsed.url}. La consola la abre en el panel de vista previa.`;
 }
@@ -558,7 +553,7 @@ export function showPlanTool(_root, { title, steps } = {}) {
  * muestre y Telegram la mande como foto.
  */
 export async function screenshotTool(_root, { url, fullPage, width, height } = {}) {
-  const parsed = checkHttpUrl(url);
+  const parsed = await checkHttpUrlResolved(url);
   if (parsed.error) return `Error: ${parsed.error}`;
   const size = {
     width: clampInt(width, 1280, 320, 3840),
@@ -595,7 +590,7 @@ export async function screenshotTool(_root, { url, fullPage, width, height } = {
 
 /** Errores y mensajes de consola de una pagina (ejecutando su JS). */
 export async function consoleTool(_root, { url, waitMs } = {}) {
-  const parsed = checkHttpUrl(url);
+  const parsed = await checkHttpUrlResolved(url);
   if (parsed.error) return `Error: ${parsed.error}`;
 
   let result;

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

@@ -4,7 +4,7 @@ import { MCP_ROUTER_NAME, planMcpTools } from './mcp.js';
 export { createToolRegistry } from './registry.js';
 export { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
 export { DEFAULT_PERMISSIONS, evaluatePermission, bashGuard } from './permissions.js';
-export { resolveInRoot, toRel } from './paths.js';
+export { resolveInRoot, toRel, realpathDeep } from './paths.js';
 export { globToRegExp, walkFiles, DEFAULT_IGNORES } from './glob.js';
 export { MCP_ROUTER_NAME, MCP_AUTO_THRESHOLD, useLazyMcp, buildMcpIndex, mcpRouterDefinition, planMcpTools } from './mcp.js';
 export * as executors from './executors.js';