micro-models-agent 0.28.0 → 0.28.2

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

@@ -1,393 +0,0 @@
-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

@@ -1,193 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

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