micro-models-agent 0.47.0 → 0.48.1

package/dist/modules/security/rate-limiter.js

@@ -0,0 +1,119 @@
+/**
+ * Rate limiter for LLM requests
+ * Prevents DoS attacks by limiting the number of requests per time window
+ */
+const DEFAULT_CONFIG = {
+    maxRequestsPerMinute: 60,
+    maxParallelTasks: 5,
+};
+/**
+ * Rate limiter class for tracking LLM requests
+ */
+export class RateLimiter {
+    config;
+    state;
+    lastCleanup = 0;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.state = {
+            requests: [],
+            parallelTasks: 0,
+        };
+    }
+    /**
+     * Check if a new request is allowed
+     * Returns true if the request is allowed, false if rate limited
+     */
+    canMakeRequest() {
+        this.cleanupOldRequests();
+        if (this.state.requests.length >= this.config.maxRequestsPerMinute) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Record a request
+     */
+    recordRequest() {
+        this.cleanupOldRequests();
+        this.state.requests.push(Date.now());
+    }
+    /**
+     * Check if a new parallel task is allowed
+     */
+    canStartParallelTask() {
+        if (this.state.parallelTasks >= this.config.maxParallelTasks) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Start a parallel task
+     */
+    startParallelTask() {
+        this.state.parallelTasks++;
+    }
+    /**
+     * End a parallel task
+     */
+    endParallelTask() {
+        this.state.parallelTasks = Math.max(0, this.state.parallelTasks - 1);
+    }
+    /**
+     * Get current parallel task count
+     */
+    getParallelTaskCount() {
+        return this.state.parallelTasks;
+    }
+    /**
+     * Get remaining requests in current window
+     */
+    getRemainingRequests() {
+        this.cleanupOldRequests();
+        return Math.max(0, this.config.maxRequestsPerMinute - this.state.requests.length);
+    }
+    /**
+     * Clean up old requests (older than 1 minute)
+     */
+    cleanupOldRequests() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60_000;
+        // Only cleanup every 5 seconds to avoid performance overhead
+        if (now - this.lastCleanup < 5000) {
+            return;
+        }
+        this.state.requests = this.state.requests.filter((timestamp) => timestamp > oneMinuteAgo);
+        this.lastCleanup = now;
+    }
+    /**
+     * Reset the rate limiter
+     */
+    reset() {
+        this.state.requests = [];
+        this.state.parallelTasks = 0;
+        this.lastCleanup = 0;
+    }
+    /**
+     * Get rate limit configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Update rate limit configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+/**
+ * Global rate limiter instance
+ * Can be used by LLM provider to enforce rate limits
+ */
+export const globalRateLimiter = new RateLimiter();
+/**
+ * Create a rate limiter with custom configuration
+ */
+export function createRateLimiter(config) {
+    return new RateLimiter(config);
+}

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

@@ -0,0 +1,531 @@
+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: {
+        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 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: {
+        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 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: {
+        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,
+        },
+    },
+};
+/**
+ * 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);
+}