snow-flow 1.3.0 → 1.3.2

package/dist/config/snow-flow-config.js

@@ -18,7 +18,7 @@ const ConfigSchema = zod_1.z.object({
     system: zod_1.z.object({
         environment: zod_1.z.enum(['development', 'staging', 'production']).default('development'),
         logLevel: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default('info'),
-        dataDir: zod_1.z.string().default(path_1.default.join(os_1.default.homedir(), '.snow-flow')),
+        dataDir: zod_1.z.string().default(process.env.SNOW_FLOW_HOME || path_1.default.join(os_1.default.homedir(), '.snow-flow')),
         maxConcurrentOperations: zod_1.z.number().min(1).max(100).default(10),
         sessionTimeout: zod_1.z.number().min(300000).default(3600000), // 1 hour default
     }),
@@ -26,7 +26,7 @@ const ConfigSchema = zod_1.z.object({
     agents: zod_1.z.object({
         queen: zod_1.z.object({
             maxWorkerAgents: zod_1.z.number().min(1).max(50).default(10),
-            spawnTimeout: zod_1.z.number().min(5000).default(30000),
+            spawnTimeout: zod_1.z.number().min(5000).default(parseInt(process.env.SNOW_FLOW_SPAWN_TIMEOUT || '30000')),
             coordinationInterval: zod_1.z.number().min(1000).default(5000),
             decisionThreshold: zod_1.z.number().min(0).max(1).default(0.7),
             retryAttempts: zod_1.z.number().min(1).max(10).default(3),
@@ -94,33 +94,33 @@ const ConfigSchema = zod_1.z.object({
         servers: zod_1.z.object({
             deployment: zod_1.z.object({
                 enabled: zod_1.z.boolean().default(true),
-                port: zod_1.z.number().min(3000).max(65535).default(3001),
+                port: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.MCP_DEPLOYMENT_PORT || '3001')),
                 host: zod_1.z.string().default('localhost'),
             }),
             intelligent: zod_1.z.object({
                 enabled: zod_1.z.boolean().default(true),
-                port: zod_1.z.number().min(3000).max(65535).default(3002),
+                port: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.MCP_INTELLIGENT_PORT || '3002')),
                 host: zod_1.z.string().default('localhost'),
             }),
             operations: zod_1.z.object({
                 enabled: zod_1.z.boolean().default(true),
-                port: zod_1.z.number().min(3000).max(65535).default(3003),
+                port: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.MCP_OPERATIONS_PORT || '3003')),
                 host: zod_1.z.string().default('localhost'),
             }),
             flowComposer: zod_1.z.object({
                 enabled: zod_1.z.boolean().default(true),
-                port: zod_1.z.number().min(3000).max(65535).default(3004),
+                port: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.MCP_FLOW_COMPOSER_PORT || '3004')),
                 host: zod_1.z.string().default('localhost'),
             }),
             platformDevelopment: zod_1.z.object({
                 enabled: zod_1.z.boolean().default(true),
-                port: zod_1.z.number().min(3000).max(65535).default(3005),
+                port: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.MCP_PLATFORM_DEV_PORT || '3005')),
                 host: zod_1.z.string().default('localhost'),
             }),
         }),
         transport: zod_1.z.object({
             type: zod_1.z.enum(['stdio', 'http', 'websocket']).default('stdio'),
-            timeout: zod_1.z.number().min(5000).default(30000),
+            timeout: zod_1.z.number().min(5000).default(parseInt(process.env.MCP_TIMEOUT || '30000')),
             retryAttempts: zod_1.z.number().min(1).max(10).default(3),
             retryDelay: zod_1.z.number().min(1000).default(5000),
         }),
@@ -149,6 +149,11 @@ const ConfigSchema = zod_1.z.object({
             ttl: zod_1.z.number().min(60000).default(300000), // 5 minutes
             maxSize: zod_1.z.number().min(10).default(50), // MB
         }),
+        oauth: zod_1.z.object({
+            redirectHost: zod_1.z.string().default('localhost'),
+            redirectPort: zod_1.z.number().min(3000).max(65535).default(parseInt(process.env.SNOW_REDIRECT_PORT || '3005')),
+            redirectPath: zod_1.z.string().default('/callback'),
+        }),
     }),
     // Monitoring configuration
     monitoring: zod_1.z.object({
@@ -327,6 +332,43 @@ class SnowFlowConfig {
             env.servicenow = env.servicenow || {};
             env.servicenow.password = process.env.SNOW_PASSWORD;
         }
+        if (process.env.SNOW_AUTH_TYPE) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.authType = process.env.SNOW_AUTH_TYPE;
+        }
+        if (process.env.SNOW_API_VERSION) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.apiVersion = process.env.SNOW_API_VERSION;
+        }
+        if (process.env.SNOW_REQUEST_TIMEOUT) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.timeout = parseInt(process.env.SNOW_REQUEST_TIMEOUT);
+        }
+        if (process.env.SNOW_MAX_RETRIES) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.retryConfig = env.servicenow.retryConfig || {};
+            env.servicenow.retryConfig.maxRetries = parseInt(process.env.SNOW_MAX_RETRIES);
+        }
+        if (process.env.SNOW_RETRY_DELAY) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.retryConfig = env.servicenow.retryConfig || {};
+            env.servicenow.retryConfig.retryDelay = parseInt(process.env.SNOW_RETRY_DELAY);
+        }
+        if (process.env.SNOW_REDIRECT_HOST) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.oauth = env.servicenow.oauth || {};
+            env.servicenow.oauth.redirectHost = process.env.SNOW_REDIRECT_HOST;
+        }
+        if (process.env.SNOW_REDIRECT_PORT) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.oauth = env.servicenow.oauth || {};
+            env.servicenow.oauth.redirectPort = parseInt(process.env.SNOW_REDIRECT_PORT);
+        }
+        if (process.env.SNOW_REDIRECT_PATH) {
+            env.servicenow = env.servicenow || {};
+            env.servicenow.oauth = env.servicenow.oauth || {};
+            env.servicenow.oauth.redirectPath = process.env.SNOW_REDIRECT_PATH;
+        }
         // System settings
         if (process.env.SNOW_FLOW_ENV) {
             env.system = env.system || {};
@@ -336,6 +378,276 @@ class SnowFlowConfig {
             env.system = env.system || {};
             env.system.logLevel = process.env.SNOW_FLOW_LOG_LEVEL;
         }
+        if (process.env.SNOW_FLOW_DATA_DIR) {
+            env.system = env.system || {};
+            env.system.dataDir = process.env.SNOW_FLOW_DATA_DIR;
+        }
+        if (process.env.SNOW_FLOW_MAX_CONCURRENT_OPS) {
+            env.system = env.system || {};
+            env.system.maxConcurrentOperations = parseInt(process.env.SNOW_FLOW_MAX_CONCURRENT_OPS);
+        }
+        if (process.env.SNOW_FLOW_SESSION_TIMEOUT) {
+            env.system = env.system || {};
+            env.system.sessionTimeout = parseInt(process.env.SNOW_FLOW_SESSION_TIMEOUT);
+        }
+        // Agent configuration
+        if (process.env.SNOW_FLOW_MAX_WORKER_AGENTS) {
+            env.agents = env.agents || {};
+            env.agents.queen = env.agents.queen || {};
+            env.agents.queen.maxWorkerAgents = parseInt(process.env.SNOW_FLOW_MAX_WORKER_AGENTS);
+        }
+        if (process.env.SNOW_FLOW_SPAWN_TIMEOUT) {
+            env.agents = env.agents || {};
+            env.agents.queen = env.agents.queen || {};
+            env.agents.queen.spawnTimeout = parseInt(process.env.SNOW_FLOW_SPAWN_TIMEOUT);
+        }
+        if (process.env.SNOW_FLOW_COORDINATION_INTERVAL) {
+            env.agents = env.agents || {};
+            env.agents.queen = env.agents.queen || {};
+            env.agents.queen.coordinationInterval = parseInt(process.env.SNOW_FLOW_COORDINATION_INTERVAL);
+        }
+        if (process.env.SNOW_FLOW_RETRY_ATTEMPTS) {
+            env.agents = env.agents || {};
+            env.agents.queen = env.agents.queen || {};
+            env.agents.queen.retryAttempts = parseInt(process.env.SNOW_FLOW_RETRY_ATTEMPTS);
+        }
+        if (process.env.SNOW_FLOW_HEARTBEAT_INTERVAL) {
+            env.agents = env.agents || {};
+            env.agents.worker = env.agents.worker || {};
+            env.agents.worker.heartbeatInterval = parseInt(process.env.SNOW_FLOW_HEARTBEAT_INTERVAL);
+        }
+        if (process.env.SNOW_FLOW_TASK_TIMEOUT) {
+            env.agents = env.agents || {};
+            env.agents.worker = env.agents.worker || {};
+            env.agents.worker.taskTimeout = parseInt(process.env.SNOW_FLOW_TASK_TIMEOUT);
+        }
+        if (process.env.SNOW_FLOW_MAX_MEMORY_USAGE) {
+            env.agents = env.agents || {};
+            env.agents.worker = env.agents.worker || {};
+            env.agents.worker.maxMemoryUsage = parseInt(process.env.SNOW_FLOW_MAX_MEMORY_USAGE);
+        }
+        if (process.env.SNOW_FLOW_AUTO_SHUTDOWN_IDLE) {
+            env.agents = env.agents || {};
+            env.agents.worker = env.agents.worker || {};
+            env.agents.worker.autoShutdownIdle = parseInt(process.env.SNOW_FLOW_AUTO_SHUTDOWN_IDLE);
+        }
+        // MCP server configuration
+        if (process.env.MCP_DEPLOYMENT_PORT) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            env.mcp.servers.deployment = env.mcp.servers.deployment || {};
+            env.mcp.servers.deployment.port = parseInt(process.env.MCP_DEPLOYMENT_PORT);
+        }
+        if (process.env.MCP_INTELLIGENT_PORT) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            env.mcp.servers.intelligent = env.mcp.servers.intelligent || {};
+            env.mcp.servers.intelligent.port = parseInt(process.env.MCP_INTELLIGENT_PORT);
+        }
+        if (process.env.MCP_OPERATIONS_PORT) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            env.mcp.servers.operations = env.mcp.servers.operations || {};
+            env.mcp.servers.operations.port = parseInt(process.env.MCP_OPERATIONS_PORT);
+        }
+        if (process.env.MCP_FLOW_COMPOSER_PORT) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            env.mcp.servers.flowComposer = env.mcp.servers.flowComposer || {};
+            env.mcp.servers.flowComposer.port = parseInt(process.env.MCP_FLOW_COMPOSER_PORT);
+        }
+        if (process.env.MCP_PLATFORM_DEV_PORT) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            env.mcp.servers.platformDevelopment = env.mcp.servers.platformDevelopment || {};
+            env.mcp.servers.platformDevelopment.port = parseInt(process.env.MCP_PLATFORM_DEV_PORT);
+        }
+        if (process.env.MCP_HOST) {
+            env.mcp = env.mcp || {};
+            env.mcp.servers = env.mcp.servers || {};
+            // Apply to all servers
+            ['deployment', 'intelligent', 'operations', 'flowComposer', 'platformDevelopment'].forEach(server => {
+                env.mcp.servers[server] = env.mcp.servers[server] || {};
+                env.mcp.servers[server].host = process.env.MCP_HOST;
+            });
+        }
+        if (process.env.MCP_TIMEOUT) {
+            env.mcp = env.mcp || {};
+            env.mcp.transport = env.mcp.transport || {};
+            env.mcp.transport.timeout = parseInt(process.env.MCP_TIMEOUT);
+        }
+        if (process.env.MCP_RETRY_ATTEMPTS) {
+            env.mcp = env.mcp || {};
+            env.mcp.transport = env.mcp.transport || {};
+            env.mcp.transport.retryAttempts = parseInt(process.env.MCP_RETRY_ATTEMPTS);
+        }
+        if (process.env.MCP_RETRY_DELAY) {
+            env.mcp = env.mcp || {};
+            env.mcp.transport = env.mcp.transport || {};
+            env.mcp.transport.retryDelay = parseInt(process.env.MCP_RETRY_DELAY);
+        }
+        if (process.env.MCP_AUTH_TOKEN_EXPIRY) {
+            env.mcp = env.mcp || {};
+            env.mcp.authentication = env.mcp.authentication || {};
+            env.mcp.authentication.tokenExpiry = parseInt(process.env.MCP_AUTH_TOKEN_EXPIRY);
+        }
+        // Memory system configuration
+        if (process.env.SNOW_FLOW_DB_PATH) {
+            env.memory = env.memory || {};
+            env.memory.dbPath = process.env.SNOW_FLOW_DB_PATH;
+        }
+        if (process.env.SNOW_FLOW_CACHE_ENABLED) {
+            env.memory = env.memory || {};
+            env.memory.cache = env.memory.cache || {};
+            env.memory.cache.enabled = process.env.SNOW_FLOW_CACHE_ENABLED === 'true';
+        }
+        if (process.env.SNOW_FLOW_CACHE_MAX_SIZE) {
+            env.memory = env.memory || {};
+            env.memory.cache = env.memory.cache || {};
+            env.memory.cache.maxSize = parseInt(process.env.SNOW_FLOW_CACHE_MAX_SIZE);
+        }
+        if (process.env.SNOW_FLOW_CACHE_TTL) {
+            env.memory = env.memory || {};
+            env.memory.cache = env.memory.cache || {};
+            env.memory.cache.ttl = parseInt(process.env.SNOW_FLOW_CACHE_TTL);
+        }
+        if (process.env.SNOW_FLOW_DEFAULT_TTL) {
+            env.memory = env.memory || {};
+            env.memory.ttl = env.memory.ttl || {};
+            env.memory.ttl.default = parseInt(process.env.SNOW_FLOW_DEFAULT_TTL);
+        }
+        if (process.env.SNOW_FLOW_SESSION_TTL) {
+            env.memory = env.memory || {};
+            env.memory.ttl = env.memory.ttl || {};
+            env.memory.ttl.session = parseInt(process.env.SNOW_FLOW_SESSION_TTL);
+        }
+        if (process.env.SNOW_FLOW_ARTIFACT_TTL) {
+            env.memory = env.memory || {};
+            env.memory.ttl = env.memory.ttl || {};
+            env.memory.ttl.artifact = parseInt(process.env.SNOW_FLOW_ARTIFACT_TTL);
+        }
+        if (process.env.SNOW_FLOW_METRIC_TTL) {
+            env.memory = env.memory || {};
+            env.memory.ttl = env.memory.ttl || {};
+            env.memory.ttl.metric = parseInt(process.env.SNOW_FLOW_METRIC_TTL);
+        }
+        if (process.env.SNOW_FLOW_CLEANUP_INTERVAL) {
+            env.memory = env.memory || {};
+            env.memory.cleanup = env.memory.cleanup || {};
+            env.memory.cleanup.interval = parseInt(process.env.SNOW_FLOW_CLEANUP_INTERVAL);
+        }
+        if (process.env.SNOW_FLOW_RETENTION_DAYS) {
+            env.memory = env.memory || {};
+            env.memory.cleanup = env.memory.cleanup || {};
+            env.memory.cleanup.retentionDays = parseInt(process.env.SNOW_FLOW_RETENTION_DAYS);
+        }
+        // Monitoring configuration
+        if (process.env.SNOW_FLOW_PERFORMANCE_ENABLED) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.performance = env.monitoring.performance || {};
+            env.monitoring.performance.enabled = process.env.SNOW_FLOW_PERFORMANCE_ENABLED === 'true';
+        }
+        if (process.env.SNOW_FLOW_SAMPLE_RATE) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.performance = env.monitoring.performance || {};
+            env.monitoring.performance.sampleRate = parseFloat(process.env.SNOW_FLOW_SAMPLE_RATE);
+        }
+        if (process.env.SNOW_FLOW_METRICS_RETENTION) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.performance = env.monitoring.performance || {};
+            env.monitoring.performance.metricsRetention = parseInt(process.env.SNOW_FLOW_METRICS_RETENTION);
+        }
+        if (process.env.SNOW_FLOW_AGGREGATION_INTERVAL) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.performance = env.monitoring.performance || {};
+            env.monitoring.performance.aggregationInterval = parseInt(process.env.SNOW_FLOW_AGGREGATION_INTERVAL);
+        }
+        if (process.env.SNOW_FLOW_HEALTH_CHECK_INTERVAL) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.health = env.monitoring.health || {};
+            env.monitoring.health.checkInterval = parseInt(process.env.SNOW_FLOW_HEALTH_CHECK_INTERVAL);
+        }
+        if (process.env.SNOW_FLOW_MEMORY_THRESHOLD) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.health = env.monitoring.health || {};
+            env.monitoring.health.thresholds = env.monitoring.health.thresholds || {};
+            env.monitoring.health.thresholds.memoryUsage = parseFloat(process.env.SNOW_FLOW_MEMORY_THRESHOLD);
+        }
+        if (process.env.SNOW_FLOW_CPU_THRESHOLD) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.health = env.monitoring.health || {};
+            env.monitoring.health.thresholds = env.monitoring.health.thresholds || {};
+            env.monitoring.health.thresholds.cpuUsage = parseFloat(process.env.SNOW_FLOW_CPU_THRESHOLD);
+        }
+        if (process.env.SNOW_FLOW_ERROR_RATE_THRESHOLD) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.health = env.monitoring.health || {};
+            env.monitoring.health.thresholds = env.monitoring.health.thresholds || {};
+            env.monitoring.health.thresholds.errorRate = parseFloat(process.env.SNOW_FLOW_ERROR_RATE_THRESHOLD);
+        }
+        if (process.env.SNOW_FLOW_WEBHOOK_URL) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.alerts = env.monitoring.alerts || {};
+            env.monitoring.alerts.webhookUrl = process.env.SNOW_FLOW_WEBHOOK_URL;
+        }
+        if (process.env.SNOW_FLOW_ALERT_SEVERITY) {
+            env.monitoring = env.monitoring || {};
+            env.monitoring.alerts = env.monitoring.alerts || {};
+            env.monitoring.alerts.severityThreshold = process.env.SNOW_FLOW_ALERT_SEVERITY;
+        }
+        // Health check thresholds
+        if (process.env.SNOW_FLOW_RESPONSE_TIME_THRESHOLD) {
+            env.health = env.health || {};
+            env.health.thresholds = env.health.thresholds || {};
+            env.health.thresholds.responseTime = parseInt(process.env.SNOW_FLOW_RESPONSE_TIME_THRESHOLD);
+        }
+        if (process.env.SNOW_FLOW_HEALTH_MEMORY_THRESHOLD) {
+            env.health = env.health || {};
+            env.health.thresholds = env.health.thresholds || {};
+            env.health.thresholds.memoryUsage = parseInt(process.env.SNOW_FLOW_HEALTH_MEMORY_THRESHOLD);
+        }
+        if (process.env.SNOW_FLOW_QUEUE_SIZE_THRESHOLD) {
+            env.health = env.health || {};
+            env.health.thresholds = env.health.thresholds || {};
+            env.health.thresholds.queueSize = parseInt(process.env.SNOW_FLOW_QUEUE_SIZE_THRESHOLD);
+        }
+        // Feature flags
+        if (process.env.SNOW_FLOW_AUTO_PERMISSIONS) {
+            env.features = env.features || {};
+            env.features.autoPermissions = process.env.SNOW_FLOW_AUTO_PERMISSIONS === 'true';
+        }
+        if (process.env.SNOW_FLOW_SMART_DISCOVERY) {
+            env.features = env.features || {};
+            env.features.smartDiscovery = process.env.SNOW_FLOW_SMART_DISCOVERY === 'true';
+        }
+        if (process.env.SNOW_FLOW_LIVE_TESTING) {
+            env.features = env.features || {};
+            env.features.liveTesting = process.env.SNOW_FLOW_LIVE_TESTING === 'true';
+        }
+        if (process.env.SNOW_FLOW_AUTO_DEPLOY) {
+            env.features = env.features || {};
+            env.features.autoDeploy = process.env.SNOW_FLOW_AUTO_DEPLOY === 'true';
+        }
+        if (process.env.SNOW_FLOW_AUTO_ROLLBACK) {
+            env.features = env.features || {};
+            env.features.autoRollback = process.env.SNOW_FLOW_AUTO_ROLLBACK === 'true';
+        }
+        if (process.env.SNOW_FLOW_SHARED_MEMORY) {
+            env.features = env.features || {};
+            env.features.sharedMemory = process.env.SNOW_FLOW_SHARED_MEMORY === 'true';
+        }
+        if (process.env.SNOW_FLOW_PROGRESS_MONITORING) {
+            env.features = env.features || {};
+            env.features.progressMonitoring = process.env.SNOW_FLOW_PROGRESS_MONITORING === 'true';
+        }
+        if (process.env.SNOW_FLOW_NEURAL_PATTERNS) {
+            env.features = env.features || {};
+            env.features.neuralPatterns = process.env.SNOW_FLOW_NEURAL_PATTERNS === 'true';
+        }
+        if (process.env.SNOW_FLOW_COGNITIVE_ANALYSIS) {
+            env.features = env.features || {};
+            env.features.cognitiveAnalysis = process.env.SNOW_FLOW_COGNITIVE_ANALYSIS === 'true';
+        }
         return env;
     }
     /**