easybuild-nox 1.0.0

package/src/commands/env.js

@@ -0,0 +1,302 @@
+const { Command } = require('commander');
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs-extra');
+const crypto = require('crypto');
+const logger = require('../utils/logger');
+
+const envCommand = new Command('env')
+  .description('Manage environment variables')
+  .option('-a, --action <action>', 'Action (list, get, set, generate, validate, encrypt, decrypt)')
+  .option('-e, --env <environment>', 'Environment file (.env, .env.local, .env.production)')
+  .action(async (options) => {
+    logger.header('🔐 Environment Manager');
+
+    try {
+      const action = options.action || 'list';
+
+      const actions = {
+        list: envList,
+        get: envGet,
+        set: envSet,
+        generate: envGenerate,
+        validate: envValidate,
+        encrypt: envEncrypt,
+        decrypt: envDecrypt,
+      };
+
+      const actionFn = actions[action];
+      if (!actionFn) {
+        logger.error(`Unknown action: ${action}`);
+        process.exit(1);
+      }
+
+      await actionFn(options);
+    } catch (error) {
+      logger.error(`Environment operation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+async function envList(options) {
+  const envFile = options.env || '.env';
+  const envPath = path.join(process.cwd(), envFile);
+
+  if (!(await fs.pathExists(envPath))) {
+    logger.warning(`No ${envFile} found`);
+    return;
+  }
+
+  const content = await fs.readFile(envPath, 'utf8');
+  const lines = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+
+  logger.section(`Environment Variables (${envFile})`);
+
+  lines.forEach(line => {
+    const [key, ...valueParts] = line.split('=');
+    const value = valueParts.join('=');
+    const masked = value.length > 20 ? value.substring(0, 10) + '...' + value.substring(value.length - 5) : value;
+    logger.dim(`  ${key} = ${masked}`);
+  });
+
+  logger.info('');
+  logger.info(`Total: ${lines.length} variables`);
+}
+
+async function envGet(options) {
+  const key = options.key;
+  if (!key) {
+    const keyAnswer = await inquirer.prompt([
+      { type: 'input', name: 'key', message: 'Variable name:' },
+    ]);
+    key = keyAnswer.key;
+  }
+
+  const envFile = options.env || '.env';
+  const envPath = path.join(process.cwd(), envFile);
+
+  if (!(await fs.pathExists(envPath))) {
+    logger.warning(`No ${envFile} found`);
+    return;
+  }
+
+  const content = await fs.readFile(envPath, 'utf8');
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    if (line.startsWith(`${key}=`)) {
+      const value = line.split('=').slice(1).join('=');
+      console.log(value);
+      return;
+    }
+  }
+
+  logger.warning(`Variable "${key}" not found`);
+}
+
+async function envSet(options) {
+  let key = options.key;
+  let value = options.value;
+
+  if (!key) {
+    const answers = await inquirer.prompt([
+      { type: 'input', name: 'key', message: 'Variable name:' },
+      { type: 'input', name: 'value', message: 'Value:' },
+    ]);
+    key = answers.key;
+    value = answers.value;
+  }
+
+  const envFile = options.env || '.env';
+  const envPath = path.join(process.cwd(), envFile);
+
+  let content = '';
+  if (await fs.pathExists(envPath)) {
+    content = await fs.readFile(envPath, 'utf8');
+  }
+
+  // Check if key already exists
+  const lines = content.split('\n');
+  const keyIndex = lines.findIndex(line => line.startsWith(`${key}=`));
+
+  if (keyIndex >= 0) {
+    lines[keyIndex] = `${key}=${value}`;
+    logger.success(`Updated ${key}`);
+  } else {
+    lines.push(`${key}=${value}`);
+    logger.success(`Added ${key}`);
+  }
+
+  await fs.writeFile(envPath, lines.join('\n'));
+}
+
+async function envGenerate(options) {
+  logger.info('Generating secure environment variables...');
+
+  const templates = {
+    database: {
+      DB_HOST: 'localhost',
+      DB_PORT: '5432',
+      DB_NAME: 'myapp',
+      DB_USER: 'postgres',
+      DB_PASSWORD: generateSecurePassword(32),
+    },
+    jwt: {
+      JWT_SECRET: generateSecurePassword(64),
+      JWT_EXPIRES_IN: '7d',
+    },
+    api: {
+      API_KEY: generateApiKey(),
+      API_SECRET: generateSecurePassword(48),
+    },
+    redis: {
+      REDIS_URL: 'redis://localhost:6379',
+    },
+    mail: {
+      SMTP_HOST: 'smtp.gmail.com',
+      SMTP_PORT: '587',
+      SMTP_USER: 'your@email.com',
+      SMTP_PASS: generateSecurePassword(24),
+    },
+    aws: {
+      AWS_ACCESS_KEY_ID: 'YOUR_ACCESS_KEY',
+      AWS_SECRET_ACCESS_KEY: generateSecurePassword(40),
+      AWS_REGION: 'us-east-1',
+    },
+  };
+
+  const templateAnswer = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'templates',
+      message: 'Select templates to generate:',
+      choices: Object.keys(templates).map(t => ({
+        name: t.charAt(0).toUpperCase() + t.slice(1),
+        value: t,
+      })),
+    },
+  ]);
+
+  let content = '# Generated by easy-build\n';
+  content += `# Generated at: ${new Date().toISOString()}\n\n`;
+
+  for (const template of templateAnswer.templates) {
+    content += `# ${template.charAt(0).toUpperCase() + template.slice(1)} Configuration\n`;
+    for (const [key, value] of Object.entries(templates[template])) {
+      content += `${key}=${value}\n`;
+    }
+    content += '\n';
+  }
+
+  const envPath = path.join(process.cwd(), '.env.generated');
+  await fs.writeFile(envPath, content);
+  logger.success(`Generated ${envPath}`);
+  logger.warning('Review and rename to .env before using!');
+}
+
+async function envValidate(options) {
+  const envFile = options.env || '.env';
+  const envPath = path.join(process.cwd(), envFile);
+
+  if (!(await fs.pathExists(envPath))) {
+    logger.warning(`No ${envFile} found`);
+    return;
+  }
+
+  const content = await fs.readFile(envPath, 'utf8');
+  const lines = content.split('\n');
+  const issues = [];
+
+  lines.forEach((line, index) => {
+    if (!line.trim() || line.startsWith('#')) return;
+
+    if (!line.includes('=')) {
+      issues.push(`Line ${index + 1}: Missing equals sign`);
+    }
+
+    const [key] = line.split('=');
+    if (key.includes(' ')) {
+      issues.push(`Line ${index + 1}: Key contains spaces`);
+    }
+
+    if (key !== key.toUpperCase()) {
+      issues.push(`Line ${index + 1}: Key should be uppercase`);
+    }
+  });
+
+  if (issues.length === 0) {
+    logger.success('Environment file is valid!');
+  } else {
+    logger.warning(`Found ${issues.length} issues:`);
+    issues.forEach(issue => logger.dim(`  ${issue}`));
+  }
+}
+
+async function envEncrypt(options) {
+  const envFile = options.env || '.env';
+  const envPath = path.join(process.cwd(), envFile);
+
+  if (!(await fs.pathExists(envPath))) {
+    logger.warning(`No ${envFile} found`);
+    return;
+  }
+
+  const keyAnswer = await inquirer.prompt([
+    { type: 'password', name: 'key', message: 'Encryption key:', mask: '*' },
+  ]);
+
+  const content = await fs.readFile(envPath, 'utf8');
+  const encrypted = encrypt(content, keyAnswer.key);
+
+  const encryptedPath = `${envPath}.encrypted`;
+  await fs.writeFile(encryptedPath, encrypted);
+  logger.success(`Encrypted to ${encryptedPath}`);
+}
+
+async function envDecrypt(options) {
+  const envFile = options.env || '.env';
+  const encryptedPath = `${path.join(process.cwd(), envFile)}.encrypted`;
+
+  if (!(await fs.pathExists(encryptedPath))) {
+    logger.warning(`No ${encryptedPath} found`);
+    return;
+  }
+
+  const keyAnswer = await inquirer.prompt([
+    { type: 'password', name: 'key', message: 'Decryption key:', mask: '*' },
+  ]);
+
+  const encrypted = await fs.readFile(encryptedPath, 'utf8');
+  try {
+    const decrypted = decrypt(encrypted, keyAnswer.key);
+    const decryptedPath = `${envPath}.decrypted`;
+    await fs.writeFile(decryptedPath, decrypted);
+    logger.success(`Decrypted to ${decryptedPath}`);
+  } catch (error) {
+    logger.error('Decryption failed - incorrect key?');
+  }
+}
+
+function generateSecurePassword(length = 32) {
+  return crypto.randomBytes(length).toString('base64').substring(0, length);
+}
+
+function generateApiKey() {
+  return `ak_${crypto.randomBytes(32).toString('hex')}`;
+}
+
+function encrypt(text, key) {
+  const cipher = crypto.createCipher('aes-256-cbc', key);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return encrypted;
+}
+
+function decrypt(text, key) {
+  const decipher = crypto.createDecipher('aes-256-cbc', key);
+  let decrypted = decipher.update(text, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+}
+
+module.exports = envCommand;