wilfredwake 1.0.0

package/src/cli/commands/init.js

@@ -0,0 +1,192 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════╗
+ * ║              INIT COMMAND - First-Time Setup                  ║
+ * ║     Guides user through configuration initialization           ║
+ * ║     Sets orchestrator URL and API token                       ║
+ * ╚═══════════════════════════════════════════════════════════════╝
+ */
+
+import readline from 'readline';
+import chalk from 'chalk';
+import ConfigManager from '../config.js';
+import { Logger, utils } from '../../shared/logger.js';
+import { format } from '../../shared/colors.js';
+
+const logger = new Logger();
+
+/**
+ * Initialize wilfredwake configuration
+ * Prompts user for orchestrator URL and API token
+ * Creates ~/.wilfredwake/config.json
+ *
+ * @param {Object} options - Command options
+ * @param {string} options.orchestrator - Orchestrator URL
+ * @param {string} options.token - API token
+ */
+export async function initCommand(options) {
+  try {
+    // ═══════════════════════════════════════════════════════════════
+    // INITIALIZATION HEADER
+    // ═══════════════════════════════════════════════════════════════
+    console.log('\n' + chalk.cyanBright.bold('╔════════════════════════════════════╗'));
+    console.log(chalk.cyanBright.bold('║  WILFREDWAKE INITIALIZATION WIZARD  ║'));
+    console.log(chalk.cyanBright.bold('╚════════════════════════════════════╝\n'));
+
+    logger.info('Welcome to wilfredwake! Let\'s set up your environment.');
+
+    const configManager = new ConfigManager();
+    await configManager.init();
+
+    // ═══════════════════════════════════════════════════════════════
+    // GATHER CONFIGURATION DETAILS
+    // ═══════════════════════════════════════════════════════════════
+
+    const answers = await _promptForConfig(options);
+
+    logger.section('Validating Configuration');
+
+    // ═══════════════════════════════════════════════════════════════
+    // VALIDATE ORCHESTRATOR URL
+    // ═══════════════════════════════════════════════════════════════
+    process.stdout.write(
+      chalk.dim(`Validating orchestrator at ${answers.orchestrator}... `)
+    );
+
+    const isReachable = await utils.isUrlReachable(
+      `${answers.orchestrator}/health`,
+      5000
+    );
+
+    if (isReachable) {
+      logger.success('Orchestrator is reachable!');
+    } else {
+      logger.warn(
+        `Could not reach orchestrator. Make sure it's running at ${answers.orchestrator}`
+      );
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // SAVE CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════
+    logger.section('Saving Configuration');
+
+    const config = await configManager.loadConfig();
+    config.orchestratorUrl = answers.orchestrator;
+    if (answers.token) {
+      config.token = answers.token;
+    }
+    config.environment = answers.environment;
+
+    await configManager.saveConfig(config);
+
+    logger.success(`Configuration saved to ${configManager.configFile}`);
+
+    // ═══════════════════════════════════════════════════════════════
+    // COMPLETION MESSAGE
+    // ═══════════════════════════════════════════════════════════════
+    console.log('\n' + chalk.greenBright.bold('✓ Setup Complete!\n'));
+
+    console.log(chalk.cyan('Configuration Summary:'));
+    console.log(chalk.dim(`  • Orchestrator: ${answers.orchestrator}`));
+    console.log(chalk.dim(`  • Environment: ${answers.environment}`));
+    if (answers.token) {
+      console.log(chalk.dim(`  • Token: ${answers.token.substring(0, 10)}...`));
+    }
+    console.log('');
+
+    console.log(chalk.cyan('Next steps:'));
+    console.log(chalk.yellow('  $ wilfredwake status                # Check service status'));
+    console.log(chalk.yellow('  $ wilfredwake wake all              # Wake all services'));
+    console.log(chalk.yellow('  $ wilfredwake --help                # View all commands\n'));
+
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Initialization failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Prompt user for configuration values
+ * @private
+ * @param {Object} options - Pre-provided options
+ * @returns {Promise<Object>} User answers
+ */
+async function _promptForConfig(options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (query) =>
+    new Promise((resolve) => {
+      rl.question(chalk.blueBright(`? ${query}`), resolve);
+    });
+
+  try {
+    // ═══════════════════════════════════════════════════════════════
+    // ORCHESTRATOR URL
+    // ═══════════════════════════════════════════════════════════════
+    let orchestrator = options.orchestrator;
+
+    if (!orchestrator) {
+      console.log(
+        chalk.dim(
+          '\nFirst, we need the URL of your orchestrator service.'
+        )
+      );
+      console.log(
+        chalk.dim(
+          'This is the always-on backend that manages your services.'
+        )
+      );
+      console.log('');
+
+      orchestrator = await question(
+        `Orchestrator URL ${chalk.gray('(default: http://localhost:3000)')} `
+      );
+      orchestrator = orchestrator || 'http://localhost:3000';
+    }
+
+    // Validate URL format
+    if (!utils.isValidUrl(orchestrator)) {
+      throw new Error(`Invalid URL format: ${orchestrator}`);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // ENVIRONMENT SELECTION
+    // ═══════════════════════════════════════════════════════════════
+    console.log('');
+    const envOptions = ['dev', 'staging', 'prod'];
+    let environment = 'dev';
+
+    console.log(chalk.dim('Select your working environment:'));
+    envOptions.forEach((env, idx) => {
+      console.log(chalk.gray(`  ${idx + 1}. ${env}`));
+    });
+
+    const envChoice = await question('Environment (1-3, default: 1) ');
+    const envIdx = parseInt(envChoice || '1') - 1;
+
+    if (envIdx >= 0 && envIdx < envOptions.length) {
+      environment = envOptions[envIdx];
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // API TOKEN (Optional)
+    // ═══════════════════════════════════════════════════════════════
+    console.log('');
+    const token = options.token ||
+      (await question(
+        `API Token ${chalk.gray('(optional, press Enter to skip)')} `
+      ));
+
+    return {
+      orchestrator: orchestrator.trim(),
+      token: token ? token.trim() : null,
+      environment,
+    };
+  } finally {
+    rl.close();
+  }
+}

package/src/cli/commands/status.js

@@ -0,0 +1,180 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════╗
+ * ║           STATUS COMMAND - Check Service Status              ║
+ * ║     Queries orchestrator for real-time service states         ║
+ * ║     Displays status in table or JSON format                   ║
+ * ╚═══════════════════════════════════════════════════════════════╝
+ */
+
+import axios from 'axios';
+import ConfigManager from '../config.js';
+import { Logger, utils } from '../../shared/logger.js';
+import { colors, format } from '../../shared/colors.js';
+import chalk from 'chalk';
+
+const logger = new Logger();
+
+/**
+ * Check status of services
+ * Defaults to showing all services if none specified
+ * Can also filter by specific service or service group
+ *
+ * @param {string} service - Optional service name to filter (defaults to 'all')
+ * @param {Object} options - Command options
+ * @param {string} options.env - Environment (dev, staging, prod)
+ * @param {string} options.format - Output format (table, json)
+ */
+export async function statusCommand(service, options) {
+  try {
+    // ═══════════════════════════════════════════════════════════════
+    // LOAD CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════
+    const configManager = new ConfigManager();
+    const config = await configManager.loadConfig();
+
+    const env = options.env || config.environment;
+    const outputFormat = options.format || config.preferences.outputFormat;
+    // DEFAULT: Show all services if none specified
+    const serviceFilter = service || 'all';
+
+    logger.section('Service Status Check');
+
+    // ═══════════════════════════════════════════════════════════════
+    // FETCH STATUS FROM ORCHESTRATOR
+    // ═══════════════════════════════════════════════════════════════
+    let stopSpinner;
+    try {
+      stopSpinner = logger.spinner('Fetching service status...');
+
+      const response = await axios.get(
+        `${config.orchestratorUrl}/api/status`,
+        {
+          params: {
+            environment: env,
+            service: serviceFilter !== 'all' ? serviceFilter : undefined,
+          },
+          timeout: 10000,
+        }
+      );
+
+      stopSpinner();
+      console.log(''); // New line after spinner
+
+      const services = response.data.services || [];
+
+      // ═══════════════════════════════════════════════════════════════
+      // DISPLAY RESULTS
+      // ═══════════════════════════════════════════════════════════════
+
+      if (outputFormat === 'json') {
+        _displayJsonStatus(services);
+      } else {
+        _displayTableStatus(services, env);
+      }
+
+      // ═══════════════════════════════════════════════════════════════
+      // SUMMARY STATISTICS
+      // ═══════════════════════════════════════════════════════════════
+      _displaySummary(services);
+
+      process.exit(0);
+    } catch (error) {
+      stopSpinner?.();
+      throw error;
+    }
+  } catch (error) {
+    logger.error(`Failed to fetch status: ${error.message}`);
+
+    if (error.code === 'ECONNREFUSED') {
+      console.log(
+        chalk.yellowBright(
+          '\n⚠ Could not connect to orchestrator. Make sure it\'s running.'
+        )
+      );
+      console.log(chalk.dim('Run: wilfredwake init'));
+    }
+
+    process.exit(1);
+  }
+}
+
+/**
+ * Display status in table format with colors
+ * @private
+ * @param {Array} services - Services array
+ * @param {string} environment - Environment name
+ */
+function _displayTableStatus(services, environment) {
+  if (services.length === 0) {
+    logger.info('No services found in registry.');
+    return;
+  }
+
+  console.log(chalk.cyanBright.bold(`\n📊 Services (${environment.toUpperCase()})\n`));
+
+  // ═══════════════════════════════════════════════════════════════
+  // TABLE HEADER
+  // ═══════════════════════════════════════════════════════════════
+  const headers = ['Service', 'Status', 'Last Woken', 'URL'];
+  console.log(format.tableHeader(headers));
+
+  // ═══════════════════════════════════════════════════════════════
+  // TABLE ROWS
+  // ═══════════════════════════════════════════════════════════════
+  services.forEach((service) => {
+    const statusColor = colors.status[service.status] || colors.status.unknown;
+    const lastWoken = service.lastWakeTime
+      ? new Date(service.lastWakeTime).toLocaleString()
+      : 'Never';
+
+    const cells = [
+      chalk.cyan(service.name.padEnd(20)),
+      statusColor(service.status.toUpperCase().padEnd(20)),
+      chalk.yellow(lastWoken.padEnd(20)),
+      chalk.gray(service.url.substring(0, 20).padEnd(20)),
+    ];
+    console.log(format.tableRow(cells));
+  });
+
+  console.log(''); // Spacing
+}
+
+/**
+ * Display status in JSON format
+ * @private
+ * @param {Array} services - Services array
+ */
+function _displayJsonStatus(services) {
+  console.log(JSON.stringify(services, null, 2));
+}
+
+/**
+ * Display summary statistics
+ * @private
+ * @param {Array} services - Services array
+ */
+function _displaySummary(services) {
+  if (services.length === 0) return;
+
+  const stats = {
+    total: services.length,
+    ready: services.filter(s => s.status === 'ready').length,
+    sleeping: services.filter(s => s.status === 'sleeping').length,
+    waking: services.filter(s => s.status === 'waking').length,
+    failed: services.filter(s => s.status === 'failed').length,
+  };
+
+  console.log(chalk.magentaBright.bold('Summary'));
+  console.log(
+    `  ${colors.status.ready('✓')} Ready: ${colors.status.ready(
+      stats.ready
+    )} | ${colors.status.sleeping('⚫')} Sleeping: ${colors.status.sleeping(
+      stats.sleeping
+    )} | ${colors.status.waking('⟳')} Waking: ${colors.status.waking(
+      stats.waking
+    )} | ${colors.status.failed('✗')} Failed: ${colors.status.failed(
+      stats.failed
+    )}`
+  );
+  console.log(`  Total: ${stats.total} services\n`);
+}

package/src/cli/commands/wake.js

@@ -0,0 +1,182 @@
+/**
+ * ╔═══════════════════════════════════════════════════════════════╗
+ * ║           WAKE COMMAND - Wake Services On Demand              ║
+ * ║     Initiates service wake with dependency ordering           ║
+ * ║     Polls health checks until ready or timeout                ║
+ * ╚═══════════════════════════════════════════════════════════════╝
+ */
+
+import axios from 'axios';
+import ConfigManager from '../config.js';
+import { Logger, utils } from '../../shared/logger.js';
+import { colors, format } from '../../shared/colors.js';
+import chalk from 'chalk';
+
+const logger = new Logger();
+
+/**
+ * Wake services on demand
+ * Defaults to waking all services if none specified
+ * Can also wake specific service or service group
+ * Respects dependency order and waits for readiness
+ *
+ * @param {string} target - Wake target (defaults to 'all', or <service>, or <group>)
+ * @param {Object} options - Command options
+ * @param {string} options.env - Environment (dev, staging, prod)
+ * @param {boolean} options.wait - Wait for services to be ready
+ * @param {string} options.timeout - Timeout in seconds
+ */
+export async function wakeCommand(target, options) {
+  try {
+    // ═══════════════════════════════════════════════════════════════
+    // LOAD CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════
+    const configManager = new ConfigManager();
+    const config = await configManager.loadConfig();
+
+    const env = options.env || config.environment;
+    const shouldWait = options.wait !== false;
+    const timeout = parseInt(options.timeout || config.preferences.timeout);
+    // DEFAULT: Wake all services if none specified
+    const wakeTarget = target || 'all';
+
+    logger.section('Service Wake Request');
+
+    logger.info(
+      `Waking ${chalk.cyan(wakeTarget)} in ${chalk.yellow(env)} environment...`
+    );
+
+    // ═══════════════════════════════════════════════════════════════
+    // SEND WAKE REQUEST TO ORCHESTRATOR
+    // ═══════════════════════════════════════════════════════════════
+    let stopSpinner;
+    try {
+      stopSpinner = logger.spinner(
+        `Sending wake request for ${chalk.cyan(wakeTarget)}...`
+      );
+
+      const response = await axios.post(
+        `${config.orchestratorUrl}/api/wake`,
+        {
+          target: wakeTarget,
+          environment: env,
+          wait: shouldWait,
+          timeout,
+        },
+        {
+          timeout: (timeout + 10) * 1000,
+          headers: {
+            Authorization: config.token ? `Bearer ${config.token}` : undefined,
+          },
+        }
+      );
+
+      stopSpinner();
+      console.log(''); // New line after spinner
+
+      // ═══════════════════════════════════════════════════════════════
+      // PROCESS WAKE RESPONSE
+      // ═══════════════════════════════════════════════════════════════
+      const results = response.data;
+
+      _displayWakeResults(results);
+
+      // ═══════════════════════════════════════════════════════════════
+      // DISPLAY FINAL STATUS
+      // ═══════════════════════════════════════════════════════════════
+      if (shouldWait) {
+        _displayFinalStatus(results);
+      }
+
+      process.exit(results.success ? 0 : 1);
+    } catch (error) {
+      stopSpinner?.();
+      throw error;
+    }
+  } catch (error) {
+    if (error.response?.status === 404) {
+      logger.error(`Service not found: ${error.response.data.message}`);
+    } else if (error.code === 'ECONNREFUSED') {
+      logger.error('Could not connect to orchestrator. Is it running?');
+      console.log(chalk.dim('Run: wilfredwake init'));
+    } else {
+      logger.error(`Wake request failed: ${error.message}`);
+    }
+
+    process.exit(1);
+  }
+}
+
+/**
+ * Display wake operation results
+ * @private
+ * @param {Object} results - Wake results from orchestrator
+ */
+function _displayWakeResults(results) {
+  console.log(chalk.cyanBright.bold('\n🌅 Wake Operation Results\n'));
+
+  if (!results.services || results.services.length === 0) {
+    logger.info('No services to wake.');
+    return;
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // SERVICE WAKE TIMELINE
+  // ═══════════════════════════════════════════════════════════════
+  console.log(chalk.cyan('Timeline:'));
+
+  results.services.forEach((service, index) => {
+    const duration = service.duration
+      ? ` (${utils.formatDuration(service.duration)})`
+      : '';
+
+    let statusIndicator;
+    if (service.status === 'live') {
+      statusIndicator = chalk.greenBright('✓');
+    } else if (service.status === 'failed') {
+      statusIndicator = chalk.redBright('✗');
+    } else {
+      statusIndicator = chalk.yellowBright('⟳');
+    }
+
+    const arrow = index < results.services.length - 1 ? '│' : '└';
+    console.log(
+      `  ${chalk.dim(arrow)} ${statusIndicator} ${chalk.cyan(
+        service.name
+      )}${chalk.yellow(duration)}`
+    );
+
+    if (service.error) {
+      console.log(`    ${chalk.redBright(`Error: ${service.error}`)}`);
+    }
+  });
+
+  console.log('');
+}
+
+/**
+ * Display final status summary
+ * @private
+ * @param {Object} results - Wake results from orchestrator
+ */
+function _displayFinalStatus(results) {
+  const succeeded = results.services.filter(s => s.status === 'live').length;
+  const failed = results.services.filter(s => s.status === 'failed').length;
+  const totalTime = utils.formatDuration(results.totalDuration || 0);
+
+  console.log(chalk.magentaBright.bold('✓ Wake Complete\n'));
+
+  console.log(`  ${colors.status.live('✓')} Live: ${colors.status.live(succeeded)}`);
+  if (failed > 0) {
+    console.log(`  ${colors.status.failed('✗')} Failed: ${colors.status.failed(failed)}`);
+  }
+  console.log(`  ${chalk.yellow('⏱')} Total Time: ${chalk.yellow(totalTime)}\n`);
+
+  if (results.success) {
+    logger.success('All services are live!');
+  } else {
+    logger.warn('Some services failed to wake. Check errors above.');
+  }
+
+  console.log('');
+}