wilfredwake 1.0.0

package/src/cli/config.js

@@ -0,0 +1,263 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════╗
+ * ║                    CLI CONFIG MANAGEMENT                      ║
+ * ║     Handles ~/.wilfredwake/config.json read/write             ║
+ * ║     Stores user preferences, tokens, and settings              ║
+ * ╚═══════════════════════════════════════════════════════════════╝
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Configuration manager for wilfredwake CLI
+ * Handles persistent storage in user's home directory
+ */
+export class ConfigManager {
+  constructor() {
+    // ═══════════════════════════════════════════════════════════════
+    // CONFIG PATHS
+    // ═══════════════════════════════════════════════════════════════
+    this.configDir = path.join(os.homedir(), '.wilfredwake');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.cacheDir = path.join(this.configDir, 'cache');
+
+    // ═══════════════════════════════════════════════════════════════
+    // DEFAULT CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════
+    this.defaultConfig = {
+      version: '1.0.0',
+      orchestratorUrl: 'http://localhost:3000',
+      token: null,
+      environment: 'dev',
+      userId: this._generateUserId(),
+      preferences: {
+        outputFormat: 'table',        // table or json
+        verbose: false,               // Enable debug output
+        autoWait: true,               // Wait for services to be ready
+        timeout: 300,                 // Default timeout in seconds
+        colorOutput: true,            // Enable colored output
+        notifyOnComplete: false,      // Notify when wake completes
+      },
+      environments: {
+        dev: {
+          name: 'Development',
+          orchestratorUrl: 'http://localhost:3000',
+        },
+        staging: {
+          name: 'Staging',
+          orchestratorUrl: 'http://staging-orchestrator:3000',
+        },
+        prod: {
+          name: 'Production',
+          orchestratorUrl: 'http://prod-orchestrator:3000',
+        },
+      },
+      lastSyncTime: null,
+      cacheExpiry: 3600000, // 1 hour in milliseconds
+    };
+  }
+
+  /**
+   * Generate a unique user ID for multi-developer support
+   * @private
+   * @returns {string} Unique user identifier
+   */
+  _generateUserId() {
+    return `user_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  }
+
+  /**
+   * Initialize configuration directory and files
+   * @returns {Promise<void>}
+   */
+  async init() {
+    try {
+      // Create .wilfredwake directory if it doesn't exist
+      await fs.mkdir(this.configDir, { recursive: true });
+
+      // Create cache directory
+      await fs.mkdir(this.cacheDir, { recursive: true });
+
+      // Create config file with defaults if it doesn't exist
+      const exists = await this._fileExists(this.configFile);
+      if (!exists) {
+        await this.saveConfig(this.defaultConfig);
+      }
+    } catch (error) {
+      throw new Error(`Failed to initialize configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Load configuration from disk
+   * @returns {Promise<Object>} Configuration object
+   */
+  async loadConfig() {
+    try {
+      const exists = await this._fileExists(this.configFile);
+      if (!exists) {
+        await this.init();
+        return this.defaultConfig;
+      }
+
+      const content = await fs.readFile(this.configFile, 'utf-8');
+      const config = JSON.parse(content);
+
+      // Merge with defaults for any missing properties
+      return { ...this.defaultConfig, ...config };
+    } catch (error) {
+      throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Save configuration to disk
+   * @param {Object} config - Configuration object
+   * @returns {Promise<void>}
+   */
+  async saveConfig(config) {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+      const content = JSON.stringify(config, null, 2);
+      await fs.writeFile(this.configFile, content, 'utf-8');
+    } catch (error) {
+      throw new Error(`Failed to save configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Update specific configuration value
+   * @param {string} key - Configuration key (supports dot notation: "preferences.verbose")
+   * @param {any} value - New value
+   * @returns {Promise<Object>} Updated configuration
+   */
+  async updateConfig(key, value) {
+    const config = await this.loadConfig();
+    const keys = key.split('.');
+    let current = config;
+
+    // Navigate to the target object
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!current[keys[i]]) {
+        current[keys[i]] = {};
+      }
+      current = current[keys[i]];
+    }
+
+    // Set the value
+    current[keys[keys.length - 1]] = value;
+
+    await this.saveConfig(config);
+    return config;
+  }
+
+  /**
+   * Get specific configuration value
+   * @param {string} key - Configuration key (supports dot notation)
+   * @returns {Promise<any>} Configuration value
+   */
+  async getConfig(key) {
+    const config = await this.loadConfig();
+    const keys = key.split('.');
+    let current = config;
+
+    for (const k of keys) {
+      current = current?.[k];
+      if (current === undefined) return null;
+    }
+
+    return current;
+  }
+
+  /**
+   * Cache data for quick retrieval
+   * @param {string} key - Cache key
+   * @param {any} data - Data to cache
+   * @returns {Promise<void>}
+   */
+  async setCacheData(key, data) {
+    try {
+      const cacheFile = path.join(this.cacheDir, `${key}.json`);
+      const cacheEntry = {
+        timestamp: Date.now(),
+        data,
+      };
+      await fs.writeFile(cacheFile, JSON.stringify(cacheEntry), 'utf-8');
+    } catch (error) {
+      // Silently fail on cache errors
+      console.debug(`Cache write failed for ${key}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Retrieve cached data if not expired
+   * @param {string} key - Cache key
+   * @returns {Promise<any|null>} Cached data or null if expired/not found
+   */
+  async getCacheData(key) {
+    try {
+      const cacheFile = path.join(this.cacheDir, `${key}.json`);
+      const exists = await this._fileExists(cacheFile);
+
+      if (!exists) return null;
+
+      const content = await fs.readFile(cacheFile, 'utf-8');
+      const cacheEntry = JSON.parse(content);
+
+      const config = await this.loadConfig();
+      const isExpired =
+        Date.now() - cacheEntry.timestamp > config.cacheExpiry;
+
+      if (isExpired) {
+        await fs.unlink(cacheFile).catch(() => {});
+        return null;
+      }
+
+      return cacheEntry.data;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Clear all cache
+   * @returns {Promise<void>}
+   */
+  async clearCache() {
+    try {
+      const files = await fs.readdir(this.cacheDir);
+      for (const file of files) {
+        await fs.unlink(path.join(this.cacheDir, file));
+      }
+    } catch (error) {
+      console.debug(`Cache clear failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a file exists
+   * @private
+   * @param {string} filePath - Path to check
+   * @returns {Promise<boolean>} True if file exists
+   */
+  async _fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Reset configuration to defaults
+   * @returns {Promise<void>}
+   */
+  async reset() {
+    await this.saveConfig(this.defaultConfig);
+  }
+}
+
+export default ConfigManager;

package/src/config/services.yaml

@@ -0,0 +1,49 @@
+# ╔═══════════════════════════════════════════════════════════════╗
+# ║              WILFREDWAKE SERVICE REGISTRY                     ║
+# ║    Define all services, environments, and dependencies        ║
+# ║    This is the single source of truth for service mgmt        ║
+# ╚═══════════════════════════════════════════════════════════════╝
+
+# WILFREDWAKE SERVICE REGISTRY (SIMPLIFIED)
+
+# Environment and version
+env: dev
+version: "1.0"
+
+# SERVICES DEFINITION (DEV ONLY)
+services:
+  dev:
+    # Core backend service
+    backend:
+      url: https://pension-backend-rs4h.onrender.com
+      health: /api/health
+      dependsOn: []
+      description: "pension backend Service"
+
+    # Frontend service
+    frontend:
+      url: https://transactions-k6gk.onrender.com
+      health: /health
+      dependsOn: []
+      description: "frontend Service"
+
+    # Payment gateway (producer)
+    payment-gateway:
+      url: https://payment-gateway-7eta.onrender.com
+      health: /health
+      dependsOn: []
+      description: "Payment Event Producer"
+
+    # Notification consumer (event processor)
+    notification-consumer:
+      url: https://notification-service-consumer.onrender.com
+      health: /
+      dependsOn: []
+      description: "Notification Event Consumer"
+
+    # Notification producer
+    notification-producer:
+      url: https://notification-service-producer.onrender.com
+      health: /health
+      dependsOn: []
+      description: "Notification Producer Service"

package/src/orchestrator/orchestrator.js

@@ -0,0 +1,397 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════╗
+ * ║              SERVICE ORCHESTRATOR ENGINE                      ║
+ * ║     Simplified wake logic using /health endpoint              ║
+ * ║     Tracks last wake time and service readiness               ║
+ * ╚═══════════════════════════════════════════════════════════════╝
+ */
+
+import axios from 'axios';
+
+/**
+ * Service state enumeration
+ */
+export const ServiceState = {
+  DEAD: 'dead',             // Service is not responding (initial state)
+  WAKING: 'waking',         // Health check response slow (> 5s threshold)
+  LIVE: 'live',             // Health check responds with 200 OK quickly
+  FAILED: 'failed',         // Health check failed/error
+  UNKNOWN: 'unknown',       // State cannot be determined
+};
+
+/**
+ * Orchestrator class - Manages service wake operations
+ * Uses simplified /health endpoint logic with timestamp tracking
+ */
+export class Orchestrator {
+  constructor(registry) {
+    this.registry = registry;
+    this.serviceStates = new Map();        // Track service states
+    this.lastWakeTime = new Map();         // Track when each service was last woken
+    this.requestTimestamps = new Map();    // Track request/response times
+    this.HEALTH_CHECK_TIMEOUT = 5000;      // 5 second threshold before marking as "waking"
+  }
+
+  /**
+   * Wake services with dependency ordering
+   * NEW LOGIC: Assume all services are dead initially
+   * Just call /health and track timestamps
+   *
+   * @param {string|Array<string>} target - Wake target (all, <service>, <group>)
+   * @param {string} environment - Environment name
+   * @param {Object} options - Wake options
+   * @param {boolean} options.wait - Wait for services to respond
+   * @param {number} options.timeout - Overall timeout in seconds
+   * @returns {Promise<Object>} Wake operation results
+   */
+  async wake(target, environment = 'dev', options = {}) {
+    const { wait = true, timeout = 300 } = options;
+
+    // ═══════════════════════════════════════════════════════════════
+    // RESOLVE WAKE ORDER
+    // ═══════════════════════════════════════════════════════════════
+    let services;
+    try {
+      services = this.registry.resolveWakeOrder(target, environment);
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        services: [],
+      };
+    }
+
+    if (services.length === 0) {
+      return {
+        success: true,
+        error: null,
+        services: [],
+        totalDuration: 0,
+      };
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // ASSUME ALL SERVICES ARE DEAD INITIALLY
+    // NEW: Instead of /wake endpoint, just check /health repeatedly
+    // ═══════════════════════════════════════════════════════════════
+    const results = [];
+    const startTime = Date.now();
+
+    for (const service of services) {
+      const serviceStartTime = Date.now();
+
+      try {
+        // NEW: Mark service as being woken and initiate health check sequence
+        this._logTimestamp(service.name, 'Wake initiated');
+
+        // NEW: Set state to DEAD initially (always assume dead)
+        this._setServiceState(service.name, ServiceState.DEAD);
+        this._recordLastWakeTime(service.name);
+
+        // Check health status (handles timeout internally)
+        const status = await this._checkHealthWithTimeout(
+          service,
+          timeout
+        );
+
+        const duration = Date.now() - serviceStartTime;
+
+        results.push({
+          name: service.name,
+          status,
+          url: service.url,
+          duration,
+          error: null,
+          lastWakeTime: this.lastWakeTime.get(service.name),
+        });
+
+        this._setServiceState(service.name, status);
+      } catch (error) {
+        const duration = Date.now() - serviceStartTime;
+
+        results.push({
+          name: service.name,
+          status: ServiceState.FAILED,
+          url: service.url,
+          duration,
+          error: error.message,
+          lastWakeTime: this.lastWakeTime.get(service.name),
+        });
+
+        this._setServiceState(service.name, ServiceState.FAILED);
+      }
+    }
+
+    const totalDuration = Date.now() - startTime;
+    const allLive = results.every(r => r.status === ServiceState.LIVE);
+
+    return {
+      success: allLive,
+      error: null,
+      services: results,
+      totalDuration,
+    };
+  }
+
+  /**
+   * Get status of services
+   * Returns current state of services (always assumes dead initially)
+   *
+   * @param {string} serviceName - Optional specific service
+   * @param {string} environment - Environment name
+   * @returns {Promise<Object>} Status information
+   */
+  async getStatus(serviceName, environment = 'dev') {
+    const services = serviceName
+      ? [this.registry.getService(serviceName, environment)].filter(Boolean)
+      : this.registry.getServices(environment);
+
+    const statusResults = [];
+
+    for (const service of services) {
+      const status = await this._checkHealthWithTimeout(service, 5); // Quick check
+      
+      statusResults.push({
+        name: service.name,
+        status,
+        url: service.url,
+        lastWakeTime: this.lastWakeTime.get(service.name) || null,
+      });
+    }
+
+    return {
+      services: statusResults,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Check health of services
+   * Performs health check without waking
+   *
+   * @param {string} serviceName - Optional specific service
+   * @param {string} environment - Environment name
+   * @returns {Promise<Object>} Health information
+   */
+  async getHealth(serviceName, environment = 'dev') {
+    const services = serviceName
+      ? [this.registry.getService(serviceName, environment)].filter(Boolean)
+      : this.registry.getServices(environment);
+
+    const healthResults = [];
+
+    for (const service of services) {
+      const health = await this._performHealthCheck(service);
+      healthResults.push({
+        name: service.name,
+        status: health.state,
+        url: service.url,
+        statusCode: health.statusCode,
+        responseTime: health.responseTime,
+        lastChecked: new Date().toISOString(),
+        lastWakeTime: this.lastWakeTime.get(service.name) || null,
+        error: health.error,
+        dependencies: service.dependsOn || [],
+      });
+    }
+
+    return {
+      services: healthResults,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * REMOVED: _wakeService - No longer calls /wake endpoint
+   * NEW: Health-based checking with timeout threshold
+   */
+
+  /**
+   * Check health with timeout threshold
+   * NEW: If response takes > 5 seconds, mark as WAKING
+   *      If responds quickly with 200, mark as LIVE
+   *
+   * @private
+   * @param {Object} service - Service definition
+   * @param {number} timeoutSeconds - Overall timeout
+   * @returns {Promise<string>} Service state
+   */
+  async _checkHealthWithTimeout(service, timeoutSeconds = 5) {
+    const startTime = Date.now();
+    const overallTimeoutMs = timeoutSeconds * 1000;
+
+    try {
+      const health = await this._performHealthCheck(service);
+      const responseTime = Date.now() - startTime;
+
+      // ═══════════════════════════════════════════════════════════════
+      // NEW LOGIC: Simple threshold-based state determination
+      // ═══════════════════════════════════════════════════════════════
+      if (health.state === ServiceState.LIVE) {
+        this._logTimestamp(
+          service.name,
+          `Health check OK in ${responseTime}ms`
+        );
+        return ServiceState.LIVE;
+      }
+
+      // If response is slow (> 5 seconds threshold), mark as waking
+      if (responseTime > this.HEALTH_CHECK_TIMEOUT) {
+        this._logTimestamp(
+          service.name,
+          `Health check slow (${responseTime}ms) - marking as waking`
+        );
+        return ServiceState.WAKING;
+      }
+
+      // If it's dead but response came back (non-200), still mark as waking
+      if (health.statusCode === 503 || health.statusCode >= 500) {
+        this._logTimestamp(service.name, `Health returned ${health.statusCode} - marking as waking`);
+        return ServiceState.WAKING;
+      }
+
+      return health.state || ServiceState.UNKNOWN;
+    } catch (error) {
+      this._logTimestamp(service.name, `Health check error: ${error.message}`);
+      return ServiceState.FAILED;
+    }
+  }
+
+  /**
+   * Perform health check on service
+   * NEW: Simple /health endpoint call with timeout tracking
+   *
+   * @private
+   * @param {Object} service - Service definition
+   * @returns {Promise<Object>} Health check result
+   */
+  async _performHealthCheck(service) {
+    const startTime = Date.now();
+
+    try {
+      const healthUrl = new URL(service.health, service.url).toString();
+
+      this._logTimestamp(service.name, `Requesting ${service.health}`);
+
+      const response = await axios.get(healthUrl, {
+        timeout: 10000,
+        validateStatus: () => true,
+      });
+
+      const responseTime = Date.now() - startTime;
+
+      // ═══════════════════════════════════════════════════════════════
+      // DETERMINE STATE FROM STATUS CODE
+      // ═══════════════════════════════════════════════════════════════
+      let state = ServiceState.UNKNOWN;
+
+      if (response.status < 300) {
+        state = ServiceState.LIVE;  // Changed from READY
+      } else if (response.status === 503) {
+        state = ServiceState.DEAD;  // Changed from SLEEPING
+      } else if (response.status >= 500) {
+        state = ServiceState.FAILED;
+      } else if (response.status >= 400) {
+        state = ServiceState.UNKNOWN;
+      }
+
+      this._logTimestamp(
+        service.name,
+        `Responded ${response.status} in ${responseTime}ms`
+      );
+
+      return {
+        state,
+        statusCode: response.status,
+        responseTime,
+        error: null,
+        uptime: response.data?.uptime || null,
+      };
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+
+      this._logTimestamp(
+        service.name,
+        `Health check failed: ${error.message}`
+      );
+
+      return {
+        state: ServiceState.DEAD,  // Changed: assume dead on error
+        statusCode: null,
+        responseTime,
+        error: error.message,
+        uptime: null,
+      };
+    }
+  }
+
+  /**
+   * Set service state
+   * @private
+   * @param {string} serviceName - Service name
+   * @param {string} state - New state
+   */
+  _setServiceState(serviceName, state) {
+    this.serviceStates.set(serviceName, state);
+  }
+
+  /**
+   * Record the time a service was last woken
+   * NEW: Track when each service wake was initiated
+   *
+   * @private
+   * @param {string} serviceName - Service name
+   */
+  _recordLastWakeTime(serviceName) {
+    const timestamp = new Date().toISOString();
+    this.lastWakeTime.set(serviceName, timestamp);
+  }
+
+  /**
+   * Log a timestamp for service event
+   * NEW: Detailed logging of request/response times
+   *
+   * @private
+   * @param {string} serviceName - Service name
+   * @param {string} message - Event message
+   */
+  _logTimestamp(serviceName, message) {
+    const timestamp = new Date().toLocaleString('en-US', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+    });
+
+    const key = `${serviceName}:${Date.now()}`;
+    this.requestTimestamps.set(key, {
+      service: serviceName,
+      timestamp,
+      message,
+    });
+
+    console.log(`[${timestamp}] ${serviceName}: ${message}`);
+  }
+
+  /**
+   * Wait for specified milliseconds
+   * @private
+   * @param {number} ms - Milliseconds to wait
+   */
+  async _wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Clear service states and wake times
+   * @returns {void}
+   */
+  clearStates() {
+    this.serviceStates.clear();
+    this.lastWakeTime.clear();
+    this.requestTimestamps.clear();
+  }
+}