micro-models-agent 2.11.0 → 2.13.1

package/dist/modules/security/network-validator.js

@@ -1,7 +1,7 @@
 import { sanitizeLogMessage } from "./data-sanitizer";
 /**
- * Parse a numeric IP component honoring decimal, hex (0x…) and octal (0…)
- * notations. Returns null when the token is not purely numeric.
+ * Разобрать числовой компонент IP с учётом decimal, hex (0x…) и octal (0…).
+ * Не числовой токен — null.
  */
 function parseIpNumber(s) {
     if (/^0x[0-9a-f]+$/.test(s))
@@ -12,9 +12,9 @@ function parseIpNumber(s) {
         return parseInt(s, 10);
     return null;
 }
-/** Check whether four decoded octets form a private/reserved IPv4 address. */
+/** Образуют ли четыре октета приватный/резервный IPv4. */
 function isPrivateIpv4(o) {
-    const [a, b = 0, c = 0, d = 0] = o;
+    const [a, b = 0, _c = 0, _d = 0] = o;
     return (a === 0 ||
         a === 10 ||
         a === 127 ||
@@ -23,55 +23,95 @@ function isPrivateIpv4(o) {
         (a === 192 && b === 168));
 }
 /**
- * Check if a hostname is a private/link-local address (SSRF protection).
- *
- * Handles more than just dotted quads: bare integer / hex / octal encodings
- * (every HTTP client decodes them as a 32-bit IPv4), shorthand quads
- * ("127.1" → 127.0.0.1) and IPv6-mapped IPv4 ("::ffff:7f00:1").
+ * Переписать хвостовой dotted-quad (IPv4-mapped литерал, напр. `::ffff:127.0.0.1`)
+ * двумя hex-группами, чтобы общий парсер IPv6 его разобрал.
+ */
+function normalizeIpv4Tail(input) {
+    const idx = input.lastIndexOf(":");
+    const tail = idx >= 0 ? input.slice(idx + 1) : input;
+    if (!tail.includes("."))
+        return input;
+    const oct = tail.split(".").map((d) => parseInt(d, 10));
+    if (oct.length !== 4 || oct.some((n) => Number.isNaN(n) || n < 0 || n > 255))
+        return null;
+    const hi = (((oct[0] << 8) | oct[1]) & 0xffff).toString(16);
+    const lo = (((oct[2] << 8) | oct[3]) & 0xffff).toString(16);
+    return `${idx >= 0 ? input.slice(0, idx + 1) : ""}${hi}:${lo}`;
+}
+/** Развернуть IPv6-литерал (без зоны) в 8 групп; кривой — null. */
+function expandIpv6(input) {
+    const normalized = normalizeIpv4Tail(input.split("%")[0]);
+    if (normalized === null)
+        return null;
+    const h = normalized;
+    const parse = (s) => s ? s.split(":").filter((x) => x !== "").map((x) => parseInt(x, 16)) : [];
+    const [head, tail] = h.split("::");
+    let groups;
+    if (tail !== undefined) {
+        const a = parse(head);
+        const b = parse(tail);
+        const zeros = 8 - a.length - b.length;
+        if (zeros < 0)
+            return null;
+        groups = [...a, ...new Array(zeros).fill(0), ...b];
+    }
+    else {
+        groups = parse(h);
+    }
+    if (groups.length !== 8 || groups.some((g) => Number.isNaN(g) || g < 0 || g > 0xffff)) {
+        return null;
+    }
+    return groups;
+}
+/**
+ * Приватный/link-local адрес в hostname (SSRF-защита) или нет.
+ * Покрывает не только dotted-quad: голые int/hex/octal-кодировки
+ * (любой HTTP-клиент декодит их как 32-битный IPv4), короткие квады
+ * ("127.1" → 127.0.0.1) и IPv6 — loopback/unspecified/link-local/
+ * unique-local и IPv4-mapped в любой форме раскрытия (старые строковые
+ * префиксы пропускали `0:0:0:0:0:0:0:1` и `::ffff:0:7f00:1`).
  */
 export function isIpPrivate(hostname) {
-    let h = hostname.toLowerCase().trim().replace(/^\[|\]$/g, "");
+    const h = hostname.toLowerCase().trim().replace(/^\[|\]$/g, "");
     if (h.includes(":")) {
-        // IPv6-mapped IPv4 (::ffff:127.0.0.1, ::ffff:7f00:1) — decode and fall
-        // through to the IPv4 checks below.
-        if (h.startsWith("::ffff:")) {
-            const mapped = h.slice(7);
-            if (!mapped.includes(":")) {
-                h = mapped; // dotted quad — fall through
-            }
-            else {
-                // Hex-colon encoding of the low 32 bits, e.g. "7f00:1".
-                const segs = mapped.split(":");
-                const hi = parseInt(segs[0], 16);
-                const lo = parseInt(segs[1] ?? "", 16);
-                if (segs.length !== 2 || Number.isNaN(hi) || Number.isNaN(lo))
-                    return false;
-                return isPrivateIpv4([(hi >> 8) & 255, hi & 255, (lo >> 8) & 255, lo & 255]);
-            }
-        }
-        else {
-            return h === "::1" || /^(fc|fd)/.test(h) || h.startsWith("fe80");
+        const g = expandIpv6(h);
+        if (!g)
+            return false;
+        // IPv4-mapped/translated (::ffff:a.b.c.d) в любой форме с нулями: старшие
+        // 96 бит — нули/ffff, младшие 32 — приватный IPv4.
+        const high = g.slice(0, 6);
+        if (high.some((n) => n === 0xffff) &&
+            high.every((n) => n === 0 || n === 0xffff) &&
+            isPrivateIpv4([(g[6] >> 8) & 255, g[6] & 255, (g[7] >> 8) & 255, g[7] & 255])) {
+            return true;
         }
+        if (g.slice(0, 7).every((n) => n === 0) && g[7] <= 1)
+            return true; // :: and ::1
+        if ((g[0] & 0xffc0) === 0xfe80)
+            return true; // fe80::/10 link-local
+        if ((g[0] & 0xfe00) === 0xfc00)
+            return true; // fc00::/7 unique-local
+        return false;
     }
     if (h === "localhost")
         return true;
-    // Bare integer/hex/octal: interpreted as one 32-bit IPv4 word.
+    // Голый int/hex/octal: интерпретируется как одно 32-битное слово IPv4.
     if (!h.includes(".")) {
         const n = parseIpNumber(h);
         if (n === null)
-            return false; // a domain name, not an IP
+            return false; // доменное имя, не IP
         if (n < 0 || n > 0xffffffff)
             return false;
         return isPrivateIpv4([(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
     }
-    // Dotted form: decode each part (hex/octal aware); shorthand like
-    // "127.1" pads the missing groups before the last.
+    // Точечная форма: декодим каждую часть (hex/octal-aware); короткие вроде
+    // "127.1" добивают пропущенные группы нулями перед последней.
     const parts = h.split(".");
     const nums = [];
     for (let i = 0; i < parts.length; i++) {
         const n = parseIpNumber(parts[i]);
         if (n === null || n > 255)
-            return false; // domain or malformed — not our concern
+            return false; // домен или мусор — не наша забота
         nums.push(n);
     }
     while (nums.length < 4)
@@ -80,11 +120,9 @@ export function isIpPrivate(hostname) {
         return false;
     return isPrivateIpv4(nums);
 }
-/**
- * Check if a URL is allowed based on security configuration
- */
+/** Разрешён ли URL по конфигу (схема, SSRF, deny/allow-домены). */
 export function isUrlAllowed(url, securityConfig) {
-    // If security is disabled, allow everything
+    // Выключенная защита разрешает всё
     if (!securityConfig?.enabled) {
         return { allowed: true };
     }
@@ -98,7 +136,7 @@ export function isUrlAllowed(url, securityConfig) {
         if (isIpPrivate(domain)) {
             return { allowed: false, reason: `Private address "${domain}" is blocked (SSRF)` };
         }
-        // Check denied domains first
+        // Сначала denied-домены
         if (securityConfig.deniedDomains?.length) {
             for (const deniedDomain of securityConfig.deniedDomains) {
                 const denied = deniedDomain.toLowerCase();
@@ -107,7 +145,7 @@ export function isUrlAllowed(url, securityConfig) {
                 }
             }
         }
-        // Check allowed domains (if non-empty, only these are allowed)
+        // Затем allowed-домены (непустой — разрешены только перечисленные)
         if (securityConfig.allowedDomains?.length) {
             let isAllowed = false;
             for (const allowedDomain of securityConfig.allowedDomains) {
@@ -130,9 +168,48 @@ export function isUrlAllowed(url, securityConfig) {
         return { allowed: false, reason: `Invalid URL: ${url}` };
     }
 }
+/** Максимум редиректов, которые проходит (и ревалидирует) {@link fetchValidated}. */
+export const MAX_REDIRECTS = 5;
+/** Бросает {@link fetchValidated}, когда хоп запрещён политикой. */
+export class BlockedRedirectError extends Error {
+    reason;
+    constructor(reason) {
+        super(`redirect blocked: ${reason}`);
+        this.reason = reason;
+        this.name = "BlockedRedirectError";
+    }
+}
 /**
- * Sanitize URL for logging (remove sensitive information)
+ * Fetch URL с РУЧНЫМИ редиректами, ревалидируя каждый хоп против SSRF/доменной
+ * политики. Обычный `fetch` с `redirect: "follow"` проверяет только стартовый
+ * URL, и публичный URL с 302 на `127.0.0.1` или metadata-эндпоинт облака
+ * дотягивается до внутреннего сервиса. Запрещённый хоп или превышение лимита —
+ * {@link BlockedRedirectError}.
  */
+export async function fetchValidated(url, securityConfig, init = {}) {
+    let current = url;
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        const check = isUrlAllowed(current, securityConfig);
+        if (!check.allowed)
+            throw new BlockedRedirectError(check.reason || "URL not allowed");
+        const response = await fetch(current, { ...init, redirect: "manual" });
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("location");
+            if (!location)
+                return { response, finalUrl: current };
+            try {
+                current = new URL(location, current).toString();
+            }
+            catch {
+                throw new BlockedRedirectError("invalid redirect location");
+            }
+            continue;
+        }
+        return { response, finalUrl: current };
+    }
+    throw new BlockedRedirectError("too many redirects");
+}
+/** Санитизация URL для логов (вырезание секретов). */
 export function sanitizeUrl(url) {
     try {
         const urlObj = new URL(url);
@@ -145,11 +222,11 @@ export function sanitizeUrl(url) {
         }
         urlObj.search = sanitizedParams.toString();
         let result = urlObj.toString();
-        // Also sanitize credentials in URL (user:pass@host)
+        // Плюс креды в URL (user:pass@host)
         if (urlObj.username || urlObj.password) {
             result = result.replace(/:\/\/[^:]+:[^@]+@/, "://[REDACTED]:[REDACTED]@");
         }
-        // Decode URL-encoded [REDACTED] back to plain text
+        // Декодим URL-encoded [REDACTED] обратно в plain text
         result = decodeURIComponent(result);
         return result;
     }

package/dist/modules/security/path-validator.js

@@ -1,39 +1,48 @@
-import { resolve, normalize } from "path";
+// Валидация путей: джейл baseDir, симлинки, deny/allow-паттерны, скоуп суб-агента.
+import { resolve, normalize, dirname } from "path";
 import { realpathSync } from "fs";
 import { isInsideDir, matchesScopeEntry, toForwardSlash } from "../../tools/path-utils";
 /**
- * Symlink containment: resolve() does NOT follow symlinks, so a symlink
- * inside baseDir can point outside it. When the target exists on disk its
- * real path must also stay inside the (real) base directory. Returns true if
- * the check cannot be performed (target missing) — creation is validated by
- * the resolved path itself.
+ * Симлинк-контейнмент: resolve() симлинки НЕ резолвит, и симлинк
+ * (или Windows-junction) внутри baseDir может указывать наружу.
+ * Существующая цель обязана остаться внутри реального base. Для ещё не
+ * созданного листа каноникализируется ближайший СУЩЕСТВУЮЩИЙ предок —
+ * иначе `base/link/new.txt` проскочил бы, когда `link` смотрит наружу.
+ * False (судить нельзя), если нет самого baseDir: чисто лексическая
+ * проверка продолжает работать на виртуальных путях.
  */
 function escapesViaSymlink(baseResolved, targetResolved) {
+    let realBase;
     try {
-        const realTarget = realpathSync(targetResolved);
-        let realBase = baseResolved;
+        realBase = realpathSync(baseResolved);
+    }
+    catch {
+        // baseDir нет (виртуальный путь / фикстура) — каноникализировать нечего.
+        return false;
+    }
+    let probe = targetResolved;
+    for (;;) {
         try {
-            realBase = realpathSync(baseResolved);
+            const real = realpathSync(probe);
+            return real !== realBase && !isInsideDir(real, realBase);
         }
         catch {
-            // Keep the resolved baseDir when it cannot be canonicalized.
+            const parent = dirname(probe);
+            if (parent === probe)
+                return false; // корень, ничего не существует
+            probe = parent;
         }
-        return !isInsideDir(realTarget, realBase);
-    }
-    catch {
-        // ENOENT etc — target does not exist yet, nothing to follow.
-        return false;
     }
 }
 /**
- * Check if a path is within the allowed scope
- * This combines global security settings with per-tool scope
+ * Путь в разрешённом скоупе или нет.
+ * Комбинирует глобальные настройки и per-tool скоуп.
  */
 export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
-    // First, check that path is within baseDir (separator- and case-safe: a
-    // sibling directory sharing the prefix must not pass).
+    // Сначала — внутри baseDir (сепараторо- и регистро-безопасно: соседний
+    // каталог с общим префиксом пройти не должен).
     if (!isInsideDir(targetResolved, baseResolved)) {
         return {
             allowed: false,
@@ -46,9 +55,9 @@ export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
             reason: "Path resolves outside the base working directory via symlink",
         };
     }
-    // If security is disabled, skip pattern validation
+    // Выключенная защита пропускает паттерны
     if (!securityConfig?.enabled) {
-        // Still enforce subagent scope if present
+        // Скоуп суб-агента действует всё равно
         if (scope) {
             const isReadScope = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
             const isWriteScope = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
@@ -63,7 +72,7 @@ export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
         }
         return { allowed: true };
     }
-    // Check global denied patterns
+    // Глобальные denied-паттерны
     if (securityConfig?.denied?.length) {
         for (const pattern of securityConfig.denied) {
             if (matchesGlobPattern(targetResolved, baseDir, pattern)) {
@@ -74,7 +83,7 @@ export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
             }
         }
     }
-    // Check global allowed patterns (if non-empty, only these are allowed)
+    // Глобальные allowed-паттерны (непустые — разрешены только совпавшие)
     if (securityConfig?.allowed?.length) {
         let isAllowed = false;
         for (const pattern of securityConfig.allowed) {
@@ -90,7 +99,7 @@ export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
             };
         }
     }
-    // Check tool-specific scope (for subagents)
+    // Per-tool скоуп (для суб-агентов)
     if (!scope) {
         return { allowed: true };
     }
@@ -105,23 +114,29 @@ export function isPathInScope(baseDir, targetPath, scope, securityConfig) {
         reason: "Path is not within the allowed scope for this sub-agent",
     };
 }
-/**
- * Check if a path is writable (for write/delete operations)
- */
+/** Путь доступен для записи (операции write/delete) или нет. */
 export function isPathWritable(baseDir, targetPath, scope, securityConfig) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
-    // First, check that path is within baseDir (separator- and case-safe: a
-    // sibling directory sharing the prefix must not pass).
+    // Сначала — внутри baseDir (сепараторо- и регистро-безопасно: соседний
+    // каталог с общим префиксом пройти не должен).
     if (!isInsideDir(targetResolved, baseResolved)) {
         return {
             allowed: false,
             reason: "Path is outside the base working directory",
         };
     }
-    // If security is disabled, skip pattern validation
+    // Запись не следует за симлинком/junction наружу из baseDir (путь чтения
+    // проверял это всегда; путь записи раньше пропускал).
+    if (escapesViaSymlink(baseResolved, targetResolved)) {
+        return {
+            allowed: false,
+            reason: "Path resolves outside the base working directory via symlink",
+        };
+    }
+    // Выключенная защита пропускает паттерны
     if (!securityConfig?.enabled) {
-        // Still enforce subagent scope if present
+        // Скоуп суб-агента действует всё равно
         if (scope) {
             const isWriteScope = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
             if (isWriteScope)
@@ -133,7 +148,7 @@ export function isPathWritable(baseDir, targetPath, scope, securityConfig) {
         }
         return { allowed: true };
     }
-    // Check global denied patterns
+    // Глобальные denied-паттерны
     if (securityConfig?.denied?.length) {
         for (const pattern of securityConfig.denied) {
             if (matchesGlobPattern(targetResolved, baseDir, pattern)) {
@@ -144,7 +159,7 @@ export function isPathWritable(baseDir, targetPath, scope, securityConfig) {
             }
         }
     }
-    // Check global allowed patterns (if non-empty, only these are allowed)
+    // Глобальные allowed-паттерны (непустые — разрешены только совпавшие)
     if (securityConfig?.allowed?.length) {
         let isAllowed = false;
         for (const pattern of securityConfig.allowed) {
@@ -160,7 +175,7 @@ export function isPathWritable(baseDir, targetPath, scope, securityConfig) {
             };
         }
     }
-    // Check tool-specific scope (for subagents)
+    // Per-tool скоуп (для суб-агентов)
     if (!scope) {
         return { allowed: true };
     }
@@ -173,24 +188,24 @@ export function isPathWritable(baseDir, targetPath, scope, securityConfig) {
     };
 }
 /**
- * Simple glob pattern matching (supports * and **)
- * This is a simplified version that handles common cases
+ * Простой glob-матчинг (поддерживает * и **).
+ * Упрощённая версия для типовых случаев.
  */
 function matchesGlobPattern(targetPath, baseDir, pattern) {
     const resolvedBaseDir = resolve(baseDir);
     const resolvedTargetPath = resolve(targetPath);
-    // Relative target path used for segment matching
+    // Относительный путь для посегментного матчинга
     const relPath = resolvedTargetPath.startsWith(resolvedBaseDir)
         ? resolvedTargetPath.slice(resolvedBaseDir.length).replace(/^\//, "")
         : resolvedTargetPath;
-    // Handle patterns with ** (recursive directory matching)
+    // Паттерны с ** (рекурсивный матчинг каталогов)
     if (pattern.includes("**")) {
-        // Split on ** to get prefix/suffix segments
+        // Разбить по ** на префикс/суффикс
         const cleaned = pattern.replace(/\/$/, "");
         const [rawPrefix, rawSuffix] = cleaned.split("**");
         const prefix = rawPrefix.replace(/\/$/, "");
         const suffix = rawSuffix.replace(/^\//, "");
-        // Check prefix: everything before ** must match the start of the path
+        // Префикс: всё до ** обязано совпасть с началом пути
         if (prefix) {
             const prefixParts = prefix.split("/").filter(Boolean);
             const relParts = relPath.split("/");
@@ -199,13 +214,13 @@ function matchesGlobPattern(targetPath, baseDir, pattern) {
                     return false;
             }
         }
-        // ** at the end matches everything
+        // ** в конце матчит всё
         if (!suffix)
             return true;
-        // Check suffix against remaining path segments
+        // Суффикс против оставшихся сегментов
         const suffixParts = suffix.split("/").filter(Boolean);
         const relParts = relPath.split("/");
-        // Search for suffix match anywhere in remaining path
+        // Ищем совпадение суффикса в любой позиции оставшегося пути
         for (let start = (prefix ? prefix.split("/").filter(Boolean).length : 0); start <= relParts.length - suffixParts.length; start++) {
             let match = true;
             for (let j = 0; j < suffixParts.length; j++) {
@@ -221,13 +236,13 @@ function matchesGlobPattern(targetPath, baseDir, pattern) {
         }
         return false;
     }
-    // Handle directory patterns (ending with /) without **
+    // Паттерны каталогов (с / на конце) без **
     if (pattern.endsWith("/")) {
         const dirPattern = pattern.slice(0, -1);
         const resolvedDirPattern = resolve(baseDir, dirPattern);
         return isInsideDir(resolvedTargetPath, resolvedDirPattern);
     }
-    // Handle * pattern (single level) without **
+    // Паттерн * (один уровень) без **
     if (pattern.includes("*")) {
         const regexPattern = pattern
             .replace(/\*/g, "[^/\\\\]*")
@@ -237,7 +252,7 @@ function matchesGlobPattern(targetPath, baseDir, pattern) {
         const relativePath = toForwardSlash(resolvedTargetPath.slice(resolvedBaseDir.length + 1));
         return regex.test(relativePath);
     }
-    // Exact match (case-insensitive on win32, where the FS is case-insensitive)
+    // Точное совпадение (на win32 регистронезависимо — там FS такая)
     const exactTarget = resolve(baseDir, pattern);
     if (process.platform === "win32") {
         return resolvedTargetPath.toLowerCase() === exactTarget.toLowerCase();

package/dist/modules/security/protected-paths.js

@@ -0,0 +1,73 @@
+// Soft-guard чувствительных путей (.git, .env, ключи): всегда включён, требует подтверждения.
+// Не жёсткий блок — тул возвращает директиву «спроси пользователя».
+import { resolve, relative } from "path";
+import { toForwardSlash } from "../../tools/path-utils";
+import { logSecurityBlock } from "./audit-log";
+import { t } from "../../i18n/index";
+/**
+ * Чувствительные пути, требующие явного подтверждения (внутренности VCS + секреты/env).
+ * Гард ВСЕГДА ВКЛЮЧЁН, независимо от `security.paths.enabled`, — удаление `.git/config`
+ * или перезапись `.env`/ключей необратимы. Не хард-блок: тул возвращает директиву
+ * «спроси пользователя и жди».
+ */
+const DIR_PATTERNS = [".git", ".hg", ".svn"];
+const EXACT_BASENAMES = [
+    ".env",
+    ".npmrc",
+    ".netrc",
+    ".git-credentials",
+    ".gitconfig",
+];
+const ENV_PREFIX = ".env.";
+const EXT_PATTERNS = [
+    ".key",
+    ".pem",
+    ".p12",
+    ".pfx",
+    ".crt",
+    ".cer",
+    ".secret",
+    ".token",
+];
+/**
+ * Совпавший защищённый паттерн для `targetPath` (относительно `baseDir`)
+ * или `undefined` для обычного пути. Сравнение регистронезависимо
+ * и не зависит от сепаратора (win32-safe).
+ */
+export function matchProtectedPath(baseDir, targetPath) {
+    const rel = toForwardSlash(relative(resolve(baseDir), resolve(targetPath))).toLowerCase();
+    if (!rel)
+        return undefined;
+    for (const dir of DIR_PATTERNS) {
+        if (rel === dir || rel.endsWith(`/${dir}`) || rel.startsWith(`${dir}/`) || rel.includes(`/${dir}/`)) {
+            return `${dir}/`;
+        }
+    }
+    const parts = rel.split("/");
+    const base = parts[parts.length - 1] ?? "";
+    for (const name of EXACT_BASENAMES) {
+        if (base === name)
+            return name;
+    }
+    if (base.startsWith(ENV_PREFIX))
+        return ".env.*";
+    for (const ext of EXT_PATTERNS) {
+        if (base.endsWith(ext))
+            return `*${ext}`;
+    }
+    return undefined;
+}
+/**
+ * Гард для мутирующих файловых тулов: отказ «спроси пользователя» + запись в аудит,
+ * `undefined` — путь обычный. Не хард-блок: пользователь вправе разрешить.
+ */
+export function protectedPathBlock(ctx, targetPath, pathLabel, action = "file_write") {
+    const pattern = matchProtectedPath(ctx.baseDir, targetPath);
+    if (!pattern)
+        return undefined;
+    logSecurityBlock(ctx.sessionId, action, `Protected path: ${pattern}`, pathLabel);
+    return {
+        success: false,
+        output: `[PROTECTED PATH] ${t("file.protected_path_ask", { path: pathLabel, pattern })}`,
+    };
+}