@danieltmn/tamnora 0.21.1 → 0.22.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.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
+
+- fix: cierra los P0 de la auditoria y pule la compactacion
+
 ## [0.21.1] - 2026-10-16
 
 ### Cambios

package/README.md

@@ -29,7 +29,8 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
 - **UI interactiva**: el agente pide un **formulario** (`ask_user`), ofrece
   **botones** (`offer_choices`) o muestra un **checklist** (`show_plan`); la
   consola los renderiza.
-- **Plataforma**: hooks y plugins locales (`.tamnora/hooks`, `.tamnora/plugins`).
+- **Plataforma**: hooks y plugins locales declarados en `tamnora.json`
+  (`.tamnora/hooks`, `.tamnora/plugins`; nunca se cargan por presencia).
 
 ## Instalacion
 
@@ -186,11 +187,14 @@ Los tres se renderizan en vivo y se reconstruyen al recargar la consola.
 
 ### Hooks y plugins
 
-- **Hooks** (`.tamnora/hooks/*.mjs` o `hooks[]`): observan el ciclo de vida
-  (`run.start/end`, `tool.before/after`, `session.compacting/compacted`, `advice`).
-  Corren aislados y con los datos redactados; son opt-in.
-- **Plugins** (`.tamnora/plugins/*.mjs` o `plugins[]`): agregan **tools propias**
-  al agente (expuestas como `plugin__<plugin>__<tool>`, con permisos).
+- **Hooks** (`hooks[]` en `tamnora.json`, p. ej. `[".tamnora/hooks/*.mjs"]`):
+  observan el ciclo de vida (`run.start/end`, `tool.before/after`,
+  `session.compacting/compacted`, `advice`). Corren aislados y con los datos
+  redactados. Es **opt-in explícito**: la presencia de archivos en el proyecto no
+  ejecuta nada.
+- **Plugins** (`plugins[]`, p. ej. `[".tamnora/plugins/*.mjs"]`): agregan **tools
+  propias** al agente (expuestas como `plugin__<plugin>__<tool>`, con permisos).
+  Igual que los hooks, solo se cargan desde la config.
 
 ### Preview
 

package/SECURITY.md

@@ -35,6 +35,19 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
   servidores de confianza. Un tool tipo `get-env` no puede leer tus secretos del
   shell, y los resultados MCP se **redactan** (`redactSecrets`) por si devuelven un
   token. No pases credenciales en los argumentos de las tools: van por `env`.
+- **Hooks y plugins**: son **opt-in explicito**. Solo se ejecutan los modulos
+  `.mjs` cuyos patrones declares en `hooks[]`/`plugins[]` de `tamnora.json`; la
+  presencia de `.tamnora/hooks` o `.tamnora/plugins` en un proyecto **no** ejecuta
+  nada. Aun asi, un hook/plugin corre con tus privilegios: revisalo antes de
+  declararlo.
+- **Salidas HTTP**: `fetch_url`, `screenshot` y `console_errors` bloquean loopback,
+  redes privadas, link-local, CGNAT y rangos IPv6 internos (incluido
+  IPv4-mapped), y **revalidan el host en cada redirect**. `preview_url` es la
+  excepcion a proposito: abre URLs locales en el panel de vista previa de la
+  consola.
+- **Procesos de dev**: `POST /api/procs/start` solo acepta conexiones locales,
+  pasa por la allowlist `processes.allow` y valida los argumentos; en Windows no
+  se permiten metacaracteres del shell.
 - **Tools locales y `bash`**: `bash` corre en tu maquina como tu usuario, asi que
   hay un piso de seguridad que **no se puede saltear** ni con `bash: "allow"` ni
   con `--yes`: los comandos catastroficos (`rm -rf /`/`~`, fork bomb, `mkfs`,

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

@@ -8,6 +8,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { isBlockedHost, normalizeHost } from '../net/hosts.js';
 
 const LAUNCH_TIMEOUT_MS = 15000;
 
@@ -52,6 +53,31 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function assertAllowedUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(String(raw));
+  } catch {
+    throw new Error(`URL inválida: ${raw}`);
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`Solo se admite http(s): ${raw}`);
+  }
+  if (isBlockedHost(parsed.hostname)) {
+    throw new Error(`host bloqueado (${normalizeHost(parsed.hostname)}).`);
+  }
+}
+
+function isBlockedNavigation(raw) {
+  try {
+    const parsed = new URL(String(raw));
+    if (!parsed.hostname) return parsed.protocol === 'file:';
+    return isBlockedHost(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+
 function launchBrowser(bin) {
   return new Promise((resolve, reject) => {
     const profile = mkdtempSync(path.join(tmpdir(), 'tamnora-browser-'));
@@ -209,8 +235,35 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
       }
     });
   });
-  await cdp.send('Page.navigate', { url }, sessionId);
-  await Promise.race([loaded, delay(timeoutMs)]);
+  let blockedUrl = '';
+  const offNav = cdp.on((message) => {
+    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;
+  });
+  try {
+    await cdp.send('Page.navigate', { url }, sessionId);
+    await Promise.race([loaded, delay(timeoutMs)]);
+  } finally {
+    offNav();
+  }
+  if (!blockedUrl) {
+    try {
+      const { result } = await cdp.send(
+        'Runtime.evaluate',
+        { expression: 'location.href', returnByValue: true },
+        sessionId
+      );
+      const finalUrl = String(result?.value ?? '');
+      if (finalUrl && isBlockedNavigation(finalUrl)) blockedUrl = finalUrl;
+    } catch {
+      /* sin runtime disponible: nos quedamos con los eventos de navegacion */
+    }
+  }
+  if (blockedUrl) {
+    throw new Error(`host bloqueado (${normalizeHost(new URL(blockedUrl).hostname)}).`);
+  }
 
   return { cdp, sessionId, targetId, messages };
 }
@@ -234,6 +287,7 @@ function killBrowser(child) {
 }
 
 async function withBrowser(url, options, run) {
+  assertAllowedUrl(url);
   const bin = findBrowserPath();
   if (!bin) {
     throw new Error('no encontré Chrome/Edge/Chromium; definí TAMNORA_BROWSER con la ruta al ejecutable');

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

@@ -1,7 +1,9 @@
 // Hooks locales: modulos `.mjs` que observan el ciclo de vida del agente
-// (cargados con `import()` dinamico, opt-in por presencia y aislados de errores).
-// Un hook exporta por default un objeto `{ name?, events: { '<tipo>': fn } }` o
-// una funcion (se llama para todos los eventos).
+// (cargados con `import()` dinamico). Es **opt-in explicito**: solo se cargan
+// los patrones declarados en `config.hooks[]`; la mera presencia de archivos en
+// el cwd no ejecuta nada. Un hook exporta por default un objeto
+// `{ name?, events: { '<tipo>': fn } }` o una funcion (se llama para todos los
+// eventos).
 
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -23,11 +25,13 @@ export function normalizeHookModule(mod, id = '') {
 }
 
 /**
- * Carga los hooks de `patterns` + `.tamnora/hooks/*.mjs` (relativos a `cwd`).
+ * Carga los hooks de los `patterns` explicitos (relativos a `cwd`). Sin
+ * patrones no se importa nada: abrir un proyecto no ejecuta codigo por si solo.
  * Un modulo roto se ignora.
  */
 export async function loadHooks(cwd, patterns = []) {
-  const list = [...new Set([...(patterns ?? []), ...DEFAULT_HOOK_PATTERNS])];
+  const list = [...new Set(patterns ?? [])];
+  if (!list.length) return [];
   const hooks = [];
   for (const rel of await globFiles(cwd, list)) {
     try {

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

@@ -0,0 +1,181 @@
+// Guarda de hosts para salidas del harness: bloquea loopback, redes privadas,
+// link-local, CGNAT y rangos IPv6 internos (incluido IPv4-mapped). La usan
+// `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'];
+
+export function normalizeHost(hostname) {
+  return String(hostname ?? '')
+    .toLowerCase()
+    .replace(/^\[|\]$/g, '')
+    .replace(/\.$/, '');
+}
+
+function isBlockedV4(octets) {
+  const [a, b] = octets;
+  if (!Number.isInteger(a) || !Number.isInteger(b)) return true;
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+
+function parseV4(value) {
+  const parts = String(value).split('.').map(Number);
+  if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return null;
+  return parts;
+}
+
+function parseV6(value) {
+  let text = String(value).toLowerCase().split('%')[0];
+  const embedded = /(\d{1,3}(?:\.\d{1,3}){3})$/.exec(text);
+  if (embedded) {
+    const v4 = parseV4(embedded[1]);
+    if (!v4) return null;
+    const hex = `${((v4[0] << 8) | v4[1]).toString(16)}:${((v4[2] << 8) | v4[3]).toString(16)}`;
+    text = text.slice(0, text.length - embedded[1].length) + hex;
+  }
+  const halves = text.split('::');
+  if (halves.length > 2) return null;
+  const left = halves[0] ? halves[0].split(':') : [];
+  const right = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+  const missing = 8 - left.length - right.length;
+  if (halves.length === 1 ? missing !== 0 : missing < 0) return null;
+  const groups = [...left, ...Array(halves.length === 2 ? missing : 0).fill('0'), ...right];
+  if (groups.length !== 8) return null;
+  const parsed = groups.map((group) => (/^[0-9a-f]{1,4}$/.test(group) ? parseInt(group, 16) : NaN));
+  return parsed.some(Number.isNaN) ? null : parsed;
+}
+
+function isBlockedV6(groups) {
+  if (!groups) return true;
+  const [g0, g1, g2, g3, g4, g5, g6, g7] = groups;
+  if (groups.every((g) => g === 0)) return true; // ::
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0 && g7 === 1) {
+    return true; // ::1
+  }
+  if ((g0 & 0xfe00) === 0xfc00) return true; // fc00::/7
+  if ((g0 & 0xffc0) === 0xfe80) return true; // fe80::/10
+  if ((g0 & 0xff00) === 0xff00) return true; // multicast
+  if (g0 === 0x64 && g1 === 0xff9b && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0) {
+    return isBlockedV4([g6 >> 8, g6 & 0xff, g7 >> 8, g7 & 0xff]); // 64:ff9b::/96
+  }
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && (g5 === 0 || g5 === 0xffff)) {
+    return isBlockedV4([g6 >> 8, g6 & 0xff, g7 >> 8, g7 & 0xff]); // IPv4-compatible / mapped
+  }
+  return false;
+}
+
+/** `true` si la IP (v4 o v6) es loopback, privada, link-local o reservada. */
+export function isBlockedAddress(address) {
+  const value = normalizeHost(address);
+  const family = net.isIP(value);
+  if (family === 4) return isBlockedV4(parseV4(value) ?? []);
+  if (family === 6) return isBlockedV6(parseV6(value));
+  return true;
+}
+
+/** `true` si el hostname (o literal IP) no debe usarse para salir del harness. */
+export function isBlockedHost(hostname) {
+  const host = normalizeHost(hostname);
+  if (!host) return true;
+  if (net.isIP(host)) return isBlockedAddress(host);
+  if (host === 'localhost' || host === 'localhost.localdomain') return true;
+  if (BLOCKED_SUFFIXES.some((suffix) => host.endsWith(suffix))) return true;
+  if (!host.includes('.')) return true; // una sola etiqueta suele ser un host interno
+  return false;
+}
+
+/** Valida una URL http(s) para una salida del harness. */
+export function checkHttpUrl(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).' };
+  }
+  if (isBlockedHost(parsed.hostname)) {
+    return { error: `host bloqueado (${normalizeHost(parsed.hostname)}).` };
+  }
+  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/plugins/index.js

@@ -1,7 +1,8 @@
 // Plugins locales: modulos `.mjs` que exportan `{ name?, tools: [...] }` para
 // agregar herramientas propias al agente. Se cargan con `import()` dinamico,
-// opt-in por presencia. Cada tool: `{ name, description, parameters?, required?,
-// handler(args, ctx) }`.
+// **opt-in explicito**: solo los patrones declarados en `config.plugins[]`; la
+// presencia de archivos en el cwd no ejecuta nada. Cada tool:
+// `{ name, description, parameters?, required?, handler(args, ctx) }`.
 
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -19,9 +20,10 @@ export function normalizePlugin(mod, id = '') {
   return { id: value.name || id, tools: valid };
 }
 
-/** Carga los plugins de `patterns` + `.tamnora/plugins/*.mjs`. */
+/** Carga los plugins de los `patterns` explicitos (relativos a `cwd`). */
 export async function loadPlugins(cwd, patterns = []) {
-  const list = [...new Set([...(patterns ?? []), ...DEFAULT_PLUGIN_PATTERNS])];
+  const list = [...new Set(patterns ?? [])];
+  if (!list.length) return [];
   const plugins = [];
   for (const rel of await globFiles(cwd, list)) {
     try {

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,6 +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 { checkHttpUrlResolved, checkPreviewUrl } from '../net/hosts.js';
 
 const MAX_READ_LINES = 2000;
 const MAX_LIST = 500;
@@ -16,6 +17,8 @@ const MAX_GREP_FILE_BYTES = 2_000_000;
 const MAX_BASH_OUTPUT = 100_000;
 const FETCH_TIMEOUT_MS = 20000;
 const MAX_FETCH_CHARS = 200_000;
+const MAX_REDIRECTS = 5;
+const REDIRECT_STATUS = new Set([301, 302, 303, 307, 308]);
 
 const NAMED_ENTITIES = {
   amp: '&',
@@ -35,23 +38,6 @@ const NAMED_ENTITIES = {
   trade: '\u2122',
 };
 
-function isBlockedHost(hostname) {
-  const h = String(hostname ?? '')
-    .toLowerCase()
-    .replace(/^\[|\]$/g, '');
-  if (h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.local')) return true;
-  if (h === '::1' || h === '0.0.0.0') return true;
-  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-  if (!m) return false;
-  const a = Number(m[1]);
-  const b = Number(m[2]);
-  if (a === 127 || a === 10 || a === 0) return true;
-  if (a === 169 && b === 254) return true;
-  if (a === 192 && b === 168) return true;
-  if (a === 172 && b >= 16 && b <= 31) return true;
-  return false;
-}
-
 function isTextualType(type) {
   const t = String(type || '').toLowerCase();
   if (!t) return true;
@@ -112,27 +98,46 @@ function formatBody(head, text, limit) {
 }
 
 export async function fetchUrlTool(_root, { url, maxLength, raw } = {}) {
-  let target;
-  try {
-    target = new URL(String(url ?? ''));
-  } catch {
-    return 'Error: URL inválida.';
-  }
-  if (!/^https?:$/.test(target.protocol)) return 'Error: solo se permite http/https.';
-  if (isBlockedHost(target.hostname)) return `Error: host bloqueado (${target.hostname}).`;
+  const checked = await checkHttpUrlResolved(url);
+  if (checked.error) return `Error: ${checked.error}`;
+  let target = checked.parsed;
 
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
-    const res = await fetch(target.toString(), {
-      redirect: 'follow',
-      signal: controller.signal,
-      headers: {
-        'User-Agent': 'Mozilla/5.0 (compatible; tamnora-harness; +https://github.com/tamnora/tamnora-harness)',
-        Accept: 'text/html,application/xhtml+xml,application/json,text/plain;q=0.9,*/*;q=0.5',
-        'Accept-Language': 'es,en;q=0.8',
-      },
-    });
+    let res;
+    for (let hop = 0; ; hop++) {
+      res = await fetch(target.toString(), {
+        redirect: 'manual',
+        signal: controller.signal,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; tamnora-harness; +https://github.com/tamnora/tamnora-harness)',
+          Accept: 'text/html,application/xhtml+xml,application/json,text/plain;q=0.9,*/*;q=0.5',
+          'Accept-Language': 'es,en;q=0.8',
+        },
+      });
+      if (!REDIRECT_STATUS.has(res.status)) break;
+      const location = res.headers.get('location');
+      if (!location) break;
+      if (hop >= MAX_REDIRECTS) return `Error: demasiadas redirecciones (${MAX_REDIRECTS}).`;
+      let next;
+      try {
+        next = new URL(location, target);
+      } catch {
+        return `Error: redirección inválida (${location}).`;
+      }
+      if (next.protocol !== 'http:' && next.protocol !== 'https:') {
+        return `Error: redirección a un protocolo no permitido (${next.protocol}).`;
+      }
+      const recheck = await checkHttpUrlResolved(next.toString());
+      if (recheck.error) return `Error: ${recheck.error}`;
+      try {
+        await res.body?.cancel();
+      } catch {
+        /* el cuerpo del redirect no importa */
+      }
+      target = next;
+    }
     const type = res.headers.get('content-type') || '';
     const limit = Math.min(Math.max(Number(maxLength) || 20000, 500), MAX_FETCH_CHARS);
     const full = await res.text();
@@ -325,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) => {
@@ -368,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);
@@ -393,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);
 }
@@ -430,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;
@@ -454,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.`;
 }
@@ -552,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 = normalizeHttpUrl(url);
+  const parsed = await checkHttpUrlResolved(url);
   if (parsed.error) return `Error: ${parsed.error}`;
   const size = {
     width: clampInt(width, 1280, 320, 3840),
@@ -589,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 = normalizeHttpUrl(url);
+  const parsed = await checkHttpUrlResolved(url);
   if (parsed.error) return `Error: ${parsed.error}`;
 
   let result;