ante-erp-cli 1.0.2 → 1.1.0

package/README.md

@@ -72,6 +72,10 @@ ante status               # Show service status
 ante health              # Run health checks (alias: ante doctor)
 ante logs                # View logs
 ante logs --service backend --follow
+ante logs export         # Export logs to file
+ante logs errors         # Show only error logs
+ante logs search <term>  # Search logs for keyword
+ante logs clean          # Clean old logs
 ante ps                  # Show running containers
 ```
 
@@ -89,7 +93,10 @@ ante update --version 2.0.0
 ante backup              # Create backup
 ante dump                # Alias for backup
 ante backup -o /backups/my-backup.tar.gz
-ante backup:list         # List available backups
+ante backup list         # List available backups
+ante backup verify       # Verify backup integrity
+ante backup clean        # Clean old backups
+ante backup size         # Show backup storage usage
 ante restore <file>      # Restore from backup
 ```
 
@@ -105,11 +112,22 @@ ante restart             # Restart all services
 ### 🗄️ Database Operations
 
 ```bash
-ante db:migrate          # Run database migrations
-ante db:seed             # Seed database
-ante db:shell            # Open PostgreSQL shell
-ante db:optimize         # Optimize database
-ante db:reset            # Reset database (⚠️ destructive)
+ante db migrate          # Run database migrations
+ante db seed             # Seed database
+ante db shell            # Open PostgreSQL shell
+ante db optimize         # Optimize database
+ante db reset            # Reset database (⚠️ destructive)
+ante db info             # Show database information
+```
+
+### ⚙️ Configuration Management
+
+```bash
+ante config show         # Display configuration (masks secrets)
+ante config edit         # Edit configuration file (auto-backup)
+ante config validate     # Validate configuration
+ante config get <key>    # Get specific configuration value
+ante config set <key=value>  # Set configuration value (auto-backup)
 ```
 
 ### 🔒 SSL & Security

package/bin/ante-cli.js

@@ -24,12 +24,14 @@ import { status } from '../src/commands/status.js';
 import { update } from '../src/commands/update.js';
 import { updateCli } from '../src/commands/update-cli.js';
 import { backup, listBackups } from '../src/commands/backup.js';
+import { verifyBackup, cleanBackups, backupSize } from '../src/commands/backup-enhancements.js';
 import { restore } from '../src/commands/restore.js';
 import { start, stop, restart } from '../src/commands/service.js';
-import { logs } from '../src/commands/logs.js';
+import { logs, exportLogs, showErrors, cleanLogs, searchLogs } from '../src/commands/logs.js';
 import { doctor } from '../src/commands/doctor.js';
 import { uninstall } from '../src/commands/uninstall.js';
 import { migrate, seed, shell, optimize, reset, info } from '../src/commands/database.js';
+import { showConfig, editConfig, validateConfig, getConfigValue, setConfigValue } from '../src/commands/config.js';
 
 // Installation & Setup
 program
@@ -80,6 +82,23 @@ backupCmd
   .description('List available backups')
   .action(listBackups);
 
+backupCmd
+  .command('verify [file]')
+  .description('Verify backup integrity')
+  .action(verifyBackup);
+
+backupCmd
+  .command('clean')
+  .description('Clean old backups')
+  .option('-d, --days <days>', 'Delete backups older than N days', '30')
+  .option('--force', 'Skip confirmation')
+  .action(cleanBackups);
+
+backupCmd
+  .command('size')
+  .description('Show backup storage usage')
+  .action(backupSize);
+
 program
   .command('restore [file]')
   .description('Restore ANTE from backup')
@@ -122,6 +141,36 @@ dbCmd
   .description('Show database information')
   .action(info);
 
+// Configuration Management
+const configCmd = program
+  .command('config')
+  .description('Configuration management commands');
+
+configCmd
+  .command('show')
+  .description('Display current configuration')
+  .action(showConfig);
+
+configCmd
+  .command('edit')
+  .description('Edit configuration file')
+  .action(editConfig);
+
+configCmd
+  .command('validate')
+  .description('Validate configuration')
+  .action(validateConfig);
+
+configCmd
+  .command('get <key>')
+  .description('Get specific configuration value')
+  .action(getConfigValue);
+
+configCmd
+  .command('set <key=value>')
+  .description('Set configuration value')
+  .action(setConfigValue);
+
 // Status & Monitoring
 program
   .command('status')
@@ -134,7 +183,7 @@ program
   .description('Run comprehensive health checks')
   .action(doctor);
 
-program
+const logsCmd = program
   .command('logs')
   .description('View ANTE logs')
   .option('-s, --service <name>', 'Specific service (backend, frontend, postgres, redis, mongodb)')
@@ -143,6 +192,36 @@ program
   .option('--since <time>', 'Show logs since timestamp')
   .action(logs);
 
+logsCmd
+  .command('export')
+  .description('Export logs to file')
+  .option('-o, --output <file>', 'Output file path')
+  .option('-s, --service <name>', 'Specific service')
+  .option('-n, --lines <number>', 'Number of lines to export')
+  .option('--since <time>', 'Export logs since timestamp')
+  .action(exportLogs);
+
+logsCmd
+  .command('errors')
+  .description('Show only error logs')
+  .option('-s, --service <name>', 'Specific service')
+  .option('-n, --lines <number>', 'Number of lines to check', '500')
+  .action(showErrors);
+
+logsCmd
+  .command('clean')
+  .description('Clean old logs')
+  .option('-d, --days <days>', 'Delete logs older than N days', '7')
+  .option('--force', 'Skip confirmation')
+  .action(cleanLogs);
+
+logsCmd
+  .command('search <keyword>')
+  .description('Search logs for keyword')
+  .option('-s, --service <name>', 'Specific service')
+  .option('-n, --lines <number>', 'Number of lines to search', '1000')
+  .action(searchLogs);
+
 program
   .command('ps')
   .description('Show running containers')
@@ -195,4 +274,3 @@ program.parse();
 if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
-

package/bin/ante-cli.js.bak

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import updateNotifier from 'update-notifier';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+
+// Check for updates
+updateNotifier({ pkg }).notify();
+
+program
+  .name('ante')
+  .description(chalk.bold('ANTE ERP Management CLI'))
+  .version(pkg.version);
+
+// Import commands
+import { install } from '../src/commands/install.js';
+import { status } from '../src/commands/status.js';
+import { update } from '../src/commands/update.js';
+import { updateCli } from '../src/commands/update-cli.js';
+import { backup, listBackups } from '../src/commands/backup.js';
+import { restore } from '../src/commands/restore.js';
+import { start, stop, restart } from '../src/commands/service.js';
+import { logs } from '../src/commands/logs.js';
+import { doctor } from '../src/commands/doctor.js';
+import { uninstall } from '../src/commands/uninstall.js';
+import { migrate, seed, shell, optimize, reset, info } from '../src/commands/database.js';
+
+// Installation & Setup
+program
+  .command('install')
+  .description('Install ANTE ERP')
+  .option('-d, --dir <path>', 'Installation directory', './ante-erp')
+  .option('--domain <domain>', 'Domain name for SSL')
+  .option('--email <email>', 'Email for SSL certificate')
+  .option('--port <port>', 'Frontend port', '8080')
+  .option('--preset <type>', 'Installation preset (minimal, standard, enterprise)', 'standard')
+  .option('--no-interactive', 'Non-interactive mode with defaults')
+  .action(install);
+
+// Update & Maintenance
+program
+  .command('update')
+  .description('Update ANTE to latest version')
+  .option('-v, --version <version>', 'Specific version to install')
+  .option('--skip-backup', 'Skip automatic backup before update')
+  .option('--force', 'Force update without confirmation')
+  .action(update);
+
+program
+  .command('upgrade')
+  .description('Alias for update')
+  .option('-v, --version <version>', 'Specific version to install')
+  .action(update);
+
+program
+  .command('update-cli')
+  .description('Update ANTE CLI tool to latest version')
+  .option('--check', 'Check for updates without installing')
+  .option('--force', 'Skip confirmation prompt')
+  .action(updateCli);
+
+// Backup & Restore
+const backupCmd = program
+  .command('backup')
+  .alias('dump')
+  .description('Create backup of ANTE ERP')
+  .option('-o, --output <path>', 'Output file path')
+  .option('--compress', 'Compress backup', true)
+  .option('--databases-only', 'Only backup databases')
+  .action(backup);
+
+backupCmd
+  .command('list')
+  .description('List available backups')
+  .action(listBackups);
+
+program
+  .command('restore [file]')
+  .description('Restore ANTE from backup')
+  .option('--force', 'Skip confirmation prompts')
+  .action(restore);
+
+// Database Operations
+const dbCmd = program
+  .command('db')
+  .description('Database management commands');
+
+dbCmd
+  .command('migrate')
+  .description('Run database migrations')
+  .action(migrate);
+
+dbCmd
+  .command('seed')
+  .description('Seed database with initial data')
+  .action(seed);
+
+dbCmd
+  .command('shell')
+  .description('Open PostgreSQL shell')
+  .action(shell);
+
+dbCmd
+  .command('optimize')
+  .description('Optimize database performance')
+  .action(optimize);
+
+dbCmd
+  .command('reset')
+  .description('Reset database (destructive)')
+  .option('--force', 'Skip confirmation prompts')
+  .action(reset);
+
+dbCmd
+  .command('info')
+  .description('Show database information')
+  .action(info);
+
+// Status & Monitoring
+program
+  .command('status')
+  .description('Show ANTE service status')
+  .action(status);
+
+program
+  .command('health')
+  .alias('doctor')
+  .description('Run comprehensive health checks')
+  .action(doctor);
+
+program
+  .command('logs')
+  .description('View ANTE logs')
+  .option('-s, --service <name>', 'Specific service (backend, frontend, postgres, redis, mongodb)')
+  .option('-f, --follow', 'Follow log output')
+  .option('-n, --lines <number>', 'Number of lines to show', '100')
+  .option('--since <time>', 'Show logs since timestamp')
+  .action(logs);
+
+program
+  .command('ps')
+  .description('Show running containers')
+  .action(status);
+
+// Service Management
+program
+  .command('start')
+  .description('Start ANTE services')
+  .option('-s, --service <name>', 'Specific service to start')
+  .action(start);
+
+program
+  .command('stop')
+  .description('Stop ANTE services')
+  .option('-s, --service <name>', 'Specific service to stop')
+  .action(stop);
+
+program
+  .command('restart')
+  .description('Restart ANTE services')
+  .option('-s, --service <name>', 'Specific service to restart')
+  .action(restart);
+
+// Cleanup
+program
+  .command('uninstall')
+  .description('Uninstall ANTE ERP')
+  .option('--keep-data', 'Keep database volumes')
+  .option('--keep-files', 'Keep installation files')
+  .option('--force', 'Skip confirmation prompts')
+  .action(uninstall);
+
+// Help
+program
+  .command('help [command]')
+  .description('Display help for command')
+  .action((command) => {
+    if (command) {
+      program.commands.find(cmd => cmd.name() === command)?.help();
+    } else {
+      program.help();
+    }
+  });
+
+// Parse command line arguments
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ante-erp-cli",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Comprehensive CLI tool for managing ANTE ERP self-hosted installations",
   "type": "module",
   "bin": {

package/src/commands/backup-enhancements.js

@@ -0,0 +1,233 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { join } from 'path';
+import { readdirSync, statSync, existsSync } from 'fs';
+import { execa } from 'execa';
+import Table from 'cli-table3';
+import inquirer from 'inquirer';
+import { getInstallDir } from '../utils/config.js';
+
+/**
+ * Verify backup integrity
+ */
+export async function verifyBackup(file, options) {
+  try {
+    const installDir = getInstallDir();
+    const backupDir = join(installDir, 'backups');
+    const backupFile = file || await selectBackup(backupDir);
+
+    if (!backupFile) {
+      console.log(chalk.yellow('No backup selected\n'));
+      return;
+    }
+
+    const fullPath = backupFile.startsWith('/') ? backupFile : join(backupDir, backupFile);
+
+    if (!existsSync(fullPath)) {
+      console.error(chalk.red(`Backup file not found: ${fullPath}\n`));
+      process.exit(1);
+    }
+
+    console.log(chalk.bold('\n🔍 Verifying Backup\n'));
+    console.log(chalk.gray(`File: ${fullPath}\n`));
+
+    const spinner = ora('Checking file integrity...').start();
+
+    try {
+      // Test tar.gz integrity
+      await execa('tar', ['-tzf', fullPath], { stdout: 'pipe' });
+      spinner.succeed('Archive integrity: OK');
+
+      // Check file size
+      const stats = statSync(fullPath);
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+      console.log(chalk.green(`File size: ${sizeMB} MB`));
+
+      // List contents
+      spinner.start('Checking contents...');
+      const result = await execa('tar', ['-tzf', fullPath]);
+      const files = result.stdout.split('\n').filter(Boolean);
+
+      const hasPostgres = files.some(f => f.includes('postgres.dump'));
+      const hasEnv = files.some(f => f.includes('env.backup'));
+      const hasCompose = files.some(f => f.includes('docker-compose.yml'));
+
+      spinner.stop();
+      console.log(chalk.green(`PostgreSQL dump: ${hasPostgres ? 'Found' : 'Missing'}`));
+      console.log(chalk.green(`Environment config: ${hasEnv ? 'Found' : 'Missing'}`));
+      console.log(chalk.green(`Docker compose: ${hasCompose ? 'Found' : 'Missing'}`));
+      console.log(chalk.gray(`\nTotal files: ${files.length}`));
+
+      if (!hasPostgres || !hasEnv) {
+        console.log(chalk.yellow('\nWarning: Backup may be incomplete\n'));
+      } else {
+        console.log(chalk.green.bold('\nBackup is valid\n'));
+      }
+
+    } catch (error) {
+      spinner.fail('Backup verification failed');
+      console.error(chalk.red('Archive is corrupted or invalid\n'));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Clean old backups
+ */
+export async function cleanBackups(options) {
+  try {
+    const installDir = getInstallDir();
+    const backupDir = join(installDir, 'backups');
+    const days = options.days || 30;
+
+    console.log(chalk.bold(`\n🧹 Cleaning Backups Older Than ${days} Days\n`));
+
+    const files = readdirSync(backupDir).filter(f => f.endsWith('.tar.gz'));
+
+    if (files.length === 0) {
+      console.log(chalk.yellow('No backups found\n'));
+      return;
+    }
+
+    const now = Date.now();
+    const cutoff = days * 24 * 60 * 60 * 1000;
+    const oldFiles = [];
+
+    for (const file of files) {
+      const filePath = join(backupDir, file);
+      const stats = statSync(filePath);
+      const age = now - stats.mtimeMs;
+
+      if (age > cutoff) {
+        oldFiles.push({ file, age: Math.floor(age / (24 * 60 * 60 * 1000)), size: stats.size });
+      }
+    }
+
+    if (oldFiles.length === 0) {
+      console.log(chalk.green(`No backups older than ${days} days\n`));
+      return;
+    }
+
+    console.log(chalk.yellow(`Found ${oldFiles.length} old backup(s):\n`));
+    oldFiles.forEach(item => {
+      console.log(chalk.gray(`  - ${item.file} (${item.age} days old)`));
+    });
+    console.log('');
+
+    if (!options.force) {
+      const answers = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Delete ${oldFiles.length} old backup(s)?`,
+        default: false
+      }]);
+
+      if (!answers.confirm) {
+        console.log(chalk.yellow('Cancelled\n'));
+        return;
+      }
+    }
+
+    let deletedSize = 0;
+    for (const item of oldFiles) {
+      const filePath = join(backupDir, item.file);
+      await execa('rm', [filePath]);
+      deletedSize += item.size;
+    }
+
+    const freedMB = (deletedSize / 1024 / 1024).toFixed(2);
+    console.log(chalk.green(`\nDeleted ${oldFiles.length} backup(s)`));
+    console.log(chalk.gray(`  Freed: ${freedMB} MB\n`));
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show total backup storage usage
+ */
+export async function backupSize() {
+  try {
+    const installDir = getInstallDir();
+    const backupDir = join(installDir, 'backups');
+
+    console.log(chalk.bold('\n💾 Backup Storage Usage\n'));
+
+    const files = readdirSync(backupDir).filter(f => f.endsWith('.tar.gz'));
+
+    if (files.length === 0) {
+      console.log(chalk.yellow('No backups found\n'));
+      return;
+    }
+
+    let totalSize = 0;
+    const fileDetails = [];
+
+    for (const file of files) {
+      const filePath = join(backupDir, file);
+      const stats = statSync(filePath);
+      totalSize += stats.size;
+
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+      const age = Math.floor((Date.now() - stats.mtimeMs) / (24 * 60 * 60 * 1000));
+
+      fileDetails.push({ file, size: sizeMB, age });
+    }
+
+    // Sort by size (largest first)
+    fileDetails.sort((a, b) => parseFloat(b.size) - parseFloat(a.size));
+
+    const table = new Table({
+      head: [chalk.cyan('Backup'), chalk.cyan('Size (MB)'), chalk.cyan('Age (days)')],
+      style: { head: [], border: ['gray'] }
+    });
+
+    fileDetails.slice(0, 10).forEach(item => {
+      table.push([item.file, item.size, item.age]);
+    });
+
+    console.log(table.toString());
+
+    const totalMB = (totalSize / 1024 / 1024).toFixed(2);
+    const totalGB = (totalSize / 1024 / 1024 / 1024).toFixed(2);
+
+    console.log('');
+    console.log(chalk.bold(`Total: ${files.length} backup(s)`));
+    console.log(chalk.bold(`Size: ${totalMB} MB (${totalGB} GB)`));
+    console.log(chalk.gray(`\nLocation: ${backupDir}\n`));
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Helper function to select backup interactively
+ */
+async function selectBackup(backupDir) {
+  const files = readdirSync(backupDir)
+    .filter(f => f.endsWith('.tar.gz'))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    return null;
+  }
+
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'backup',
+    message: 'Select backup to verify:',
+    choices: files
+  }]);
+
+  return answers.backup;
+}

package/src/commands/backup.js

@@ -1,9 +1,10 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { join } from 'path';
-import { readdirSync } from 'fs';
+import { readdirSync, statSync, existsSync } from 'fs';
 import { execa } from 'execa';
 import Table from 'cli-table3';
+import inquirer from 'inquirer';
 import { getInstallDir } from '../utils/config.js';
 import { execInContainer } from '../utils/docker.js';
 

package/src/commands/config.js

@@ -0,0 +1,304 @@
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { getInstallDir } from '../utils/config.js';
+import inquirer from 'inquirer';
+
+/**
+ * Show current configuration
+ */
+export async function showConfig() {
+  try {
+    const installDir = getInstallDir();
+    const envFile = join(installDir, '.env');
+
+    if (!existsSync(envFile)) {
+      console.log(chalk.yellow('⚠️  No .env file found'));
+      console.log(chalk.gray(`Expected location: ${envFile}`));
+      console.log(chalk.gray('\nRun "ante install" first to create the configuration.'));
+      process.exit(1);
+    }
+
+    console.log(chalk.bold('\n📋 ANTE Configuration\n'));
+    console.log(chalk.gray(`Location: ${envFile}\n`));
+
+    const envContent = readFileSync(envFile, 'utf8');
+    const lines = envContent.split('\n');
+
+    let currentSection = '';
+    for (const line of lines) {
+      if (line.trim() === '' || line.trim().startsWith('#')) {
+        // Section header
+        if (line.trim().startsWith('#') && !line.includes('=')) {
+          currentSection = line.trim().replace(/^#+\s*/, '');
+          console.log(chalk.cyan(`\n${currentSection}`));
+        }
+        continue;
+      }
+
+      const [key, ...valueParts] = line.split('=');
+      const value = valueParts.join('=');
+
+      if (key && value !== undefined) {
+        // Mask sensitive values
+        const sensitiveKeys = ['PASSWORD', 'SECRET', 'KEY', 'TOKEN'];
+        const isSensitive = sensitiveKeys.some(k => key.toUpperCase().includes(k));
+        const displayValue = isSensitive ? '********' : value;
+
+        console.log(chalk.gray(`  ${key}=`) + displayValue);
+      }
+    }
+
+    console.log(chalk.gray('\n💡 Tip: Use "ante config edit" to modify configuration\n'));
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Edit configuration
+ */
+export async function editConfig() {
+  try {
+    const installDir = getInstallDir();
+    const envFile = join(installDir, '.env');
+
+    if (!existsSync(envFile)) {
+      console.log(chalk.yellow('⚠️  No .env file found'));
+      console.log(chalk.gray(`Expected location: ${envFile}`));
+      process.exit(1);
+    }
+
+    // Create backup
+    const backupFile = `${envFile}.backup.${Date.now()}`;
+    writeFileSync(backupFile, readFileSync(envFile));
+    console.log(chalk.green(`✓ Created backup: ${backupFile}`));
+
+    // Determine editor
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+
+    console.log(chalk.bold(`\n📝 Opening configuration in ${editor}...`));
+    console.log(chalk.gray('Save and exit when done\n'));
+
+    try {
+      execSync(`${editor} "${envFile}"`, { stdio: 'inherit' });
+
+      console.log(chalk.green('\n✓ Configuration saved'));
+
+      // Prompt to restart
+      const { shouldRestart } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'shouldRestart',
+        message: 'Restart services to apply changes?',
+        default: true
+      }]);
+
+      if (shouldRestart) {
+        console.log(chalk.gray('\nRestarting services...\n'));
+        execSync('ante restart', { stdio: 'inherit' });
+      } else {
+        console.log(chalk.yellow('\n⚠️  Remember to restart services: ante restart\n'));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('\nEditor error:'), error.message);
+      console.log(chalk.yellow(`\nRestore backup if needed: cp ${backupFile} ${envFile}`));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Validate configuration
+ */
+export async function validateConfig() {
+  try {
+    const installDir = getInstallDir();
+    const envFile = join(installDir, '.env');
+
+    if (!existsSync(envFile)) {
+      console.log(chalk.red('✗ No .env file found'));
+      process.exit(1);
+    }
+
+    console.log(chalk.bold('\n🔍 Validating Configuration\n'));
+
+    const envContent = readFileSync(envFile, 'utf8');
+    const config = {};
+
+    // Parse .env file
+    for (const line of envContent.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const [key, ...valueParts] = trimmed.split('=');
+      if (key) {
+        config[key.trim()] = valueParts.join('=').trim();
+      }
+    }
+
+    const errors = [];
+    const warnings = [];
+
+    // Required configurations
+    const required = {
+      'DATABASE_URL': 'PostgreSQL connection string',
+      'DIRECT_URL': 'PostgreSQL direct connection',
+      'MONGODB_URI': 'MongoDB connection string',
+      'JWT_SECRET': 'JWT secret key',
+      'REDIS_HOST': 'Redis host',
+      'REDIS_PORT': 'Redis port'
+    };
+
+    for (const [key, description] of Object.entries(required)) {
+      if (!config[key]) {
+        errors.push(`Missing ${chalk.yellow(key)} - ${description}`);
+      } else {
+        console.log(chalk.green('✓'), key);
+      }
+    }
+
+    // Warnings for default values
+    if (config.JWT_SECRET && config.JWT_SECRET.includes('change-this')) {
+      warnings.push('JWT_SECRET contains default value - change in production');
+    }
+
+    if (config.DATABASE_URL && config.DATABASE_URL.includes('your-password')) {
+      warnings.push('DATABASE_URL contains placeholder password');
+    }
+
+    // Check JWT secret length
+    if (config.JWT_SECRET && config.JWT_SECRET.length < 32) {
+      warnings.push('JWT_SECRET should be at least 32 characters');
+    }
+
+    // Print results
+    console.log('');
+
+    if (errors.length > 0) {
+      console.log(chalk.red.bold('Errors:'));
+      errors.forEach(err => console.log(chalk.red('  ✗'), err));
+      console.log('');
+    }
+
+    if (warnings.length > 0) {
+      console.log(chalk.yellow.bold('Warnings:'));
+      warnings.forEach(warn => console.log(chalk.yellow('  ⚠️ '), warn));
+      console.log('');
+    }
+
+    if (errors.length === 0 && warnings.length === 0) {
+      console.log(chalk.green.bold('✓ Configuration is valid\n'));
+    } else if (errors.length === 0) {
+      console.log(chalk.yellow.bold('⚠️  Configuration has warnings\n'));
+    } else {
+      console.log(chalk.red.bold('✗ Configuration has errors\n'));
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Get specific configuration value
+ */
+export async function getConfigValue(key) {
+  try {
+    const installDir = getInstallDir();
+    const envFile = join(installDir, '.env');
+
+    if (!existsSync(envFile)) {
+      console.log(chalk.red('✗ No .env file found'));
+      process.exit(1);
+    }
+
+    const envContent = readFileSync(envFile, 'utf8');
+
+    for (const line of envContent.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const [envKey, ...valueParts] = trimmed.split('=');
+      if (envKey.trim() === key) {
+        const value = valueParts.join('=').trim();
+        console.log(value);
+        return;
+      }
+    }
+
+    console.error(chalk.red(`✗ Key "${key}" not found in configuration`));
+    process.exit(1);
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Set specific configuration value
+ */
+export async function setConfigValue(keyValue) {
+  try {
+    const installDir = getInstallDir();
+    const envFile = join(installDir, '.env');
+
+    if (!existsSync(envFile)) {
+      console.log(chalk.red('✗ No .env file found'));
+      process.exit(1);
+    }
+
+    const [key, ...valueParts] = keyValue.split('=');
+    const value = valueParts.join('=');
+
+    if (!key || value === undefined) {
+      console.error(chalk.red('✗ Invalid format. Use: KEY=VALUE'));
+      process.exit(1);
+    }
+
+    // Create backup
+    const backupFile = `${envFile}.backup.${Date.now()}`;
+    const originalContent = readFileSync(envFile, 'utf8');
+    writeFileSync(backupFile, originalContent);
+
+    const lines = originalContent.split('\n');
+    let found = false;
+
+    const newLines = lines.map(line => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) return line;
+
+      const [envKey] = trimmed.split('=');
+      if (envKey.trim() === key.trim()) {
+        found = true;
+        return `${key}=${value}`;
+      }
+      return line;
+    });
+
+    if (!found) {
+      // Add new key
+      newLines.push(`${key}=${value}`);
+    }
+
+    writeFileSync(envFile, newLines.join('\n'));
+
+    console.log(chalk.green(`✓ Set ${key}=${value}`));
+    console.log(chalk.gray(`Backup created: ${backupFile}`));
+    console.log(chalk.yellow('\n⚠️  Restart services to apply: ante restart\n'));
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}

package/src/commands/logs.js

@@ -1,33 +1,222 @@
 import chalk from 'chalk';
 import { join } from 'path';
+import { writeFileSync } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 import { getInstallDir } from '../utils/config.js';
 import { getLogs } from '../utils/docker.js';
+import inquirer from 'inquirer';
+
+const execAsync = promisify(exec);
 
 /**
- * View ANTE logs
+ * View ANTE logs (original function)
  */
 export async function logs(options) {
   try {
     const installDir = getInstallDir();
     const composeFile = join(installDir, 'docker-compose.yml');
-    
-    console.log(chalk.bold(`\n📄 ANTE Logs${options.service ? ` (${options.service})` : ''}\n`));
-    
+
+    const serviceLabel = options.service ? ` (${options.service})` : '';
+    console.log(chalk.bold(`\n📄 ANTE Logs${serviceLabel}\n`));
+
     const logOptions = {
       tail: options.lines ? parseInt(options.lines) : 100,
       follow: options.follow,
       since: options.since
     };
-    
+
     const logOutput = await getLogs(composeFile, options.service, logOptions);
-    
+
     if (!options.follow && logOutput) {
       console.log(logOutput);
     }
-    
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Export logs to file
+ */
+export async function exportLogs(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const defaultFilename = `ante-logs-${timestamp}.txt`;
+    const outputFile = options.output || defaultFilename;
+
+    console.log(chalk.bold('\n📤 Exporting Logs\n'));
+
+    const logOptions = {
+      tail: options.lines ? parseInt(options.lines) : undefined,
+      since: options.since
+    };
+
+    const logOutput = await getLogs(composeFile, options.service, logOptions);
+
+    if (logOutput) {
+      writeFileSync(outputFile, logOutput);
+      console.log(chalk.green(`✓ Logs exported to: ${outputFile}`));
+
+      const result = await execAsync(`du -h "${outputFile}"`);
+      const size = result.stdout.split('\t')[0];
+      console.log(chalk.gray(`  Size: ${size}`));
+      console.log('');
+    } else {
+      console.log(chalk.yellow('⚠️  No logs to export'));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show only error logs
+ */
+export async function showErrors(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+
+    console.log(chalk.bold.red('\n🔴 Error Logs\n'));
+
+    const logOptions = {
+      tail: options.lines ? parseInt(options.lines) : 500
+    };
+
+    const logOutput = await getLogs(composeFile, options.service, logOptions);
+
+    if (logOutput) {
+      const errorLines = logOutput
+        .split('\n')
+        .filter(line =>
+          line.toLowerCase().includes('error') ||
+          line.toLowerCase().includes('fatal') ||
+          line.toLowerCase().includes('exception')
+        );
+
+      if (errorLines.length > 0) {
+        console.log(errorLines.join('\n'));
+        console.log(chalk.yellow(`\n⚠️  Found ${errorLines.length} error(s)\n`));
+      } else {
+        console.log(chalk.green('✓ No errors found in recent logs\n'));
+      }
+    }
+
   } catch (error) {
     console.error(chalk.red('Error:'), error.message);
     process.exit(1);
   }
 }
 
+/**
+ * Clean old logs
+ */
+export async function cleanLogs(options) {
+  try {
+    const installDir = getInstallDir();
+    const days = options.days || 7;
+
+    console.log(chalk.bold(`\n🧹 Cleaning Logs Older Than ${days} Days\n`));
+
+    if (!options.force) {
+      const answers = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Delete logs older than ${days} days?`,
+        default: false
+      }]);
+
+      if (!answers.confirm) {
+        console.log(chalk.yellow('Cancelled\n'));
+        return;
+      }
+    }
+
+    console.log(chalk.gray('Rotating Docker container logs...'));
+
+    try {
+      const result = await execAsync('docker ps --format "{{.Names}}"');
+      const containers = result.stdout.trim().split('\n').filter(Boolean);
+
+      for (const container of containers) {
+        if (container.includes('ante')) {
+          await execAsync(`docker logs ${container} 2>&1 >/dev/null`);
+        }
+      }
+
+      console.log(chalk.green('✓ Docker logs rotated'));
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Could not rotate some logs'));
+    }
+
+    const logsDir = join(installDir, 'logs');
+    try {
+      const findCmd = `find "${logsDir}" -name "*.log" -mtime +${days} -type f 2>/dev/null || true`;
+      const result = await execAsync(findCmd);
+      const oldFiles = result.stdout.trim().split('\n').filter(Boolean);
+
+      if (oldFiles.length > 0) {
+        const deleteCmd = `find "${logsDir}" -name "*.log" -mtime +${days} -type f -delete 2>/dev/null || true`;
+        await execAsync(deleteCmd);
+        console.log(chalk.green(`✓ Deleted ${oldFiles.length} old log file(s)`));
+      } else {
+        console.log(chalk.gray('No old log files found'));
+      }
+    } catch (error) {
+      console.log(chalk.gray('No local log files to clean'));
+    }
+
+    console.log(chalk.green('\n✓ Log cleanup completed\n'));
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Search logs for keyword
+ */
+export async function searchLogs(keyword, options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+
+    console.log(chalk.bold(`\n🔍 Searching for: "${keyword}"\n`));
+
+    const logOptions = {
+      tail: options.lines ? parseInt(options.lines) : 1000
+    };
+
+    const logOutput = await getLogs(composeFile, options.service, logOptions);
+
+    if (logOutput) {
+      const matchingLines = logOutput
+        .split('\n')
+        .filter(line => line.toLowerCase().includes(keyword.toLowerCase()));
+
+      if (matchingLines.length > 0) {
+        matchingLines.forEach(line => {
+          const regex = new RegExp(keyword, 'gi');
+          const highlighted = line.replace(regex, (match) => chalk.yellow.bold(match));
+          console.log(highlighted);
+        });
+        console.log(chalk.gray(`\nFound ${matchingLines.length} match(es)\n`));
+      } else {
+        console.log(chalk.yellow(`No matches found for "${keyword}"\n`));
+      }
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}

package/src/commands/logs.js.bak

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { join } from 'path';
+import { getInstallDir } from '../utils/config.js';
+import { getLogs } from '../utils/docker.js';
+
+/**
+ * View ANTE logs
+ */
+export async function logs(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+    
+    console.log(chalk.bold(`\n📄 ANTE Logs${options.service ? ` (${options.service})` : ''}\n`));
+    
+    const logOptions = {
+      tail: options.lines ? parseInt(options.lines) : 100,
+      follow: options.follow,
+      since: options.since
+    };
+    
+    const logOutput = await getLogs(composeFile, options.service, logOptions);
+    
+    if (!options.follow && logOutput) {
+      console.log(logOutput);
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+

package/src/templates/docker-compose.yml.js

@@ -117,7 +117,7 @@ services:
       REDIS_PASSWORD: \${REDIS_PASSWORD}
       REDIS_DB: 0
       REDIS_TLS: "false"
-      MONGODB_URI: mongodb://ante:\${MONGO_PASSWORD}@mongodb:27017/ante?authSource=admin
+      MONGODB_URI: mongodb://ante:\${MONGO_PASSWORD_ENCODED}@mongodb:27017/ante?authSource=admin
       JWT_SECRET: \${JWT_SECRET}
       JWT_EXPIRATION: \${JWT_EXPIRATION:-24h}
       DEVELOPER_KEY: \${DEVELOPER_KEY}

package/src/templates/env.js

@@ -30,6 +30,7 @@ export function generateEnv(credentials, options = {}) {
 DB_PASSWORD=${credentials.dbPassword}
 REDIS_PASSWORD=${credentials.redisPassword}
 MONGO_PASSWORD=${credentials.mongoPassword}
+MONGO_PASSWORD_ENCODED=${encodeURIComponent(credentials.mongoPassword)}
 
 # ------------------------------------------------------------------------------
 # SECURITY KEYS

package/src/utils/validation.js

@@ -103,8 +103,8 @@ export function checkDiskSpace(path = '/', requiredGB = 20) {
  * @returns {{ok: boolean, message: string, availableGB: number}}
  */
 export function checkMemory(requiredGB = 2) {
-  const totalGB = Math.floor(totalmem() / (1024 ** 3));
-  const freeGB = Math.floor(freemem() / (1024 ** 3));
+  const totalGB = Math.round(totalmem() / (1024 ** 3));
+  const freeGB = Math.round(freemem() / (1024 ** 3));
 
   return {
     ok: totalGB >= requiredGB,