micro-models-agent 0.24.12 → 0.25.0

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

@@ -0,0 +1,393 @@
+import { mergeSecurityConfig } from '../../config/security';
+/**
+ * Strict security policy - maximum security, minimum flexibility
+ * Recommended for: production environments, sensitive data, multi-user systems
+ */
+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: {
+        bash: {
+            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: {
+            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: {
+            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 security policy - good security with reasonable flexibility
+ * Recommended for: development, single-user systems, general use
+ */
+export const BALANCED_POLICY = {
+    name: 'Balanced',
+    description: 'Good security with reasonable flexibility. Default policy.',
+    preset: 'balanced',
+    recommendedFor: ['development', 'single-user', 'general-use', 'testing'],
+    config: {
+        bash: {
+            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: {
+            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: {
+            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 security policy - minimal security, maximum flexibility
+ * Recommended for: trusted environments, local development, testing
+ */
+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: {
+        bash: {
+            blacklist: [
+                'rm', 'dd', 'shutdown', 'reboot', 'halt', 'poweroff',
+                'format', 'fdisk', 'parted', 'mkfs',
+            ],
+            whitelist: [],
+            blockDangerousFlags: false,
+            dangerousFlags: ['--force', '-rf', '--no-preserve-root'],
+            dangerousOperators: [],
+            logCommands: true,
+        },
+        paths: {
+            denied: ['.env', '*.key', '*.pem', '*.crt', '*.p12', '*.pfx'],
+            allowed: [],
+        },
+        network: {
+            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,
+        },
+    },
+};
+/**
+ * All available security policies
+ */
+export const SECURITY_POLICIES = {
+    strict: STRICT_POLICY,
+    balanced: BALANCED_POLICY,
+    permissive: PERMISSIVE_POLICY,
+    custom: {
+        name: 'Custom',
+        description: 'Custom security configuration',
+        preset: 'custom',
+        recommendedFor: [],
+        config: {},
+    },
+};
+/**
+ * Security policy manager
+ */
+export class SecurityPolicyManager {
+    currentPolicy = 'balanced';
+    customConfig = {};
+    /**
+     * Get all available policies
+     */
+    getPolicies() {
+        return Object.values(SECURITY_POLICIES);
+    }
+    /**
+     * Get a specific policy by name
+     */
+    getPolicy(preset) {
+        return SECURITY_POLICIES[preset] || SECURITY_POLICIES.balanced;
+    }
+    /**
+     * Get the current policy
+     */
+    getCurrentPolicy() {
+        if (this.currentPolicy === 'custom') {
+            return {
+                ...SECURITY_POLICIES.custom,
+                config: this.customConfig,
+            };
+        }
+        return this.getPolicy(this.currentPolicy);
+    }
+    /**
+     * Set the current policy
+     */
+    setPolicy(preset) {
+        this.currentPolicy = preset;
+    }
+    /**
+     * Set custom configuration (for 'custom' preset)
+     */
+    setCustomConfig(config) {
+        this.customConfig = config;
+        this.currentPolicy = 'custom';
+    }
+    /**
+     * Get the current security configuration
+     */
+    getConfig() {
+        const policy = this.getCurrentPolicy();
+        return mergeSecurityConfig({
+            ...policy.config,
+            ...(this.currentPolicy === 'custom' ? this.customConfig : {}),
+        });
+    }
+    /**
+     * Apply a policy and return the merged configuration
+     */
+    applyPolicy(preset, customOverrides) {
+        this.setPolicy(preset);
+        if (customOverrides) {
+            this.customConfig = customOverrides;
+            this.currentPolicy = 'custom';
+        }
+        return this.getConfig();
+    }
+    /**
+     * Get policy recommendation for a use case
+     */
+    getRecommendation(useCase) {
+        for (const policy of this.getPolicies()) {
+            if (policy.recommendedFor.includes(useCase)) {
+                return policy;
+            }
+        }
+        return BALANCED_POLICY;
+    }
+    /**
+     * Check if current policy allows a specific action
+     */
+    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;
+        }
+    }
+    /**
+     * Get policy comparison
+     */
+    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;
+    }
+}
+/**
+ * Global security policy manager instance
+ */
+export const globalSecurityPolicyManager = new SecurityPolicyManager();
+/**
+ * Create a security policy manager with custom configuration
+ */
+export function createSecurityPolicyManager() {
+    return new SecurityPolicyManager();
+}
+/**
+ * Get a policy by name
+ */
+export function getSecurityPolicy(preset) {
+    return globalSecurityPolicyManager.getPolicy(preset);
+}
+/**
+ * Apply a security policy
+ */
+export function applySecurityPolicy(preset, customOverrides) {
+    return globalSecurityPolicyManager.applyPolicy(preset, customOverrides);
+}

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

@@ -0,0 +1,193 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { encryptString, decryptString, isEncryptedString, ConfigEncryptor, } from './encryption';
+/**
+ * Default session encryption configuration
+ */
+export const DEFAULT_SESSION_ENCRYPTION = {
+    enabled: false,
+    encryptHistory: true,
+    encryptSessionLog: true,
+};
+/**
+ * Session file encryptor/decryptor
+ */
+export class SessionFileEncryptor {
+    config;
+    encryptor;
+    constructor(config) {
+        this.config = { ...DEFAULT_SESSION_ENCRYPTION, ...config };
+        this.encryptor = new ConfigEncryptor({
+            keyPath: config?.keyPath || join(homedir(), '.mma', '.session-encryption-key')
+        });
+    }
+    /**
+     * Check if session file encryption is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Encrypt a session file content
+     */
+    encryptFileContent(content) {
+        if (!this.config.enabled)
+            return content;
+        return encryptString(content, this.encryptor.getKey());
+    }
+    /**
+     * Decrypt a session file content
+     */
+    decryptFileContent(content) {
+        if (!this.config.enabled)
+            return content;
+        if (!isEncryptedString(content))
+            return content;
+        return decryptString(content, this.encryptor.getKey());
+    }
+    /**
+     * Encrypt a JSON object (for structured files)
+     */
+    encryptJSON(obj) {
+        if (!this.config.enabled)
+            return JSON.stringify(obj);
+        return this.encryptFileContent(JSON.stringify(obj));
+    }
+    /**
+     * Decrypt a JSON string
+     */
+    decryptJSON(content) {
+        if (!this.config.enabled)
+            return JSON.parse(content);
+        const decrypted = this.decryptFileContent(content);
+        return JSON.parse(decrypted);
+    }
+    /**
+     * Encrypt a JSONL file (one JSON object per line)
+     */
+    encryptJSONL(lines) {
+        if (!this.config.enabled)
+            return lines;
+        return lines.map(line => this.encryptFileContent(line));
+    }
+    /**
+     * Decrypt a JSONL file
+     */
+    decryptJSONL(lines) {
+        if (!this.config.enabled)
+            return lines;
+        return lines.map(line => this.decryptFileContent(line));
+    }
+    /**
+     * Read and decrypt a session file
+     */
+    readSessionFile(filePath) {
+        const content = readFileSync(filePath, 'utf8');
+        return this.decryptFileContent(content);
+    }
+    /**
+     * Write and encrypt a session file
+     */
+    writeSessionFile(filePath, content) {
+        const encrypted = this.encryptFileContent(content);
+        writeFileSync(filePath, encrypted, 'utf8');
+    }
+    /**
+     * Read and decrypt a JSON session file
+     */
+    readSessionJSON(filePath) {
+        const content = readFileSync(filePath, 'utf8');
+        return this.decryptJSON(content);
+    }
+    /**
+     * Write and encrypt a JSON session file
+     */
+    writeSessionJSON(filePath, obj) {
+        const content = this.encryptJSON(obj);
+        writeFileSync(filePath, content, 'utf8');
+    }
+    /**
+     * Read and decrypt a JSONL session file
+     */
+    readSessionJSONL(filePath) {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(line => line.trim());
+        const decryptedLines = this.decryptJSONL(lines);
+        return decryptedLines.map(line => JSON.parse(line));
+    }
+    /**
+     * Append an encrypted entry to a JSONL file
+     */
+    appendToSessionJSONL(filePath, obj) {
+        const encryptedLine = this.encryptFileContent(JSON.stringify(obj));
+        writeFileSync(filePath, encryptedLine + '\n', { flag: 'a', encoding: 'utf8' });
+    }
+    /**
+     * Encrypt all session files in a directory
+     */
+    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 {
+                    // Skip binary files or files we can't read
+                }
+            }
+        }
+    }
+    /**
+     * Decrypt all session files in a directory
+     */
+    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); // Remove .enc
+                try {
+                    const content = readFileSync(encFilePath, 'utf8');
+                    const decrypted = this.decryptFileContent(content);
+                    writeFileSync(decFilePath, decrypted, 'utf8');
+                    unlinkSync(encFilePath);
+                }
+                catch {
+                    // Skip files we can't decrypt
+                }
+            }
+        }
+    }
+}
+/**
+ * Global session file encryptor instance
+ */
+export const globalSessionEncryptor = new SessionFileEncryptor();
+/**
+ * Create a session file encryptor with custom configuration
+ */
+export function createSessionFileEncryptor(config) {
+    return new SessionFileEncryptor(config);
+}
+/**
+ * Helper to encrypt a message object (for SessionMessage)
+ */
+export function encryptSessionMessage(msg) {
+    return globalSessionEncryptor.encryptJSON(msg);
+}
+/**
+ * Helper to decrypt a session message
+ */
+export function decryptSessionMessage(encrypted) {
+    return globalSessionEncryptor.decryptJSON(encrypted);
+}

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

@@ -0,0 +1,95 @@
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+import { mkdirSync, existsSync } from 'fs';
+import { DEFAULT_SECURITY_CONFIG } from '../../config/security';
+/**
+ * Default session isolation configuration
+ */
+export const DEFAULT_SESSION_ISOLATION = {
+    enabled: false,
+    isolatePlugins: true,
+    isolateTempFiles: true,
+};
+/**
+ * Create a session context with isolation
+ */
+export function createSessionContext(sessionId, projectDir, isolationConfig, securityOverrides) {
+    const config = { ...DEFAULT_SESSION_ISOLATION, ...isolationConfig };
+    // Create session-specific temporary directory
+    const baseDir = config.baseDir || join(homedir(), '.mma', 'sessions', sessionId);
+    const tempDir = join(baseDir, 'temp');
+    if (config.isolateTempFiles && !existsSync(tempDir)) {
+        try {
+            mkdirSync(tempDir, { recursive: true, mode: 0o700 });
+        }
+        catch {
+            // If we can't create the temp dir, continue without isolation
+        }
+    }
+    return {
+        sessionId,
+        tempDir,
+        securityOverrides,
+        workingDir: projectDir,
+    };
+}
+/**
+ * Get session-specific security configuration
+ * Merges global security config with session overrides
+ */
+export function getSessionSecurityConfig(globalConfig, sessionContext) {
+    const globalSecurity = globalConfig.security || DEFAULT_SECURITY_CONFIG;
+    const sessionOverrides = sessionContext?.securityOverrides;
+    if (!sessionOverrides) {
+        return globalSecurity;
+    }
+    return {
+        ...globalSecurity,
+        ...sessionOverrides,
+        // Merge nested objects
+        bash: { ...globalSecurity.bash, ...sessionOverrides.bash },
+        paths: { ...globalSecurity.paths, ...sessionOverrides.paths },
+        network: { ...globalSecurity.network, ...sessionOverrides.network },
+        rateLimits: { ...globalSecurity.rateLimits, ...sessionOverrides.rateLimits },
+        contentScan: { ...globalSecurity.contentScan, ...sessionOverrides.contentScan },
+    };
+}
+/**
+ * Get session-specific temporary directory
+ */
+export function getSessionTempDir(sessionContext) {
+    return sessionContext.tempDir;
+}
+/**
+ * Clean up session-specific temporary data
+ */
+export function cleanupSessionTempDir(sessionContext) {
+    // Note: In a real implementation, we would recursively delete the temp dir
+    // For now, we just leave it as the OS will clean up eventually
+    // In production, you might want to implement proper cleanup
+}
+/**
+ * Create a session-specific file path
+ * Ensures the path is within the session's working directory or temp directory
+ */
+export function createSessionFilePath(sessionContext, relativePath, useTempDir = false) {
+    const baseDir = useTempDir ? sessionContext.tempDir : sessionContext.workingDir;
+    return resolve(baseDir, relativePath);
+}
+/**
+ * Check if a path is within the session's allowed directories
+ */
+export function isPathInSessionScope(sessionContext, path) {
+    const resolvedPath = resolve(path);
+    const workingDir = resolve(sessionContext.workingDir);
+    const tempDir = resolve(sessionContext.tempDir);
+    // Check if path is within working directory
+    if (resolvedPath.startsWith(workingDir + '/') || resolvedPath.startsWith(workingDir + '\\')) {
+        return true;
+    }
+    // Check if path is within temp directory
+    if (resolvedPath.startsWith(tempDir + '/') || resolvedPath.startsWith(tempDir + '\\')) {
+        return true;
+    }
+    return false;
+}

package/dist/modules/session/index.js

@@ -0,0 +1,3 @@
+export { SessionStore } from './store';
+export { SessionManager } from './manager';
+export { SessionModule } from './module';