micro-models-agent 2.10.0 → 2.12.0

package/dist/tools/syntax-validator.js

@@ -1,7 +1,12 @@
+/** Превалидация синтаксиса перед записью (TS/JS/JSON/XML), без шелла. */
 import { writeFileSync, existsSync, unlinkSync } from "fs";
 import { extname, dirname } from "path";
 import { spawn } from "child_process";
+import { Logger } from "../logger/app-logger";
+import { settleChildClose } from "../utils/child-run";
 const SYNTAX_CACHE = new Map();
+const logger = new Logger("warn", "syntax-validator");
+/** Хэш контента для кэша проверок. */
 function contentHash(content) {
     let h = 5381;
     for (let i = 0; i < content.length; i++) {
@@ -10,13 +15,15 @@ function contentHash(content) {
     return String(h);
 }
 /**
- * Run a command with timeout. Returns stdout/stderr on success, throws on failure.
+ * Прогон компилятора с таймаутом. Успех — stdout/stderr, провал — throw.
+ * Спавн БЕЗ шелла: путь файла от модели, интерполяция шелла выполнила бы
+ * `$()`/бэктики/`%VAR%` в имени.
  */
-function runCommand(command, cwd, timeoutMs) {
+function runCommand(file, args, cwd, timeoutMs) {
     return new Promise((resolve, reject) => {
-        const child = spawn(command, {
+        const child = spawn(file, args, {
             cwd,
-            shell: true,
+            shell: false,
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -36,117 +43,312 @@ function runCommand(command, cwd, timeoutMs) {
             clearTimeout(timer);
             const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
             const stderr = Buffer.concat(stderrChunks).toString("utf-8");
-            if (code === 0) {
-                resolve({ stdout, stderr });
-            }
-            else {
-                const err = new Error(`Syntax check failed with exit code ${code}`);
-                err.stdout = stdout;
-                err.stderr = stderr;
-                err.status = code;
-                reject(err);
-            }
+            settleChildClose(code, stdout, stderr, `Syntax check failed with exit code ${code}`, resolve, reject);
         });
     });
 }
-/**
- * Supported file extensions for syntax validation.
- */
+/** Расширения с валидацией синтаксиса. */
 const TS_EXTENSIONS = new Set([".ts", ".tsx", ".cts", ".mts"]);
 const JS_EXTENSIONS = new Set([".js", ".jsx", ".cjs", ".mjs"]);
-const JSON_EXTENSIONS = new Set([".json"]);
+const JSON_EXTENSIONS = new Set([".json", ".jsonc"]);
+/** XML-семейство: только well-formedness, без внешних зависимостей. */
+const XML_EXTENSIONS = new Set([".xml", ".drawio", ".svg", ".xaml", ".plist", ".iml"]);
+const XML_SPANS = [
+    { open: "<!--", close: "-->", kind: "comment" },
+    { open: "<![CDATA[", close: "]]>", kind: "cdata" },
+    { open: "<?", close: "?>", kind: "pi" },
+];
+/** Спан коммента/CDATA/PI: конец (за закрывателем) или -1, если открыт. */
+function skipXmlSpan(content, i) {
+    for (const s of XML_SPANS) {
+        if (!content.startsWith(s.open, i))
+            continue;
+        const end = content.indexOf(s.close, i + s.open.length);
+        return end === -1 ? { end: -1, kind: s.kind } : { end: end + s.close.length, kind: s.kind };
+    }
+    return null;
+}
 /**
- * Pre-validate file syntax BEFORE writing to disk.
- * Returns { valid: true } if syntax is OK or language is not supported.
- * Returns { valid: false, error: "..." } if syntax is invalid.
- *
- * For TypeScript/JavaScript: writes to a temp file and runs the compiler.
- * For JSON: parses the content directly.
+ * Индекс за первым `>` вне кавычек, или -1. С trackBrackets (для `<!...>`
+ * с `[...]`-секциями) `>` внутри скобок тоже пропускается.
  */
-export async function preValidateSyntax(filePath, content, baseDir) {
-    const ext = extname(filePath).toLowerCase();
-    // JSON — parse directly
-    if (JSON_EXTENSIONS.has(ext)) {
-        try {
-            JSON.parse(content);
-            return { valid: true };
-        }
-        catch (e) {
-            return { valid: false, error: e.message };
+function findClosingGt(content, from, trackBrackets) {
+    let j = from;
+    let quote = null;
+    let depth = 0;
+    while (j < content.length) {
+        const d = content[j];
+        quote = nextQuoteState(quote, d);
+        if (quote) {
+            j++;
+            continue;
         }
+        if (trackBrackets && d === "[")
+            depth++;
+        else if (trackBrackets && d === "]")
+            depth--;
+        else if (d === ">" && depth <= 0)
+            return j + 1;
+        j++;
     }
-    // TypeScript — syntax check via bun build
-    if (TS_EXTENSIONS.has(ext)) {
-        const hash = contentHash(content);
-        const cached = SYNTAX_CACHE.get(filePath);
-        if (cached && cached.hash === hash) {
-            return cached.error ? { valid: false, error: cached.error } : { valid: true };
+    return -1;
+}
+/** Кавычко-состояние на один символ: вход, выход или удержание спана. */
+function nextQuoteState(quote, d) {
+    if (quote)
+        return d === quote ? null : quote;
+    return d === '"' || d === "'" ? d : null;
+}
+/** Сырой текст обычного `<...>`-тега плюс конечный индекс, или null. */
+function readXmlTag(content, i) {
+    const end = findClosingGt(content, i + 1, false);
+    if (end === -1)
+        return null;
+    return { raw: content.slice(i + 1, end - 1).trim(), end };
+}
+/** Число переводов строк. */
+function countLines(s) {
+    return s.split("\n").length - 1;
+}
+/** Шаг через один `<...>`-элемент. Ошибка (без суффикса строки) или null. */
+function scanXmlMarkup(st) {
+    const { content } = st;
+    const span = skipXmlSpan(content, st.i);
+    if (span) {
+        if (span.end === -1)
+            return `Unclosed XML ${span.kind}`;
+        st.line += countLines(content.slice(st.i, span.end));
+        st.i = span.end;
+        return null;
+    }
+    if (content.startsWith("<!", st.i)) {
+        const end = findClosingGt(content, st.i + 2, true);
+        if (end === -1)
+            return "Unclosed declaration";
+        st.line += countLines(content.slice(st.i, end));
+        st.i = end;
+        return null;
+    }
+    const tag = readXmlTag(content, st.i);
+    if (!tag)
+        return "Unclosed tag";
+    st.line += countLines(content.slice(st.i, tag.end));
+    st.i = tag.end;
+    return matchXmlTag(st.stack, tag.raw, st.line);
+}
+/** Сверка закрывающего тега со стеком. Ошибка или null. */
+function matchXmlCloseTag(stack, raw) {
+    const name = raw.slice(1).split(/[\s/>]/, 1)[0];
+    if (!name)
+        return "Empty closing tag";
+    const open = stack.pop();
+    if (!open)
+        return `Stray closing tag </${name}> with no open element`;
+    if (open.name !== name) {
+        return `Mismatched tag: expected </${open.name}> (opened line ${open.line}), got </${name}>`;
+    }
+    return null;
+}
+/** Сверка открывающего/самозакрытого тега со стеком. Ошибка или null. */
+function matchXmlOpenTag(stack, raw, tagLine) {
+    const selfClosed = /\/\s*$/.test(raw);
+    const name = raw.split(/[\s/>]/, 1)[0];
+    if (!name || name.startsWith("/") || name === "?") {
+        return `Malformed tag <${raw.slice(0, 32)}>`;
+    }
+    if (!selfClosed)
+        stack.push({ name, line: tagLine });
+    return null;
+}
+/**
+ * Сверка одного тега (open/self-close/close) со стеком. Стек мутирует, больше
+ * ничего. Ошибка (без суффикса строки) или null.
+ */
+function matchXmlTag(stack, raw, tagLine) {
+    if (!raw)
+        return "Empty tag <>";
+    if (raw.startsWith("/"))
+        return matchXmlCloseTag(stack, raw);
+    return matchXmlOpenTag(stack, raw, tagLine);
+}
+/** Проверяет XML well-formedness. Первая ошибка с номером строки или null. */
+export function checkXmlWellFormed(content) {
+    const st = { content, i: 0, line: 1, stack: [] };
+    const err = (msg) => `${msg} (line ${st.line})`;
+    while (st.i < content.length) {
+        if (content[st.i] === "\n") {
+            st.line++;
+            st.i++;
+            continue;
         }
-        const tmpFile = `${filePath}.tmp${ext}`;
-        try {
-            writeFileSync(tmpFile, content, "utf-8");
-            await runCommand(`bun build --no-bundle --target=bun "${tmpFile}"`, dirname(filePath), 5000);
-            SYNTAX_CACHE.set(filePath, { hash, error: null });
-            return { valid: true };
+        if (content[st.i] !== "<") {
+            st.i++;
+            continue;
         }
-        catch (err) {
-            const stderr = err.stderr || err.stdout || "";
-            const firstError = stderr.split("\n").find((line) => line.trim()) || "TypeScript syntax error";
-            const error = firstError.trim();
-            SYNTAX_CACHE.set(filePath, { hash, error });
-            return { valid: false, error };
+        const problem = scanXmlMarkup(st);
+        if (problem)
+            return err(problem);
+    }
+    if (st.stack.length > 0) {
+        const open = st.stack[st.stack.length - 1];
+        return err(`Unclosed tag <${open.name}> (opened line ${open.line})`);
+    }
+    return null;
+}
+/**
+ * Best-effort JSONC-нормалайзер: сносит `//` и `/* ... *\/`-комменты и висячие
+ * запятые, чтобы валидный комментированный `tsconfig.json` не отклонялся
+ * pre-write гейтом как syntax error (гейт заставлял малые модели сносить
+ * нужные комменты).
+ */
+function stripJsonComments(input) {
+    let out = "";
+    let inString = false;
+    let inLine = false;
+    let inBlock = false;
+    for (let i = 0; i < input.length; i++) {
+        const c = input[i];
+        const n = input[i + 1];
+        if (inLine) {
+            if (c === "\n") {
+                inLine = false;
+                out += c;
+            }
+            continue;
         }
-        finally {
-            try {
-                if (existsSync(tmpFile))
-                    unlinkSync(tmpFile);
+        if (inBlock) {
+            if (c === "*" && n === "/") {
+                inBlock = false;
+                i++;
             }
-            catch {
-                /* ignore cleanup errors */
+            continue;
+        }
+        if (inString) {
+            out += c;
+            if (c === "\\") {
+                out += n ?? "";
+                i++;
+            }
+            else if (c === '"') {
+                inString = false;
             }
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "/" && n === "/") {
+            inLine = true;
+            i++;
+            continue;
+        }
+        if (c === "/" && n === "*") {
+            inBlock = true;
+            i++;
+            continue;
         }
+        out += c;
     }
-    // JavaScript — syntax check via node --check
+    return out.replace(/,\s*([}\]])/g, "$1");
+}
+/**
+ * Превалидация синтаксиса ДО записи на диск.
+ * `{ valid: true }` — синтаксис ок или язык не поддерживается;
+ * `{ valid: false, error }` — синтаксис бит.
+ *
+ * TypeScript/JavaScript: временный файл + прогон компилятора.
+ * JSON: прямой парсинг.
+ */
+export async function preValidateSyntax(filePath, content, _baseDir) {
+    const ext = extname(filePath).toLowerCase();
+    // JSON / JSONC — прямой парсинг, комменты и висячие запятые терпим.
+    if (JSON_EXTENSIONS.has(ext))
+        return validateJsonContent(content);
+    // XML-семейство — чистая well-formedness (компилятор не спавним).
+    if (XML_EXTENSIONS.has(ext))
+        return validateXmlContent(content);
+    // TypeScript — синтаксис через bun build.
+    if (TS_EXTENSIONS.has(ext)) {
+        return validateWithCompiler(filePath, ext, content, "bun", (tmpFile) => ["build", "--no-bundle", "--target=bun", tmpFile], "TypeScript syntax error", true);
+    }
+    // JavaScript — синтаксис через node --check.
     if (JS_EXTENSIONS.has(ext)) {
-        const hash = contentHash(content);
-        const cached = SYNTAX_CACHE.get(filePath);
-        if (cached && cached.hash === hash) {
-            return cached.error ? { valid: false, error: cached.error } : { valid: true };
-        }
-        const tmpFile = `${filePath}.tmp${ext}`;
+        return validateWithCompiler(filePath, ext, content, "node", (tmpFile) => ["--check", tmpFile], "JavaScript syntax error", false);
+    }
+    // Неподдерживаемое расширение — без валидации.
+    return { valid: true };
+}
+/**
+ * Проверка компилятором через временный файл (без шелла — путь от модели).
+ * Общая для TypeScript (`bun build`) и JavaScript (`node --check`); результаты
+ * кэшируются по хэшу контента.
+ */
+async function validateWithCompiler(filePath, ext, content, command, args, fallbackError, useStdout) {
+    const hash = contentHash(content);
+    const cached = SYNTAX_CACHE.get(filePath);
+    if (cached && cached.hash === hash) {
+        return cached.error ? { valid: false, error: cached.error } : { valid: true };
+    }
+    const tmpFile = `${filePath}.tmp${ext}`;
+    try {
+        writeFileSync(tmpFile, content, "utf-8");
+        await runCommand(command, args(tmpFile), dirname(filePath), 5000);
+        SYNTAX_CACHE.set(filePath, { hash, error: null });
+        return { valid: true };
+    }
+    catch (err) {
+        const stderr = err.stderr || (useStdout ? err.stdout || "" : "");
+        const firstError = stderr.split("\n").find((line) => line.trim()) || fallbackError;
+        const error = firstError.trim();
+        SYNTAX_CACHE.set(filePath, { hash, error });
+        return { valid: false, error };
+    }
+    finally {
+        removeTempFile(tmpFile);
+    }
+}
+/** Best-effort чистка временного файла: проверка уже вернулась, падения только
+ * логируются ради диагностики, а не глотаются молча. */
+function removeTempFile(tmpFile) {
+    try {
+        if (existsSync(tmpFile))
+            unlinkSync(tmpFile);
+    }
+    catch (cleanupErr) {
+        logger.warn(`failed to remove syntax-check temp file ${tmpFile}`, {
+            error: String(cleanupErr),
+        });
+    }
+}
+/** JSON / JSONC — прямой парсинг, комменты и висячие запятые терпим. */
+function validateJsonContent(content) {
+    try {
+        JSON.parse(content);
+        return { valid: true };
+    }
+    catch (e) {
         try {
-            writeFileSync(tmpFile, content, "utf-8");
-            await runCommand(`node --check "${tmpFile}"`, dirname(filePath), 5000);
-            SYNTAX_CACHE.set(filePath, { hash, error: null });
+            JSON.parse(stripJsonComments(content));
             return { valid: true };
         }
-        catch (err) {
-            const stderr = err.stderr || "";
-            const firstError = stderr.split("\n").find((line) => line.trim()) || "JavaScript syntax error";
-            const error = firstError.trim();
-            SYNTAX_CACHE.set(filePath, { hash, error });
-            return { valid: false, error };
-        }
-        finally {
-            try {
-                if (existsSync(tmpFile))
-                    unlinkSync(tmpFile);
-            }
-            catch {
-                /* ignore cleanup errors */
-            }
+        catch {
+            return { valid: false, error: e.message };
         }
     }
-    // Unsupported extension — skip validation
-    return { valid: true };
+}
+/** XML-семейство — чистая well-formedness (компилятор не спавним). */
+function validateXmlContent(content) {
+    const error = checkXmlWellFormed(content);
+    return error ? { valid: false, error } : { valid: true };
 }
 /**
- * Detect import/export conflicts in TypeScript/JavaScript code.
- * Returns array of conflicting names.
+ * Детект конфликтов import/export в TS/JS. Возвращает конфликтующие имена.
  */
 export function detectImportConflicts(content) {
     const conflicts = [];
-    // Extract all named imports: import { foo, bar as baz } from '...'
+    // Все именованные импорты: import { foo, bar as baz } from '...'.
     const importRegex = /import\s+(?:type\s+)?\{([^}]+)\}\s+from/g;
     const exportRegex = /export\s+(?:function|class|const|let|var|type|interface|async\s+function)\s+(\w+)/g;
     const imports = new Set();
@@ -157,7 +359,7 @@ export function detectImportConflicts(content) {
             .split(",")
             .map((s) => s.trim())
             .map((s) => {
-            // Handle "foo as bar" — take the local name (foo)
+            // "foo as bar" — берём локальное имя (foo).
             const asMatch = s.match(/^(\w+)\s+as\s+\w+$/);
             return asMatch ? asMatch[1] : s;
         })
@@ -167,7 +369,7 @@ export function detectImportConflicts(content) {
     while ((match = exportRegex.exec(content))) {
         exports.add(match[1]);
     }
-    // Check for conflicts
+    // Сверка конфликтов.
     for (const name of imports) {
         if (exports.has(name)) {
             conflicts.push(name);

package/dist/tools/user-input.js

@@ -1,12 +1,12 @@
+/** Низкоуровневый ввод юзера: меню/парсинг выбора по STYLE.md, readline-фолбэк. */
 import * as readline from "readline";
 import { t } from "../i18n/index";
 import { getDefaultChannel } from "../output/index";
-/** Index returned by askChoice when the user picks the "custom answer" entry. */
+/** Индекс выбора "свой ответ" из askChoice. */
 export const CUSTOM_INDEX = -1;
 /**
- * Parse user input like "1" or "1,3" into 0-based option indexes.
- * Returns null on invalid input (empty, non-numeric, out of range,
- * duplicates, or multiple values when multiple is false).
+ * Парсит ввод вида "1" или "1,3" в 0-based индексы. Невалидное (пусто,
+ * нецифры, вне диапазона, дубли, несколько при multiple=false) — null.
  */
 export function parseSelection(input, optionCount, multiple) {
     const trimmed = input.trim();
@@ -28,9 +28,11 @@ export function parseSelection(input, optionCount, multiple) {
     }
     return indexes.length ? indexes : null;
 }
-/** Render question + numbered option list as a single string. */
+/** Рендерит `? <вопрос>` + опции с отступом по STYLE.md. */
 export function formatMenu(question, options, opts = {}) {
-    const lines = [question];
+    const parts = question.split("\n");
+    parts[parts.length - 1] = `? ${parts[parts.length - 1]}`;
+    const lines = [...parts];
     options.forEach((opt, i) => {
         lines.push(`  [${i + 1}] ${opt.label} — ${opt.description}`);
     });
@@ -39,24 +41,26 @@ export function formatMenu(question, options, opts = {}) {
     }
     return lines.join("\n");
 }
-/** Prompt text for the choice input. */
+/** Маркер промпта выбора `>`, по STYLE.md. */
 export function choicePrompt(optionCount, multiple) {
     return multiple
         ? t("tool.user_input.choice_multiple")
         : t("tool.user_input.choice_single", { max: optionCount });
 }
+/** Создаёт readline-интерфейс на stdio. */
 function createRl() {
     return readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
 }
+/** Одна строка промпта через readline. */
 function promptLine(rl, prompt) {
     return new Promise((resolve) => {
         rl.question(prompt, (answer) => resolve(answer));
     });
 }
-/** Free-text question. Returns trimmed answer (may be empty). */
+/** Free-text вопрос. Возвращает триммированный ответ (может быть пуст). */
 export async function askText(question) {
     const rl = createRl();
     try {
@@ -68,9 +72,9 @@ export async function askText(question) {
     }
 }
 /**
- * Choice question: shows a numbered menu and waits for a valid selection.
- * Returns selected 0-based indexes; CUSTOM_INDEX marks the custom entry.
- * Re-asks until the input is valid.
+ * Вопрос с выбором: нумерованное меню, ожидание валидного ввода.
+ * Возвращает 0-based индексы; CUSTOM_INDEX — кастомный пункт.
+ * Переспрашивает до валидного.
  */
 export async function askChoice(question, options, opts = {}) {
     const multiple = opts.multiple ?? false;
@@ -94,21 +98,21 @@ export async function askChoice(question, options, opts = {}) {
     }
 }
 /**
- * High-level helper used by the question tool.
- * - No options: free-text input, returns [text] or [] when empty.
- * - With options: returns selected labels; custom entry resolves to typed text.
+ * Высокоуровневый хелпер тула question.
+ * - Без опций: free-text, `[text]` или `[]` при пустом.
+ * - С опциями: выбранные labels; кастомный пункт — введённый текст.
  *
- * When `io` is provided (REPL), all prompting goes through it so the tool can
- * borrow the terminal from the input editor. Without it (headless/non-REPL)
- * the module-level readline helpers above remain the fallback.
+ * При `io` (REPL) весь промптинг идёт через него (терминал взаймы у редактора
+ * ввода). Без него (headless/non-REPL) — module-level readline-фолбэк выше.
  */
 export async function askUser(question, opts = {}, io) {
     const header = [opts.progress, opts.header].filter(Boolean).join(" — ");
-    const text = header ? `${header}\n${question}` : question;
     if (!opts.options || opts.options.length === 0) {
+        const text = header ? `${header}\n? ${question}` : `? ${question}`;
         const answer = io ? await io.askText(text) : await askText(text);
         return answer ? [answer] : [];
     }
+    const text = header ? `${header}\n${question}` : question;
     const allowCustom = opts.custom ?? true;
     const indexes = io
         ? await io.askChoice(text, opts.options, { multiple: opts.multiple, allowCustom })

package/dist/tools/web-browse.js

@@ -1,9 +1,12 @@
+/** Тул чтения веб-страницы в plain text (без JS; SSRF-защита, cap вывода). */
 import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
+import { BlockedRedirectError, fetchValidated, isUrlAllowed, sanitizeUrl, } from "../modules/security/network-validator";
 import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { MAX_PREVIEW_LINES } from "./preview";
+/** Потолок символов до построчной обрезки. */
 const MAX_CHARS = 3000;
+/** Читает страницу в plain text; JS-приложения вернут пустоту — для них browser. */
 export const webBrowseTool = {
     name: "web_browse",
     icon: "🌐",
@@ -18,7 +21,6 @@ export const webBrowseTool = {
     },
     handler: async (ctx, args) => {
         const url = String(args.url || "");
-        // Get session-specific security config
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
             : ctx.config.security?.network;
@@ -31,7 +33,7 @@ export const webBrowseTool = {
             };
         }
         try {
-            const response = await fetch(url, {
+            const { response } = await fetchValidated(url, securityConfig, {
                 signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
             });
             const text = await response.text();
@@ -74,6 +76,10 @@ export const webBrowseTool = {
             };
         }
         catch (err) {
+            if (err instanceof BlockedRedirectError) {
+                logSecurityBlock(ctx.sessionId, "network_request", err.reason, sanitizeUrl(url));
+                return { success: false, output: `[SECURITY BLOCKED] redirect: ${err.reason}` };
+            }
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
             return {
                 success: false,

package/dist/tools/web-fetch.js

@@ -1,10 +1,13 @@
+/** Тул чтения URL в markdown (plain HTTP, без JS; SSRF-защита, cap вывода). */
 import { t } from "../i18n/index";
-import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
+import { BlockedRedirectError, fetchValidated, isUrlAllowed, sanitizeUrl, } from "../modules/security/network-validator";
 import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { DEFAULT_SECURITY_CONFIG } from "../config/security";
 import { MAX_PREVIEW_LINES } from "./preview";
+/** Потолок символов до построчной обрезки. */
 const MAX_CHARS = 5000;
+/** Сносит скрипты/стили/теги/сущности в plain text. */
 function stripHtml(html) {
     return html
         .replace(/<script[\s\S]*?<\/script>/gi, "")
@@ -14,6 +17,7 @@ function stripHtml(html) {
         .replace(/\s+/g, " ")
         .trim();
 }
+/** Тянет URL в markdown; JS-страницы вернут пустоту — для них тул browser. */
 export const webFetchTool = {
     name: "web_fetch",
     icon: "⬇️",
@@ -28,7 +32,6 @@ export const webFetchTool = {
     },
     handler: async (ctx, args) => {
         const url = String(args.url);
-        // Get session-specific security config
         const config = ctx.config || {};
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(config, ctx.sessionContext).network
@@ -42,29 +45,11 @@ export const webFetchTool = {
             };
         }
         try {
-            const response = await fetch(url, {
+            // Каждый хоп редиректа перевадидируется (SSRF); старый код проверял один
+            // хоп и ставил redirect:"follow", оставляя остальные без проверки.
+            const { response: finalResponse, finalUrl } = await fetchValidated(url, securityConfig, {
                 signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
-                redirect: "manual",
             });
-            let finalResponse = response;
-            let finalUrl = url;
-            // Follow one redirect level manually, re-validating the target (SSRF).
-            if (response.status >= 300 && response.status < 400) {
-                const loc = response.headers.get("location");
-                if (!loc) {
-                    return { success: false, output: t("error.fetch_failed", { message: "Redirect without location" }) };
-                }
-                finalUrl = new URL(loc, url).toString();
-                const recheck = isUrlAllowed(finalUrl, securityConfig);
-                if (!recheck.allowed) {
-                    logSecurityBlock(ctx.sessionId, "network_request", recheck.reason || "redirect blocked", sanitizeUrl(finalUrl));
-                    return { success: false, output: `[SECURITY BLOCKED] redirect: ${recheck.reason}` };
-                }
-                finalResponse = await fetch(finalUrl, {
-                    signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
-                    redirect: "follow",
-                });
-            }
             if (!finalResponse.ok) {
                 return {
                     success: false,
@@ -109,6 +94,10 @@ export const webFetchTool = {
             };
         }
         catch (e) {
+            if (e instanceof BlockedRedirectError) {
+                logSecurityBlock(ctx.sessionId, "network_request", e.reason, sanitizeUrl(url));
+                return { success: false, output: `[SECURITY BLOCKED] redirect: ${e.reason}` };
+            }
             logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
             return {
                 success: false,