@oussema_mili/test-pkg-123 1.1.22

package/utils/prompts.js

@@ -0,0 +1,318 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+
+/**
+ * Prompt for registration token
+ *
+ * @param {string} fenwaveUrl - Fenwave URL to display
+ * @returns {Promise<string>} Registration token
+ */
+export async function promptRegistrationToken(fenwaveUrl) {
+  console.log(chalk.blue('\n📝 Registration Token Required\n'));
+  console.log(chalk.gray(`Get your token from: ${fenwaveUrl}/agent-installer\n`));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'token',
+      message: 'Enter your registration token:',
+      mask: '*',
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'Registration token is required';
+        }
+        if (input.length < 32) {
+          return 'Invalid token format';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return answers.token.trim();
+}
+
+/**
+ * Prompt for confirmation
+ *
+ * @param {string} message - Confirmation message
+ * @param {boolean} defaultValue - Default value (true/false)
+ * @returns {Promise<boolean>} User's answer
+ */
+export async function promptConfirmation(message, defaultValue = true) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue,
+    },
+  ]);
+
+  return answers.confirmed;
+}
+
+/**
+ * Prompt for Docker registry configuration
+ *
+ * @returns {Promise<Object>} Registry configuration
+ */
+export async function promptDockerRegistries() {
+  console.log(chalk.blue('\n🐳 Docker Registry Configuration\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureEcr',
+      message: 'Configure AWS ECR for Fenwave images?',
+      default: true,
+    },
+    {
+      type: 'input',
+      name: 'awsRegion',
+      message: 'AWS Region:',
+      default: 'eu-west-1',
+      when: (answers) => answers.configureEcr,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'AWS Region is required';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'confirm',
+      name: 'addCustomRegistry',
+      message: 'Add custom Docker registry?',
+      default: false,
+    },
+  ]);
+
+  const registries = [];
+
+  if (answers.configureEcr) {
+    registries.push({
+      type: 'ecr',
+      region: answers.awsRegion,
+    });
+  }
+
+  if (answers.addCustomRegistry) {
+    const customRegistry = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'url',
+        message: 'Registry URL:',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Registry URL is required';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Username:',
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Password:',
+        mask: '*',
+      },
+    ]);
+
+    registries.push({
+      type: 'custom',
+      ...customRegistry,
+    });
+  }
+
+  return registries;
+}
+
+/**
+ * Prompt for choice from a list
+ *
+ * @param {string} message - Prompt message
+ * @param {Array} choices - Array of choices
+ * @param {string} defaultChoice - Default choice
+ * @returns {Promise<string>} Selected choice
+ */
+export async function promptChoice(message, choices, defaultChoice) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message,
+      choices,
+      default: defaultChoice,
+    },
+  ]);
+
+  return answers.choice;
+}
+
+/**
+ * Prompt for text input
+ *
+ * @param {string} message - Prompt message
+ * @param {string} defaultValue - Default value
+ * @param {Function} validate - Validation function
+ * @returns {Promise<string>} User input
+ */
+export async function promptInput(message, defaultValue, validate) {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'input',
+      message,
+      default: defaultValue,
+      validate,
+    },
+  ]);
+
+  return answers.input;
+}
+
+/**
+ * Display progress with spinner
+ *
+ * @param {string} message - Progress message
+ * @param {Promise} promise - Promise to await
+ * @returns {Promise} Result of the promise
+ */
+export async function displayProgress(message, promise) {
+  const spinner = ora(message).start();
+
+  try {
+    const result = await promise;
+    spinner.succeed(chalk.green(message));
+    return result;
+  } catch (error) {
+    spinner.fail(chalk.red(`${message} - ${error.message}`));
+    throw error;
+  }
+}
+
+/**
+ * Display success message
+ *
+ * @param {string} message - Success message
+ */
+export function displaySuccess(message) {
+  console.log(chalk.green('✅ ' + message));
+}
+
+/**
+ * Display error message
+ *
+ * @param {string} message - Error message
+ */
+export function displayError(message) {
+  console.log(chalk.red('❌ ' + message));
+}
+
+/**
+ * Display warning message
+ *
+ * @param {string} message - Warning message
+ */
+export function displayWarning(message) {
+  console.log(chalk.yellow('⚠️  ' + message));
+}
+
+/**
+ * Display info message
+ *
+ * @param {string} message - Info message
+ */
+export function displayInfo(message) {
+  console.log(chalk.blue('ℹ️  ' + message));
+}
+
+/**
+ * Display header with decorative border
+ *
+ * @param {string} title - Header title
+ */
+export function displayHeader(title) {
+  const border = '━'.repeat(70);
+  console.log('\n' + chalk.cyan(border));
+  console.log(chalk.cyan.bold(`  ${title}`));
+  console.log(chalk.cyan(border) + '\n');
+}
+
+/**
+ * Display step indicator
+ *
+ * @param {number} current - Current step
+ * @param {number} total - Total steps
+ * @param {string} description - Step description
+ */
+export function displayStep(current, total, description) {
+  console.log(chalk.bold(`\nStep ${current}/${total}: ${description}`));
+}
+
+/**
+ * Display a list of items
+ *
+ * @param {Array} items - Items to display
+ * @param {string} prefix - Prefix for each item (default: '  • ')
+ */
+export function displayList(items, prefix = '  • ') {
+  items.forEach((item) => {
+    console.log(chalk.gray(prefix + item));
+  });
+}
+
+/**
+ * Display key-value pairs
+ *
+ * @param {Object} data - Data to display
+ * @param {string} indent - Indentation (default: '   ')
+ */
+export function displayKeyValue(data, indent = '   ') {
+  Object.entries(data).forEach(([key, value]) => {
+    console.log(chalk.gray(`${indent}${key}: `) + chalk.white(value));
+  });
+}
+
+/**
+ * Clear console
+ */
+export function clearConsole() {
+  console.clear();
+}
+
+/**
+ * Prompt for backend URL
+ *
+ * @param {string} defaultUrl - Default backend URL
+ * @returns {Promise<string>} Backend URL
+ */
+export async function promptBackendUrl(defaultUrl = 'http://localhost:7007') {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'url',
+      message: 'Fenwave Backend URL:',
+      default: defaultUrl,
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'Backend URL is required';
+        }
+        try {
+          new URL(input);
+          return true;
+        } catch (error) {
+          return 'Invalid URL format';
+        }
+      },
+    },
+  ]);
+
+  return answers.url.trim();
+}

package/utils/ssl-certificates.js

@@ -0,0 +1,256 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+// Directory for storing generated certificates
+const CERTS_DIR = path.join(os.homedir(), ".fenwave", "certs");
+
+/**
+ * Ensure the certificates directory exists
+ */
+function ensureCertsDir() {
+  if (!fs.existsSync(CERTS_DIR)) {
+    fs.mkdirSync(CERTS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Check if mkcert is installed and available
+ * @returns {Promise<{installed: boolean, version?: string, error?: string}>}
+ */
+export async function checkMkcertInstalled() {
+  try {
+    const { stdout } = await execAsync("mkcert -version");
+    return {
+      installed: true,
+      version: stdout.trim(),
+    };
+  } catch (error) {
+    return {
+      installed: false,
+      error: "mkcert is not installed. Install it with: brew install mkcert (macOS) or see https://github.com/FiloSottile/mkcert",
+    };
+  }
+}
+
+/**
+ * Install the mkcert CA to the system trust store
+ * This allows browsers to trust locally-generated certificates
+ * @returns {Promise<{success: boolean, message: string, caPath?: string}>}
+ */
+export async function installMkcertCA() {
+  try {
+    // Run mkcert -install to add CA to system trust store
+    await execAsync("mkcert -install");
+
+    // Get the CA root directory
+    const { stdout: caRootDir } = await execAsync("mkcert -CAROOT");
+    const caDir = caRootDir.trim();
+    const caPath = path.join(caDir, "rootCA.pem");
+
+    // Copy CA to our certs directory for easy access
+    ensureCertsDir();
+    const localCAPath = path.join(CERTS_DIR, "rootCA.pem");
+
+    if (fs.existsSync(caPath)) {
+      fs.copyFileSync(caPath, localCAPath);
+    }
+
+    return {
+      success: true,
+      message: "mkcert CA installed successfully",
+      caPath: localCAPath,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to install mkcert CA: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Get the path to the mkcert CA certificate
+ * @returns {Promise<{success: boolean, caPath?: string, error?: string}>}
+ */
+export async function getMkcertCAPath() {
+  try {
+    const { stdout: caRootDir } = await execAsync("mkcert -CAROOT");
+    const caDir = caRootDir.trim();
+    const caPath = path.join(caDir, "rootCA.pem");
+
+    // Also check our local copy
+    const localCAPath = path.join(CERTS_DIR, "rootCA.pem");
+
+    if (fs.existsSync(localCAPath)) {
+      return { success: true, caPath: localCAPath };
+    }
+
+    if (fs.existsSync(caPath)) {
+      // Copy to local for consistency
+      ensureCertsDir();
+      fs.copyFileSync(caPath, localCAPath);
+      return { success: true, caPath: localCAPath };
+    }
+
+    return {
+      success: false,
+      error: "mkcert CA not found. Run 'mkcert -install' first.",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to get mkcert CA path: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Derive a certificate name from domain(s)
+ * @param {string[]} domains - Array of domain names
+ * @returns {string} Sanitized certificate name
+ */
+function deriveCertName(domains) {
+  if (!domains || domains.length === 0) {
+    return "localhost";
+  }
+
+  // Use first domain, remove wildcards and sanitize
+  const firstDomain = domains[0]
+    .replace(/^\*\./, "") // Remove leading wildcard
+    .replace(/[^a-zA-Z0-9.-]/g, "-") // Replace invalid chars
+    .toLowerCase();
+
+  return firstDomain || "localhost";
+}
+
+/**
+ * Generate SSL certificates for the specified domains
+ * @param {string[]} domains - Array of domain names (e.g., ["example.local", "*.example.local"])
+ * @param {string} [certName] - Optional certificate file prefix
+ * @returns {Promise<{success: boolean, certPath?: string, keyPath?: string, message: string}>}
+ */
+export async function generateCertificates(domains, certName) {
+  if (!domains || domains.length === 0) {
+    return {
+      success: false,
+      message: "No domains specified for certificate generation",
+    };
+  }
+
+  // Check mkcert is installed
+  const mkcertCheck = await checkMkcertInstalled();
+  if (!mkcertCheck.installed) {
+    return {
+      success: false,
+      message: mkcertCheck.error,
+    };
+  }
+
+  ensureCertsDir();
+
+  // Derive or use provided cert name
+  const name = certName || deriveCertName(domains);
+  const certPath = path.join(CERTS_DIR, `${name}.pem`);
+  const keyPath = path.join(CERTS_DIR, `${name}-key.pem`);
+
+  try {
+    // Build mkcert command
+    // mkcert -cert-file <cert> -key-file <key> domain1 domain2 ...
+    const domainsArg = domains.map(d => `"${d}"`).join(" ");
+    const command = `mkcert -cert-file "${certPath}" -key-file "${keyPath}" ${domainsArg}`;
+
+    const { stdout, stderr } = await execAsync(command);
+
+    // Verify files were created
+    if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
+      return {
+        success: false,
+        message: "Certificate files were not created",
+      };
+    }
+
+    return {
+      success: true,
+      certPath,
+      keyPath,
+      message: `Generated certificates for: ${domains.join(", ")}`,
+      output: stdout || stderr,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to generate certificates: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Get paths to existing certificates
+ * @param {string} certName - Certificate name/prefix
+ * @returns {{certPath: string, keyPath: string, caPath: string, exists: boolean}}
+ */
+export function getCertificatePaths(certName) {
+  const certPath = path.join(CERTS_DIR, `${certName}.pem`);
+  const keyPath = path.join(CERTS_DIR, `${certName}-key.pem`);
+  const caPath = path.join(CERTS_DIR, "rootCA.pem");
+
+  return {
+    certPath,
+    keyPath,
+    caPath,
+    exists: fs.existsSync(certPath) && fs.existsSync(keyPath),
+  };
+}
+
+/**
+ * Check if certificates exist for a given name
+ * @param {string} certName - Certificate name/prefix
+ * @returns {boolean}
+ */
+export function certificatesExist(certName) {
+  const { exists } = getCertificatePaths(certName);
+  return exists;
+}
+
+/**
+ * Delete certificates for a given name
+ * @param {string} certName - Certificate name/prefix
+ * @returns {{success: boolean, message: string}}
+ */
+export function deleteCertificates(certName) {
+  const { certPath, keyPath } = getCertificatePaths(certName);
+
+  try {
+    if (fs.existsSync(certPath)) {
+      fs.unlinkSync(certPath);
+    }
+    if (fs.existsSync(keyPath)) {
+      fs.unlinkSync(keyPath);
+    }
+    return {
+      success: true,
+      message: `Deleted certificates for: ${certName}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to delete certificates: ${error.message}`,
+    };
+  }
+}
+
+export default {
+  checkMkcertInstalled,
+  installMkcertCA,
+  getMkcertCAPath,
+  generateCertificates,
+  getCertificatePaths,
+  certificatesExist,
+  deleteCertificates,
+  CERTS_DIR,
+};