micro-models-agent 2.11.0 → 2.12.0

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

@@ -1,5 +1,5 @@
 import { DEFAULT_SECURITY_CONFIG } from "../../config/security";
-// Fallback in case DEFAULT_SECURITY_CONFIG is not available
+// Резерв, если DEFAULT_SECURITY_CONFIG недоступен
 const FALLBACK_BASH_CONFIG = {
     enabled: false,
     blacklist: [
@@ -24,77 +24,125 @@ const FALLBACK_BASH_CONFIG = {
 };
 export const DEFAULT_BASH_CONFIG = DEFAULT_SECURITY_CONFIG?.bash || FALLBACK_BASH_CONFIG;
 /**
- * Extract the actual base command from a shell command string.
- * Handles path prefixes, env assignments, and sudo.
+ * Выделить базовую команду из shell-строки.
+ * Учитывает пути, env-присваивания и sudo.
  *
- * Examples:
+ * Примеры:
  *   "/usr/bin/rm -rf /"           → "rm"
  *   "sudo /usr/bin/rm file"       → "rm"
  *   "NODE_ENV=prod node app.js"   → "node"
  *   "env PATH=/x rm -rf /"        → "rm"
- *   "cmd=rm; $cmd -rf /"          → "cmd" (variable indirection — not expanded)
+ *   "cmd=rm; $cmd -rf /"          → "cmd" (переменная не раскрывается)
  *   "powershell Remove-Item x"    → "Remove-Item"
  *   "cmd /c del /s /q"            → "del"
  */
+/** Обёртки, запускающие другую команду; их опции пропускаются. */
+const WRAPPERS = new Set([
+    "sudo",
+    "doas",
+    "env",
+    "command",
+    "exec",
+    "nohup",
+    "nice",
+    "timeout",
+    "stdbuf",
+    "ionice",
+    "setsid",
+    "time",
+]);
+/** Флаги обёрток, съедающие следующий токен как значение. */
+const WRAPPER_VALUE_FLAGS = {
+    sudo: new Set(["-u", "-g", "-p", "-C", "-U", "-h", "-r", "-t", "-c"]),
+    doas: new Set(["-u"]),
+    nice: new Set(["-n", "--adjustment"]),
+    timeout: new Set(["-k", "-s", "--signal", "--kill-after"]),
+    stdbuf: new Set(["-i", "-o", "-e"]),
+    ionice: new Set(["-c", "-n"]),
+};
+/** Пропустить собственные опции/значения обёртки; вернуть следующий индекс. */
+function skipWrapperArgs(tokens, i, wrapper) {
+    const valueFlags = WRAPPER_VALUE_FLAGS[wrapper] ?? new Set();
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (t.startsWith("-")) {
+            i++;
+            if (t.includes("="))
+                continue; // --flag=value самодостаточен
+            if (valueFlags.has(t))
+                i++; // съесть значение флага
+            continue;
+        }
+        // Голое число (timeout 5, nice 10) — никогда не команда.
+        if (/^\d+(?:\.\d+)?[smhd]?$/.test(t)) {
+            i++;
+            continue;
+        }
+        break;
+    }
+    return i;
+}
 function extractBaseCommand(trimmed) {
     const tokens = trimmed.split(/\s+/);
     let i = 0;
-    // Skip env assignments (KEY=val, KEY="val", etc.) and prefixed commands
+    // Пропуск env-присваиваний (KEY=val, KEY="val" и т.п.) и обёрток
+    // (sudo/nice/timeout/stdbuf/…) ВМЕСТЕ с их опциями — иначе
+    // `nice rm file` извлёк бы "nice", и blacklist не увидел бы `rm`.
     while (i < tokens.length) {
         const tok = tokens[i];
         if (/^[a-zA-Z_][a-zA-Z0-9_]*=/.test(tok)) {
             i++;
             continue;
         }
-        if (tok === "sudo" || tok === "env" || tok === "command" || tok === "exec" || tok === "nohup") {
-            i++;
+        if (WRAPPERS.has(tok)) {
+            i = skipWrapperArgs(tokens, i + 1, tok);
             continue;
         }
         break;
     }
     if (i >= tokens.length)
         return tokens[0] ?? "";
-    // Extract basename from path (e.g. /usr/bin/rm → rm). Strip surrounding
-    // quotes first — otherwise `'rm'` / `"rm"` evade the blacklist entirely.
+    // basename из пути (/usr/bin/rm → rm). Сначала снять кавычки —
+    // иначе `'rm'` / `"rm"` полностью обойдут blacklist.
     const raw = tokens[i].replace(/^["']+|["']+$/g, "");
     const parts = raw.split(/[\\/]/);
     const basename = parts[parts.length - 1] || raw;
-    // Strip .exe/.cmd/.bat extensions for blacklist matching (e.g. powershell.exe → powershell)
+    // Срезать .exe/.cmd/.bat для сверки (powershell.exe → powershell)
     return basename.replace(/\.(exe|cmd|bat)$/i, "") || basename;
 }
 /**
- * Check if a shell operator appears as a standalone token in the command.
- * Uses regex with lookbehind/lookahead so that:
- *   "&"  does NOT match "&&"  (AND operator)
- *   "|"  does NOT match "||"  (OR operator)
- *   ">"  does NOT match ">>"  (append)
- *   "2>" does NOT match "2>>" (append stderr)
+ * Есть ли shell-оператор отдельным токеном в команде.
+ * Regex с lookbehind/lookahead, чтобы:
+ *   "&"  НЕ матчил "&&"  (AND)
+ *   "|"  НЕ матчил "||"  (OR)
+ *   ">"  НЕ матчил ">>"  (append)
+ *   "2>" НЕ матчил "2>>" (append stderr)
  */
 function containsOperator(command, op) {
     const escaped = op.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // For single-char operators that are prefixes of multi-char ones,
-    // ensure they don't match when part of a longer sequence.
-    // Note: "&" is no longer in dangerousOperators (&& is legitimate),
-    // but keep the special case for defense-in-depth if manually added.
+    // Односимвольные операторы — префиксы многосимвольных:
+    // не матчить внутри длинной цепочки.
+    // "&" уже не в dangerousOperators (&& легитимен),
+    // спецкейс оставлен на случай ручного добавления.
     if (op === "&")
         return /(?<!&)&(?!&)/.test(command);
     if (op === "|")
         return /(?<!\|)\|(?!\|)/.test(command);
     if (op === ">")
         return /(?<!>)>(?!>)/.test(command);
-    // For everything else (including multi-char like ">>", "2>", "2>>", ";", "`"),
-    // match literally.
+    // Остальное (">>", "2>", "2>>", ";", "`") — буквальное совпадение.
     return new RegExp(escaped).test(command);
 }
 /**
- * Check if a command is allowed based on security configuration
+ * Разрешена ли команда по конфигу безопасности.
+ * Выключенная защита разрешает всё; пустая команда запрещена.
  */
 export function isCommandAllowed(command, securityConfig) {
-    // If security is disabled, allow everything
+    // Выключенная защита разрешает всё
     if (!securityConfig?.enabled) {
         return { allowed: true, sanitizedCommand: command };
     }
-    // Ensure config has all required fields
+    // Конфиг должен иметь все поля
     let config = securityConfig;
     if (!config.blacklist || !Array.isArray(config.blacklist)) {
         config = {
@@ -106,8 +154,8 @@ export function isCommandAllowed(command, securityConfig) {
     if (!trimmedCommand) {
         return { allowed: false, reason: "Empty command" };
     }
-    // Shell wrappers are always blocked — they bypass all command validation.
-    // The agent should use the bash tool directly, not shell interpreters.
+    // Shell-обёртки запрещены всегда — они обходят всю валидацию.
+    // Агент использует тул bash напрямую, а не интерпретаторы.
     const ALWAYS_BLOCKED = ["powershell", "pwsh", "cmd"];
     const baseForShellCheck = extractBaseCommand(trimmedCommand);
     if (ALWAYS_BLOCKED.includes(baseForShellCheck)) {
@@ -116,25 +164,25 @@ export function isCommandAllowed(command, securityConfig) {
             reason: `Shell wrapper "${baseForShellCheck}" is blocked — use the bash tool directly`,
         };
     }
-    // Interpreters with -c/-e execute arbitrary code and bypass the blacklist.
-    // Quotes are stripped first (`'bash' -c`), and the name may follow a path
-    // separator (`/bin/bash -c`), so match those too.
+    // Интерпретаторы с -c/-e исполняют произвольный код в обход blacklist.
+    // Кавычки снимаются заранее (`'bash' -c`), имя может идти после пути
+    // (`/bin/bash -c`) — матчить и их.
     const unquotedCommand = trimmedCommand.replace(/["']/g, "");
-    const INTERPRETER_FLAGS = /(?:^|[\\/\s])(?:bash|sh|zsh|dash|python|python3|node|bun|perl|ruby)\s+(?:-c|-e|--command|--eval)\b/;
+    const INTERPRETER_FLAGS = /(?:^|[\\/\s])(?:bash|sh|zsh|dash|python[0-9.]*|pypy[0-9.]*|node(?:js)?|bun|deno|perl|ruby|php|lua)\s+(?:-c|-e|--command|--eval)\b/;
     if (INTERPRETER_FLAGS.test(unquotedCommand)) {
         return { allowed: false, reason: "Interpreter -c/-e invocation is blocked" };
     }
-    // Multi-line commands can hide blacklisted commands after a newline.
+    // Многострочники прячут запрещённые команды после перевода строки.
     if (/\r?\n/.test(trimmedCommand)) {
         return { allowed: false, reason: "Multi-line commands are blocked" };
     }
-    // Chained commands bypass the base-command check (e.g. "echo hi; rm -rf /").
+    // Цепочки обходят проверку базовой команды ("echo hi; rm -rf /").
     if (/[;&|]/.test(trimmedCommand) &&
         /(^|[;&|\s])(rm|del|rd|dd|chmod|chown|wget|curl|nc|netcat|shutdown|reboot|mkfs|fdisk)\b/.test(trimmedCommand)) {
         return { allowed: false, reason: "Command chaining to a dangerous command is blocked" };
     }
-    // Check dangerous operators FIRST — before parsing the base command.
-    // e.g. "curl http://x | bash" must be caught even though curl isn't blacklisted.
+    // Опасные операторы — ПЕРЕД разбором базовой команды:
+    // "curl http://x | bash" ловится, даже если curl не в blacklist.
     if (config.blockDangerousFlags) {
         for (const op of config.dangerousOperators || []) {
             if (containsOperator(trimmedCommand, op)) {
@@ -145,13 +193,13 @@ export function isCommandAllowed(command, securityConfig) {
             }
         }
     }
-    // Extract actual base command (handles paths, env vars, sudo)
+    // Базовая команда (пути, env, sudo уже учтены)
     const baseCommand = extractBaseCommand(trimmedCommand);
-    // Case-insensitive matching: win32/macOS exec is case-insensitive, so
-    // `RM -rf x` must hit the blacklist just like `rm`.
+    // Сравнение регистронезависимо: exec на win32/macOS нечувствителен к регистру,
+    // `RM -rf x` обязан попасть в blacklist как `rm`.
     const blacklistLower = new Set((config.blacklist || []).map((c) => c.toLowerCase()));
     const whitelistLower = (config.whitelist || []).map((c) => c.toLowerCase());
-    // Check whitelist first (if non-empty, only whitelisted commands are allowed)
+    // Whitelist сначала (непустой — разрешены только перечисленные)
     if (whitelistLower.length > 0) {
         if (!whitelistLower.includes(baseCommand.toLowerCase())) {
             return {
@@ -160,14 +208,14 @@ export function isCommandAllowed(command, securityConfig) {
             };
         }
     }
-    // Check blacklist (against the extracted basename, not the raw token)
+    // Blacklist — по извлечённому basename, не по сырому токену
     if (blacklistLower.has(baseCommand.toLowerCase())) {
         return {
             allowed: false,
             reason: `Command "${baseCommand}" is blacklisted`,
         };
     }
-    // Also check the raw first token in case it's a simple name
+    // И сырой первый токен — вдруг это простое имя
     const rawFirst = trimmedCommand
         .split(/\s+/)[0]
         .replace(/^["']+|["']+$/g, "")
@@ -178,10 +226,10 @@ export function isCommandAllowed(command, securityConfig) {
             reason: `Command "${rawFirst}" is blacklisted`,
         };
     }
-    // Check for dangerous flags
+    // Опасные флаги
     if (config.blockDangerousFlags) {
         for (const flag of config.dangerousFlags || []) {
-            // Check for flag as whole word or with equals
+            // Флаг целым словом или с equals
             const flagPattern = new RegExp(`(?:^|\\s)${flag}(?:\\s|$|=)`);
             if (flagPattern.test(trimmedCommand)) {
                 return {
@@ -191,15 +239,15 @@ export function isCommandAllowed(command, securityConfig) {
             }
         }
     }
-    // Command is allowed
+    // Команда разрешена
     return { allowed: true, sanitizedCommand: command };
 }
 /**
- * Sanitize command for logging (remove sensitive information)
- * Uses the same patterns as sanitizeLogMessage for consistency
+ * Санитизация команды для логов (вырезание секретов).
+ * Те же паттерны, что в sanitizeLogMessage, — для консистентности.
  */
 export function sanitizeCommandForLog(command) {
-    // Import patterns from data-sanitizer to maintain consistency
+    // Паттерны из data-sanitizer — для консистентности
     const patterns = [
         /(api[_-]?key|apikey|api_key)\s*[=:\s]\s*["']?([a-zA-Z0-9_-]{10,})["']?/gi,
         /(token|access[_-]?token|auth[_-]?token)\s*[=:\s]\s*["']?([a-zA-Z0-9_-]{10,})["']?/gi,
@@ -215,9 +263,9 @@ export function sanitizeCommandForLog(command) {
     ];
     let sanitized = command;
     for (const pattern of patterns) {
-        // Whole-match replacement for every pattern: capture-group-aware
-        // replacement would re-emit the secret itself for patterns whose only
-        // group IS the value (e.g. "Bearer <token>", sk-...).
+        // Замена целиком по каждому паттерну: замена с учётом групп
+        // переизлучила бы сам секрет для паттернов, где группа И ЕСТЬ значение
+        // (например, "Bearer <token>", sk-...).
         sanitized = sanitized.replace(pattern, "[REDACTED]");
     }
     return sanitized;

package/dist/modules/security/content-scanner.js

@@ -1,9 +1,8 @@
 /**
- * Default dangerous patterns to scan for in file content.
- * NOTE: only genuinely dangerous constructs are listed. Legitimate runtime
- * APIs (process.exit, setTimeout/setInterval, template literals `${}`,
- * backtick strings) are NOT scanned — they are valid JS/TS and blocking
- * them breaks ordinary CLI code (false positives).
+ * Дефолтные опасные паттерны.
+ * В списке только реально опасные конструкции. Легитимные рантайм-API
+ * (process.exit, setTimeout/setInterval, шаблонные литералы `${}`, бэктики)
+ * НЕ сканируются — это валидный JS/TS, их блок ломает обычный CLI-код.
  */
 const DEFAULT_DANGEROUS_PATTERNS = [
     /eval\(/gi,
@@ -24,14 +23,15 @@ const DEFAULT_DANGEROUS_PATTERNS = [
     /curl.*\|.*sh/gi,
 ];
 /**
- * Scan file content for dangerous patterns
+ * Проверить содержимое файла на опасные паттерны.
+ * Выключенный скан и пустой список паттернов разрешают всё.
  */
 export function scanContent(content, filePath, config) {
-    // If scanning is disabled, allow everything
+    // Выключенный скан разрешает всё
     if (!config?.enabled) {
         return { allowed: true };
     }
-    // Use default patterns if none provided
+    // Без своих паттернов — дефолтные
     const patterns = config.dangerousPatterns?.length
         ? config.dangerousPatterns
         : DEFAULT_DANGEROUS_PATTERNS;

package/dist/modules/security/data-sanitizer.js

@@ -1,8 +1,7 @@
-/**
- * Patterns for sensitive data that should be redacted from logs
- */
+// Вырезание секретов (ключи, токены, пароли) из логов, команд и URL.
+/** Паттерны чувствительных данных для редактуры в логах. */
 const SENSITIVE_PATTERNS = [
-    // API keys and tokens in key=value format
+    // Ключи и токены в формате key=value
     {
         pattern: /(api[_-]?key|apikey|api_key)\s*[=:\s]\s*["']?([a-zA-Z0-9_-]{10,})["']?/gi,
         replacement: "$1=[REDACTED]",
@@ -19,7 +18,7 @@ const SENSITIVE_PATTERNS = [
         pattern: /(secret|private[_-]?key|secret[_-]?key)\s*[=:\s]\s*["']?([^\s"'&]+)["']?/gi,
         replacement: "$1=[REDACTED]",
     },
-    // Standalone API keys (not in key=value format)
+    // Отдельные ключи (не key=value)
     {
         pattern: /\bsk-[a-zA-Z0-9_-]{20,}\b/gi,
         replacement: "sk-[REDACTED]",
@@ -40,20 +39,18 @@ const SENSITIVE_PATTERNS = [
         pattern: /\bAKIA[0-9A-Z]{15,}\b/gi,
         replacement: "AKIA[REDACTED]",
     },
-    // Bearer tokens in headers
+    // Bearer-токены в заголовках
     {
         pattern: /Bearer\s+[a-zA-Z0-9_-]{20,}/gi,
         replacement: "Bearer [REDACTED]",
     },
-    // Generic high-entropy strings that look like secrets (30+ chars, mixed case and numbers)
+    // Прочие высокоэнтропийные строки, похожие на секреты (30+ символов)
     {
         pattern: /\b([a-zA-Z0-9_-]{30,})\b/g,
         replacement: "[REDACTED]",
     },
 ];
-/**
- * Sanitize a log message by removing sensitive information
- */
+/** Вычистить секреты из лог-сообщения. */
 export function sanitizeLogMessage(message) {
     let sanitized = message;
     for (const { pattern, replacement } of SENSITIVE_PATTERNS) {
@@ -61,15 +58,11 @@ export function sanitizeLogMessage(message) {
     }
     return sanitized;
 }
-/**
- * Sanitize a command string by removing sensitive information
- */
+/** Вычистить секреты из командной строки. */
 export function sanitizeCommand(command) {
     return sanitizeLogMessage(command);
 }
-/**
- * Sanitize a URL by removing sensitive query parameters
- */
+/** Вычистить секретные query-параметры из URL; не-URL — как лог-сообщение. */
 export function sanitizeUrl(url) {
     try {
         const urlObj = new URL(url);

package/dist/modules/security/encryption.js

@@ -1,31 +1,26 @@
+// Шифрование секретов конфига: AES-256-CBC + HMAC, ключ в ~/.mma/.encryption-key.
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
-import { homedir } from "os";
 import { join } from "path";
 import { readFileSync, writeFileSync, existsSync, copyFileSync } from "fs";
+import { globalMmaDir } from "../../config/paths";
 const DEFAULT_CONFIG = {
-    keyPath: join(homedir(), ".mma", ".encryption-key"),
+    keyPath: join(globalMmaDir(), ".encryption-key"),
     algorithm: "aes-256-gcm",
 };
 const IV_LENGTH = 16;
 const SALT_LENGTH = 16;
 const KEY_LENGTH = 32;
-const AUTH_TAG_LENGTH = 16;
-/**
- * Generate a new encryption key
- */
+/** Сгенерировать новый ключ шифрования. */
 export function generateEncryptionKey() {
     return randomBytes(KEY_LENGTH);
 }
-/**
- * Get or create encryption key from file
- */
+/** Взять ключ из файла или создать новый. */
 export function getOrCreateEncryptionKey(config) {
     const { keyPath } = { ...DEFAULT_CONFIG, ...config };
-    // Ensure directory exists
+    // Каталог обязан существовать
     const dir = join(keyPath, "..");
     if (!existsSync(dir)) {
-        // Note: We can't use mkdirSync here because we're in a pure function
-        // This will be handled by the caller
+        // mkdirSync тут нельзя — чистая функция, создаёт вызывающий
     }
     if (!existsSync(keyPath)) {
         const key = generateEncryptionKey();
@@ -34,8 +29,8 @@ export function getOrCreateEncryptionKey(config) {
             return key;
         }
         catch (e) {
-            // If we can't persist the key, encrypted data would be unrecoverable
-            // on the next run — fail loudly instead of silently degrading.
+            // Без персиста ключа зашифрованное станет невосстановимым при
+            // следующем запуске — падаем громко, а не деградируем молча.
             throw new Error(`Cannot write encryption key to ${keyPath}: ${errMsg(e)}`);
         }
     }
@@ -44,13 +39,13 @@ export function getOrCreateEncryptionKey(config) {
         return Buffer.from(keyBase64, "base64");
     }
     catch {
-        // Backup the corrupted key file before throwing
+        // Битый ключ бэкапим перед выбросом
         try {
             const backupPath = `${keyPath}.corrupted.${Date.now()}`;
             copyFileSync(keyPath, backupPath);
         }
         catch {
-            /* backup failed, continue */
+            /* бэкап не удался, идём дальше */
         }
         throw new Error(`Encryption key file is corrupted or unreadable: ${keyPath}. ` +
             `All previously encrypted data will be unrecoverable. ` +
@@ -58,32 +53,30 @@ export function getOrCreateEncryptionKey(config) {
     }
 }
 /**
- * Encrypt a string using AES-256-GCM
- * Note: Bun's crypto module doesn't support getAuthTag/setAuthTag directly,
- * so we use a simpler approach with AES-256-CBC + HMAC for authentication
+ * Зашифровать строку (AES-256-GCM).
+ * В crypto Bun нет getAuthTag/setAuthTag напрямую, поэтому проще:
+ * AES-256-CBC + HMAC для аутентификации.
  */
 export function encryptString(plaintext, key) {
     const iv = randomBytes(IV_LENGTH);
     const salt = randomBytes(SALT_LENGTH);
-    // Derive encryption key and HMAC key from the main key
+    // Ключ шифрования и HMAC-ключ выводятся из главного ключа
     const encKey = scryptSync(key, salt, KEY_LENGTH);
     const hmacSalt = Buffer.concat([salt, Buffer.from([1, 2, 3, 4])]);
     const hmacKey = scryptSync(key, hmacSalt, KEY_LENGTH);
-    // Encrypt with AES-256-CBC
+    // Шифрование AES-256-CBC
     const cipher = createCipheriv("aes-256-cbc", encKey, iv);
     let encrypted = cipher.update(plaintext, "utf8", "base64");
     encrypted += cipher.final("base64");
-    // Create HMAC for authentication
+    // HMAC для аутентификации
     const hmac = createHmac("sha256", hmacKey);
     hmac.update(iv);
     hmac.update(Buffer.from(encrypted, "base64"));
     const authTag = hmac.digest();
-    // Format: salt:iv:authTag:encrypted
+    // Формат: salt:iv:authTag:encrypted
     return `${salt.toString("base64")}:${iv.toString("base64")}:${authTag.toString("base64")}:${encrypted}`;
 }
-/**
- * Decrypt a string using AES-256-CBC + HMAC
- */
+/** Расшифровать строку (AES-256-CBC + HMAC). */
 export function decryptString(encryptedText, key) {
     const parts = encryptedText.split(":");
     if (parts.length !== 4) {
@@ -93,11 +86,11 @@ export function decryptString(encryptedText, key) {
     const iv = Buffer.from(parts[1], "base64");
     const authTag = Buffer.from(parts[2], "base64");
     const encrypted = parts[3];
-    // Derive encryption key and HMAC key from the main key
+    // Ключ шифрования и HMAC-ключ выводятся из главного ключа
     const encKey = scryptSync(key, salt, KEY_LENGTH);
     const hmacSalt = Buffer.concat([salt, Buffer.from([1, 2, 3, 4])]);
     const hmacKey = scryptSync(key, hmacSalt, KEY_LENGTH);
-    // Verify HMAC
+    // Проверка HMAC
     const hmac = createHmac("sha256", hmacKey);
     hmac.update(iv);
     hmac.update(Buffer.from(encrypted, "base64"));
@@ -105,7 +98,7 @@ export function decryptString(encryptedText, key) {
     if (computedTag.length !== authTag.length || !timingSafeEqual(computedTag, authTag)) {
         throw new Error("Authentication failed: invalid tag");
     }
-    // Decrypt with AES-256-CBC
+    // Расшифровка AES-256-CBC
     const decipher = createDecipheriv("aes-256-cbc", encKey, iv);
     let decrypted = decipher.update(encrypted, "base64", "utf8");
     decrypted += decipher.final("utf8");
@@ -113,23 +106,18 @@ export function decryptString(encryptedText, key) {
 }
 import { createHmac } from "node:crypto";
 import { errMsg } from "../../utils";
-/**
- * Check if a string looks like it's encrypted
- */
+/** Похоже ли значение на зашифрованное (формат salt:iv:authTag:encrypted). */
 export function isEncryptedString(value) {
-    // Encrypted strings have the format: salt:iv:authTag:encrypted
-    // Each part is base64 encoded and separated by colons
+    // Формат: salt:iv:authTag:encrypted, каждая часть — base64 через двоеточие
     const parts = value.split(":");
     if (parts.length !== 4)
         return false;
-    // Strict base64 shape check: Buffer.from(value, "base64") NEVER throws
-    // (lenient decode), so it cannot distinguish plaintext from base64.
+    // Строгая проверка формы base64: Buffer.from(value, "base64") НИКОГДА не бросает
+    // (ленивое декодирование), так что plaintext от base64 он не отличит.
     const isB64 = (s) => s.length > 0 && s.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(s);
     return parts.every(isB64);
 }
-/**
- * Sensitive field names that should be encrypted
- */
+/** Имена чувствительных полей для шифрования. */
 export const SENSITIVE_FIELD_NAMES = [
     "api_key",
     "apikey",
@@ -147,16 +135,12 @@ export const SENSITIVE_FIELD_NAMES = [
     "authorization",
     "key",
 ];
-/**
- * Check if a field name indicates sensitive data
- */
+/** Имя поля указывает на чувствительные данные или нет. */
 export function isSensitiveFieldName(fieldName) {
     const lowerFieldName = fieldName.toLowerCase();
     return SENSITIVE_FIELD_NAMES.some((name) => lowerFieldName.includes(name));
 }
-/**
- * Encrypt sensitive fields in an object
- */
+/** Зашифровать чувствительные поля объекта (рекурсивно, RegExp не трогает). */
 export function encryptSensitiveFields(obj, key) {
     const result = {};
     for (const [fieldName, value] of Object.entries(obj)) {
@@ -182,9 +166,7 @@ export function encryptSensitiveFields(obj, key) {
     }
     return result;
 }
-/**
- * Decrypt sensitive fields in an object
- */
+/** Расшифровать чувствительные поля объекта; неудача — оставить как есть. */
 export function decryptSensitiveFields(obj, key) {
     const result = {};
     for (const [fieldName, value] of Object.entries(obj)) {
@@ -193,7 +175,7 @@ export function decryptSensitiveFields(obj, key) {
                 result[fieldName] = decryptString(value, key);
             }
             catch {
-                // If decryption fails, keep the encrypted value
+                // Расшифровка не удалась — оставить зашифрованное значение
                 result[fieldName] = value;
             }
         }
@@ -216,9 +198,7 @@ export function decryptSensitiveFields(obj, key) {
     }
     return result;
 }
-/**
- * Create a wrapper for encrypting/decrypting config values
- */
+/** Обёртка шифрования/расшифровки значений конфига. */
 export class ConfigEncryptor {
     key;
     constructor(config) {

package/dist/modules/security/index.js

@@ -1,3 +1,4 @@
+// Публичный фасад модуля безопасности: валидаторы, аудит, шифрование, политики.
 export * from "./command-validator";
 export * from "./path-validator";
 export * from "./network-validator";
@@ -10,5 +11,5 @@ export * from "./session-isolation";
 export * from "./session-encryption";
 export * from "./audit-notifier";
 export * from "./security-policies";
-// Re-export sanitizeUrl from network-validator to avoid conflicts
+// Реэкспорт sanitizeUrl из network-validator — единый источник (без конфликтов)
 export { sanitizeUrl } from "./network-validator";