micro-models-agent 2.16.1 → 2.17.2

package/dist/modules/security/security-policies.js

@@ -1,499 +0,0 @@
-import { mergeSecurityConfig } from "../../config/security";
-/**
- * Strict: максимум безопасности, минимум гибкости.
- * Для: продакшн, чувствительные данные, многопользовательские системы.
- */
-export const STRICT_POLICY = {
-    name: "Strict",
-    description: "Maximum security with minimal flexibility. Blocks most dangerous operations.",
-    preset: "strict",
-    recommendedFor: ["production", "sensitive-data", "multi-user", "enterprise"],
-    config: {
-        enabled: true,
-        bash: {
-            enabled: true,
-            blacklist: [
-                "rm",
-                "dd",
-                "chmod",
-                "wget",
-                "curl",
-                "scp",
-                "ssh",
-                "nc",
-                "netcat",
-                "mknod",
-                "mkfifo",
-                "ln",
-                "chown",
-                "chgrp",
-                "useradd",
-                "usermod",
-                "passwd",
-                "sudo",
-                "su",
-                "exec",
-                "eval",
-                "source",
-                "kill",
-                "pkill",
-                "killall",
-                "shutdown",
-                "reboot",
-                "halt",
-                "poweroff",
-                "format",
-                "fdisk",
-                "parted",
-                "mkfs",
-                "mount",
-                "umount",
-                "mv",
-                "cp",
-            ],
-            whitelist: ["ls", "cat", "echo", "grep", "find", "pwd", "whoami", "date"],
-            blockDangerousFlags: true,
-            dangerousFlags: [
-                "--force",
-                "-rf",
-                "--no-preserve-root",
-                "--recursive",
-                "--all",
-                "-x",
-                "-e",
-                "--delete",
-                "--remove",
-                "--dangerous",
-                "--yes",
-                "-y",
-                "--no-confirm",
-                "-R",
-                "--no-clobber",
-            ],
-            dangerousOperators: [">", ">>", "2>", "2>>", "|", "&&", "||", ";", "&", "`", "$("],
-            logCommands: true,
-        },
-        paths: {
-            enabled: true,
-            denied: [
-                ".git/",
-                "node_modules/",
-                ".env",
-                "*.key",
-                "*.pem",
-                "*.crt",
-                "*.p12",
-                "*.pfx",
-                "*.secret",
-                "*.token",
-                "package-lock.json",
-                "bun.lock",
-                "yarn.lock",
-                "pnpm-lock.yaml",
-                ".ssh/",
-                ".config/",
-                ".bashrc",
-                ".bash_profile",
-                ".zshrc",
-                ".profile",
-                "/etc/",
-                "/usr/",
-                "/var/",
-                "/bin/",
-                "/sbin/",
-                "/root/",
-                "/home/",
-            ],
-            allowed: [],
-        },
-        network: {
-            enabled: true,
-            deniedDomains: [
-                "localhost",
-                "127.0.0.1",
-                "0.0.0.0",
-                "::1",
-                "*.internal",
-                "*.local",
-                "192.168.*",
-                "10.*",
-                "172.16.*",
-            ],
-            allowedDomains: [],
-            requestTimeout: 10000,
-            maxResponseSize: 10000,
-        },
-        maxRecursionDepth: 2,
-        maxFileOperations: 50,
-        rateLimits: {
-            maxRequestsPerMinute: 30,
-            maxParallelTasks: 3,
-        },
-        contentScan: {
-            enabled: true,
-            dangerousPatterns: [
-                /eval\(/,
-                /new Function\(/,
-                /child_process\.exec\(/,
-                /child_process\.spawn\(/,
-                /require\('child_process'\)/,
-                /require\('http'\)\.createServer/,
-                /require\('net'\)\.createServer/,
-                /process\.exit\(/,
-                /while\(true\)/,
-                /for\(;;\)/,
-                /rm -rf/,
-                /dd if=/,
-                /chmod 777/,
-                /wget /,
-                /curl /,
-                /ssh /,
-                /scp /,
-            ],
-        },
-        sessionEncryption: {
-            enabled: true,
-            encryptHistory: true,
-            encryptSessionLog: true,
-        },
-        auditNotifier: {
-            enabled: true,
-            minSeverity: "low",
-            eventTypes: [
-                "security_block",
-                "bash_command",
-                "file_operation",
-                "network_request",
-                "authentication",
-                "configuration_change",
-                "session_start",
-                "session_end",
-            ],
-            maxRetries: 3,
-        },
-    },
-};
-/**
- * Balanced: вменяемая безопасность с разумной гибкостью.
- * Для: разработка, однопользовательские системы, общее использование.
- */
-export const BALANCED_POLICY = {
-    name: "Balanced",
-    description: "Good security with reasonable flexibility. Default policy.",
-    preset: "balanced",
-    recommendedFor: ["development", "single-user", "general-use", "testing"],
-    config: {
-        enabled: true,
-        bash: {
-            enabled: true,
-            blacklist: [
-                "rm",
-                "dd",
-                "chmod",
-                "wget",
-                "curl",
-                "scp",
-                "ssh",
-                "nc",
-                "netcat",
-                "mknod",
-                "mkfifo",
-                "useradd",
-                "usermod",
-                "passwd",
-                "sudo",
-                "su",
-                "shutdown",
-                "reboot",
-                "halt",
-                "poweroff",
-                "format",
-                "fdisk",
-                "parted",
-                "mkfs",
-            ],
-            whitelist: [],
-            blockDangerousFlags: true,
-            dangerousFlags: [
-                "--force",
-                "-rf",
-                "--no-preserve-root",
-                "--recursive",
-                "--all",
-                "--delete",
-                "--remove",
-                "--dangerous",
-                "--yes",
-                "-y",
-                "--no-confirm",
-            ],
-            dangerousOperators: ["|", "&&", "||", ";", "&", "`"],
-            logCommands: true,
-        },
-        paths: {
-            enabled: true,
-            denied: [
-                ".git/",
-                "node_modules/",
-                ".env",
-                "*.key",
-                "*.pem",
-                "*.crt",
-                "*.p12",
-                "*.pfx",
-                "*.secret",
-                "*.token",
-                "package-lock.json",
-                "bun.lock",
-                "yarn.lock",
-                "pnpm-lock.yaml",
-                ".ssh/",
-            ],
-            allowed: [],
-        },
-        network: {
-            enabled: true,
-            deniedDomains: [],
-            allowedDomains: [],
-            requestTimeout: 15000,
-            maxResponseSize: 15000,
-        },
-        maxRecursionDepth: 3,
-        maxFileOperations: 100,
-        rateLimits: {
-            maxRequestsPerMinute: 60,
-            maxParallelTasks: 5,
-        },
-        contentScan: {
-            enabled: true,
-            dangerousPatterns: [
-                /eval\(/,
-                /new Function\(/,
-                /child_process\.exec\(/,
-                /child_process\.spawn\(/,
-                /require\('child_process'\)/,
-                /process\.exit\(/,
-                /while\(true\)/,
-                /for\(;;\)/,
-                /rm -rf/,
-                /dd if=/,
-                /chmod 777/,
-            ],
-        },
-        sessionEncryption: {
-            enabled: false,
-            encryptHistory: true,
-            encryptSessionLog: true,
-        },
-        auditNotifier: {
-            enabled: false,
-            minSeverity: "medium",
-            eventTypes: ["security_block", "bash_command", "file_operation", "network_request"],
-            maxRetries: 3,
-        },
-    },
-};
-/**
- * Permissive: минимум безопасности, максимум гибкости.
- * Для: доверенные окружения, локальная разработка, тесты.
- */
-export const PERMISSIVE_POLICY = {
-    name: "Permissive",
-    description: "Minimal security with maximum flexibility. Use with caution.",
-    preset: "permissive",
-    recommendedFor: ["trusted-environment", "local-dev", "testing", "sandbox"],
-    config: {
-        enabled: true,
-        bash: {
-            enabled: true,
-            blacklist: [
-                "rm",
-                "dd",
-                "shutdown",
-                "reboot",
-                "halt",
-                "poweroff",
-                "format",
-                "fdisk",
-                "parted",
-                "mkfs",
-            ],
-            whitelist: [],
-            blockDangerousFlags: false,
-            dangerousFlags: ["--force", "-rf", "--no-preserve-root"],
-            dangerousOperators: [],
-            logCommands: true,
-        },
-        paths: {
-            enabled: true,
-            denied: [".env", "*.key", "*.pem", "*.crt", "*.p12", "*.pfx"],
-            allowed: [],
-        },
-        network: {
-            enabled: true,
-            deniedDomains: [],
-            allowedDomains: [],
-            requestTimeout: 30000,
-            maxResponseSize: 30000,
-        },
-        maxRecursionDepth: 5,
-        maxFileOperations: 200,
-        rateLimits: {
-            maxRequestsPerMinute: 120,
-            maxParallelTasks: 10,
-        },
-        contentScan: {
-            enabled: true,
-            dangerousPatterns: [
-                /eval\(/,
-                /new Function\(/,
-                /while\(true\)/,
-                /for\(;;\)/,
-                /rm -rf/,
-                /dd if=/,
-            ],
-        },
-        sessionEncryption: {
-            enabled: false,
-            encryptHistory: false,
-            encryptSessionLog: false,
-        },
-        auditNotifier: {
-            enabled: false,
-            minSeverity: "high",
-            eventTypes: ["security_block"],
-            maxRetries: 2,
-        },
-    },
-};
-/** Все доступные политики безопасности. */
-export const SECURITY_POLICIES = {
-    strict: STRICT_POLICY,
-    balanced: BALANCED_POLICY,
-    permissive: PERMISSIVE_POLICY,
-    custom: {
-        name: "Custom",
-        description: "Custom security configuration",
-        preset: "custom",
-        recommendedFor: [],
-        config: {},
-    },
-};
-/** Менеджер политик безопасности (текущая + кастом). */
-export class SecurityPolicyManager {
-    currentPolicy = "balanced";
-    customConfig = {};
-    /** Все доступные политики. */
-    getPolicies() {
-        return Object.values(SECURITY_POLICIES);
-    }
-    /** Политика по имени (неизвестная — balanced). */
-    getPolicy(preset) {
-        return SECURITY_POLICIES[preset] || SECURITY_POLICIES.balanced;
-    }
-    /** Текущая политика (custom — с кастомным конфигом). */
-    getCurrentPolicy() {
-        if (this.currentPolicy === "custom") {
-            return {
-                ...SECURITY_POLICIES.custom,
-                config: this.customConfig,
-            };
-        }
-        return this.getPolicy(this.currentPolicy);
-    }
-    /** Назначить текущую политику. */
-    setPolicy(preset) {
-        this.currentPolicy = preset;
-    }
-    /** Задать кастомный конфиг (переключает на 'custom'). */
-    setCustomConfig(config) {
-        this.customConfig = config;
-        this.currentPolicy = "custom";
-    }
-    /** Текущий security-конфиг (политика + мерж дефолтов). */
-    getConfig() {
-        const policy = this.getCurrentPolicy();
-        return mergeSecurityConfig({
-            ...policy.config,
-            ...(this.currentPolicy === "custom" ? this.customConfig : {}),
-        });
-    }
-    /** Применить политику с опциональными оверрайдами; вернуть смерженный конфиг. */
-    applyPolicy(preset, customOverrides) {
-        this.setPolicy(preset);
-        if (customOverrides) {
-            this.customConfig = customOverrides;
-            this.currentPolicy = "custom";
-        }
-        return this.getConfig();
-    }
-    /** Рекомендованная политика для кейса (иначе — balanced). */
-    getRecommendation(useCase) {
-        for (const policy of this.getPolicies()) {
-            if (policy.recommendedFor.includes(useCase)) {
-                return policy;
-            }
-        }
-        return BALANCED_POLICY;
-    }
-    /** Разрешает ли текущая политика действие (bash/file_access/network). */
-    allowsAction(action, context) {
-        const config = this.getConfig();
-        switch (action) {
-            case "bash":
-                if (context?.command) {
-                    const cmd = context.command.split(" ")[0];
-                    return !config.bash.blacklist.includes(cmd);
-                }
-                return true;
-            case "file_access":
-                if (context?.path) {
-                    for (const denied of config.paths.denied) {
-                        if (context.path.includes(denied.replace("*", ""))) {
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            case "network":
-                if (context?.path) {
-                    for (const denied of config.network.deniedDomains) {
-                        if (context.path.includes(denied.replace("*", ""))) {
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            default:
-                return true;
-        }
-    }
-    /** Посравнить две политики по ключам конфига. */
-    comparePolicies(policy1, policy2) {
-        const config1 = this.getPolicy(policy1).config;
-        const config2 = this.getPolicy(policy2).config;
-        const comparison = {};
-        const keys = new Set([...Object.keys(config1), ...Object.keys(config2)]);
-        for (const key of keys) {
-            comparison[key] = {
-                policy1: config1[key],
-                policy2: config2[key],
-            };
-        }
-        return comparison;
-    }
-}
-/** Глобальный менеджер политик. */
-export const globalSecurityPolicyManager = new SecurityPolicyManager();
-/** Создать менеджер политик. */
-export function createSecurityPolicyManager() {
-    return new SecurityPolicyManager();
-}
-/** Политика по имени через глобальный менеджер. */
-export function getSecurityPolicy(preset) {
-    return globalSecurityPolicyManager.getPolicy(preset);
-}
-/** Применить политику через глобальный менеджер. */
-export function applySecurityPolicy(preset, customOverrides) {
-    return globalSecurityPolicyManager.applyPolicy(preset, customOverrides);
-}

package/dist/modules/security/session-encryption.js

@@ -1,182 +0,0 @@
-// Шифрование файлов сессий (history.jsonl, session.jsonl): чтение/запись/append.
-import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync } from "fs";
-import { join } from "path";
-import { encryptString, decryptString, isEncryptedString, ConfigEncryptor, } from "./encryption";
-import { defaultOutputBus } from "../../output";
-import { globalMmaDir } from "../../config/paths";
-/** Дефолтный конфиг шифрования сессии (выключено). */
-export const DEFAULT_SESSION_ENCRYPTION = {
-    enabled: false,
-    encryptHistory: true,
-    encryptSessionLog: true,
-};
-/** Шифровальщик/расшифровщик файлов сессии. */
-export class SessionFileEncryptor {
-    config;
-    encryptor;
-    constructor(config) {
-        this.config = { ...DEFAULT_SESSION_ENCRYPTION, ...config };
-        this.encryptor = new ConfigEncryptor({
-            keyPath: config?.keyPath || join(globalMmaDir(), ".session-encryption-key"),
-        });
-    }
-    /** Включено ли шифрование файлов сессии. */
-    isEnabled() {
-        return this.config.enabled;
-    }
-    /** Зашифровать содержимое файла сессии. */
-    encryptFileContent(content) {
-        if (!this.config.enabled)
-            return content;
-        return encryptString(content, this.encryptor.getKey());
-    }
-    /** Расшифровать содержимое файла сессии (plain text — как есть). */
-    decryptFileContent(content) {
-        if (!this.config.enabled)
-            return content;
-        if (!isEncryptedString(content))
-            return content;
-        return decryptString(content, this.encryptor.getKey());
-    }
-    /** Зашифровать JSON-объект (для структурных файлов). */
-    encryptJSON(obj) {
-        if (!this.config.enabled)
-            return JSON.stringify(obj);
-        return this.encryptFileContent(JSON.stringify(obj));
-    }
-    /** Расшифровать JSON-строку; мусор — ошибка. */
-    decryptJSON(content) {
-        let plain = content;
-        if (this.config.enabled) {
-            plain = this.decryptFileContent(content);
-        }
-        try {
-            return JSON.parse(plain);
-        }
-        catch {
-            throw new Error("Invalid JSON content in session file — file may be corrupted or encrypted with a different key");
-        }
-    }
-    /** Зашифровать JSONL-файл (по строке на объект). */
-    encryptJSONL(lines) {
-        if (!this.config.enabled)
-            return lines;
-        return lines.map((line) => this.encryptFileContent(line));
-    }
-    /**
-     * Расшифровать JSONL. Строка с ошибкой (битая, оборванная крашем, чужой
-     * plaintext) логируется и ПРОПУСКАЕТСЯ — одна плохая строка не должна
-     * убивать всю историю сессии.
-     */
-    decryptJSONL(lines) {
-        if (!this.config.enabled)
-            return lines;
-        return lines.flatMap((line) => {
-            try {
-                return [this.decryptFileContent(line)];
-            }
-            catch (e) {
-                defaultOutputBus.log("error", "security", `[session-encryption] failed to decrypt JSONL line — skipping it: ${e instanceof Error ? e.message : String(e)}`, { persist: true });
-                return [];
-            }
-        });
-    }
-    /** Прочитать и расшифровать файл сессии. */
-    readSessionFile(filePath) {
-        const content = readFileSync(filePath, "utf8");
-        return this.decryptFileContent(content);
-    }
-    /** Зашифровать и записать файл сессии. */
-    writeSessionFile(filePath, content) {
-        const encrypted = this.encryptFileContent(content);
-        writeFileSync(filePath, encrypted, "utf8");
-    }
-    /** Прочитать и расшифровать JSON-файл сессии. */
-    readSessionJSON(filePath) {
-        const content = readFileSync(filePath, "utf8");
-        return this.decryptJSON(content);
-    }
-    /** Зашифровать и записать JSON-файл сессии. */
-    writeSessionJSON(filePath, obj) {
-        const content = this.encryptJSON(obj);
-        writeFileSync(filePath, content, "utf8");
-    }
-    /** Прочитать и расшифровать JSONL-файл сессии (битые строки пропускаются). */
-    readSessionJSONL(filePath) {
-        const content = readFileSync(filePath, "utf8");
-        const lines = content.split("\n").filter((line) => line.trim());
-        const decryptedLines = this.decryptJSONL(lines);
-        // Кривые строки пропускаем, а не роняем весь лог сессии
-        return decryptedLines.flatMap((line) => {
-            try {
-                return [JSON.parse(line)];
-            }
-            catch {
-                return [];
-            }
-        });
-    }
-    /** Добавить зашифрованную запись в JSONL-файл. */
-    appendToSessionJSONL(filePath, obj) {
-        const encryptedLine = this.encryptFileContent(JSON.stringify(obj));
-        writeFileSync(filePath, `${encryptedLine}\n`, {
-            flag: "a",
-            encoding: "utf8",
-        });
-    }
-    /** Зашифровать все файлы каталога сессии (*.enc, оригиналы удаляются). */
-    encryptSessionDirectory(sessionDir) {
-        if (!this.config.enabled)
-            return;
-        const files = readdirSync(sessionDir);
-        for (const file of files) {
-            const filePath = join(sessionDir, file);
-            if (existsSync(filePath) && !file.endsWith(".enc")) {
-                try {
-                    const content = readFileSync(filePath, "utf8");
-                    const encrypted = this.encryptFileContent(content);
-                    writeFileSync(`${filePath}.enc`, encrypted, "utf8");
-                    unlinkSync(filePath);
-                }
-                catch {
-                    // Бинарники и нечитаемое пропускаем
-                }
-            }
-        }
-    }
-    /** Расшифровать все *.enc в каталоге сессии (оригиналы восстанавливаются). */
-    decryptSessionDirectory(sessionDir) {
-        if (!this.config.enabled)
-            return;
-        const files = readdirSync(sessionDir);
-        for (const file of files) {
-            if (file.endsWith(".enc")) {
-                const encFilePath = join(sessionDir, file);
-                const decFilePath = encFilePath.slice(0, -4); // снять .enc
-                try {
-                    const content = readFileSync(encFilePath, "utf8");
-                    const decrypted = this.decryptFileContent(content);
-                    writeFileSync(decFilePath, decrypted, "utf8");
-                    unlinkSync(encFilePath);
-                }
-                catch {
-                    // Нерасшифровываемое пропускаем
-                }
-            }
-        }
-    }
-}
-/** Глобальный шифровальщик файлов сессии. */
-export const globalSessionEncryptor = new SessionFileEncryptor();
-/** Создать шифровальщик файлов сессии с кастомным конфигом. */
-export function createSessionFileEncryptor(config) {
-    return new SessionFileEncryptor(config);
-}
-/** Хелпер: зашифровать объект сообщения (для SessionMessage). */
-export function encryptSessionMessage(msg) {
-    return globalSessionEncryptor.encryptJSON(msg);
-}
-/** Хелпер: расшифровать сообщение сессии. */
-export function decryptSessionMessage(encrypted) {
-    return globalSessionEncryptor.decryptJSON(encrypted);
-}