ante-erp-cli 1.0.0

package/src/commands/install.js

@@ -0,0 +1,277 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { Listr } from 'listr2';
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { runSystemChecks } from '../utils/validation.js';
+import { generateCredentials } from '../utils/password.js';
+import { saveInstallConfig, detectInstallation } from '../utils/config.js';
+import { pullImages, startServices, waitForServiceHealthy } from '../utils/docker.js';
+import { generateDockerCompose } from '../templates/docker-compose.yml.js';
+import { generateEnv } from '../templates/env.js';
+
+/**
+ * Show welcome message
+ */
+function showWelcome() {
+  console.log(
+    boxen(
+      chalk.bold.cyan('ANTE ERP') + '\n' +
+      chalk.white('Self-Hosted Installation Tool\n') +
+      chalk.gray(`Version ${chalk.white('1.0.0')}`),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan'
+      }
+    )
+  );
+}
+
+/**
+ * Show success message
+ */
+function showSuccess(installDir, credentials) {
+  console.log(
+    boxen(
+      chalk.green.bold('✓ Installation Complete!') + '\n\n' +
+      chalk.white('Access Information:') + '\n' +
+      chalk.gray('━'.repeat(40)) + '\n' +
+      chalk.cyan('Frontend:  ') + chalk.white('http://localhost:8080') + '\n' +
+      chalk.cyan('Backend:   ') + chalk.white('http://localhost:3001') + '\n' +
+      chalk.cyan('WebSocket: ') + chalk.white('ws://localhost:4001') + '\n\n' +
+      chalk.yellow('⚠  IMPORTANT:') + '\n' +
+      chalk.white(`Credentials saved to:\n${installDir}/installation-credentials.txt`) + '\n' +
+      chalk.gray('Save this file securely!') + '\n\n' +
+      chalk.white('Next steps:') + '\n' +
+      chalk.gray('1. Open http://localhost:8080 in your browser') + '\n' +
+      chalk.gray('2. Create your admin account') + '\n' +
+      chalk.gray('3. Explore the documentation at https://docs.ante.ph'),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'green'
+      }
+    )
+  );
+}
+
+/**
+ * Install ANTE ERP
+ */
+export async function install(options) {
+  try {
+    showWelcome();
+    
+    // Check if already installed
+    const existing = detectInstallation();
+    if (existing && !options.force) {
+      console.log(chalk.yellow('\n⚠  ANTE is already installed at:'), chalk.white(existing));
+      const { continueAnyway } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'continueAnyway',
+          message: 'Install anyway?',
+          default: false
+        }
+      ]);
+      
+      if (!continueAnyway) {
+        console.log(chalk.gray('\nInstallation cancelled.'));
+        return;
+      }
+    }
+    
+    // System checks
+    console.log(chalk.bold('\n🔍 Checking system requirements...\n'));
+    const { ok, checks } = await runSystemChecks();
+    
+    // Display check results
+    console.log(chalk.bold('System Requirements:'));
+    console.log(`${checks.docker.ok ? chalk.green('✓') : chalk.red('✗')} Docker: ${checks.docker.message}`);
+    console.log(`${checks.dockerCompose.ok ? chalk.green('✓') : chalk.red('✗')} Docker Compose: ${checks.dockerCompose.message}`);
+    console.log(`${checks.node.ok ? chalk.green('✓') : chalk.red('✗')} Node.js: ${checks.node.message}`);
+    
+    console.log(chalk.bold('\nResources:'));
+    console.log(`${checks.diskSpace.ok ? chalk.green('✓') : chalk.red('✗')} Disk Space: ${checks.diskSpace.message}`);
+    console.log(`${checks.memory.ok ? chalk.green('✓') : chalk.red('✗')} Memory: ${checks.memory.message}`);
+    console.log(`${checks.cpu.ok ? chalk.green('✓') : chalk.yellow('⚠')} CPU: ${checks.cpu.message}`);
+    
+    if (!ok) {
+      console.log(chalk.red('\n✗ System requirements not met. Please resolve issues above.\n'));
+      process.exit(1);
+    }
+    
+    console.log(chalk.green('\n✓ All requirements met!\n'));
+    
+    // Interactive prompts or use options
+    let config;
+    if (options.interactive) {
+      config = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'installDir',
+          message: 'Installation directory:',
+          default: options.dir || './ante-erp'
+        },
+        {
+          type: 'list',
+          name: 'preset',
+          message: 'Choose installation type:',
+          choices: [
+            { name: 'Minimal (Evaluation)', value: 'minimal' },
+            { name: 'Standard (Recommended)', value: 'standard' },
+            { name: 'Enterprise (Full Features)', value: 'enterprise' }
+          ],
+          default: 'standard'
+        },
+        {
+          type: 'confirm',
+          name: 'useDomain',
+          message: 'Do you have a domain name?',
+          default: false
+        },
+        {
+          type: 'input',
+          name: 'domain',
+          message: 'Domain name:',
+          when: (answers) => answers.useDomain
+        }
+      ]);
+    } else {
+      config = {
+        installDir: options.dir,
+        preset: options.preset || 'standard',
+        useDomain: !!options.domain,
+        domain: options.domain
+      };
+    }
+    
+    // Generate credentials
+    console.log(chalk.bold('\n🔐 Generating secure credentials...\n'));
+    const credentials = generateCredentials();
+    
+    // Installation tasks
+    const tasks = new Listr([
+      {
+        title: 'Creating installation directory',
+        task: () => {
+          mkdirSync(config.installDir, { recursive: true });
+          mkdirSync(join(config.installDir, 'backups'), { recursive: true });
+          mkdirSync(join(config.installDir, 'logs'), { recursive: true });
+        }
+      },
+      {
+        title: 'Generating configuration files',
+        task: () => {
+          const dockerCompose = generateDockerCompose({
+            frontendPort: parseInt(options.port) || 8080,
+            backendPort: 3001,
+            websocketPort: 4001
+          });
+          
+          const envContent = generateEnv(credentials, {
+            frontendUrl: config.domain ? `https://${config.domain}` : 'http://localhost:8080',
+            apiUrl: config.domain ? `https://${config.domain}/api` : 'http://localhost:3001',
+            socketUrl: config.domain ? `wss://${config.domain}/socket.io` : 'ws://localhost:4001'
+          });
+          
+          writeFileSync(join(config.installDir, 'docker-compose.yml'), dockerCompose);
+          writeFileSync(join(config.installDir, '.env'), envContent);
+          
+          // Save credentials
+          const credentialsText = `ANTE ERP Installation Credentials
+Generated: ${new Date().toISOString()}
+
+⚠️ IMPORTANT: Keep this file secure and never commit to version control!
+
+Database Credentials:
+━━━━━━━━━━━━━━━━━━━━
+PostgreSQL Password: ${credentials.dbPassword}
+Redis Password:      ${credentials.redisPassword}
+MongoDB Password:    ${credentials.mongoPassword}
+
+Security Keys:
+━━━━━━━━━━━━━━
+JWT Secret:        ${credentials.jwtSecret}
+Developer Key:     ${credentials.developerKey}
+Encryption Key:    ${credentials.encryptionKey}
+
+Access Information:
+━━━━━━━━━━━━━━━━━━━
+Frontend:  http://localhost:${options.port || 8080}
+Backend:   http://localhost:3001
+WebSocket: ws://localhost:4001
+
+Next Steps:
+━━━━━━━━━━
+1. Access the frontend URL in your browser
+2. Create your admin account
+3. Configure your organization settings
+4. Start using ANTE ERP!
+
+Documentation: https://docs.ante.ph
+Support: support@ante.ph
+`;
+          
+          writeFileSync(join(config.installDir, 'installation-credentials.txt'), credentialsText);
+        }
+      },
+      {
+        title: 'Pulling Docker images',
+        task: async () => {
+          const composeFile = join(config.installDir, 'docker-compose.yml');
+          await pullImages(composeFile);
+        }
+      },
+      {
+        title: 'Starting services',
+        task: async () => {
+          const composeFile = join(config.installDir, 'docker-compose.yml');
+          await startServices(composeFile);
+        }
+      },
+      {
+        title: 'Waiting for services to be ready',
+        task: async () => {
+          const composeFile = join(config.installDir, 'docker-compose.yml');
+          
+          // Wait for backend to be healthy
+          const backendHealthy = await waitForServiceHealthy(composeFile, 'backend', 120);
+          if (!backendHealthy) {
+            throw new Error('Backend service failed to start');
+          }
+          
+          // Give it a few more seconds
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+      }
+    ], {
+      rendererOptions: {
+        collapseSubtasks: false
+      }
+    });
+    
+    await tasks.run();
+    
+    // Save installation configuration
+    saveInstallConfig({
+      installPath: config.installDir,
+      version: '1.0.0',
+      domain: config.domain
+    });
+    
+    // Show success message
+    showSuccess(config.installDir, credentials);
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Installation failed:'), error.message);
+    console.error(chalk.gray('\nFor help, visit: https://docs.ante.ph/self-hosting/troubleshooting\n'));
+    process.exit(1);
+  }
+}
+

package/src/commands/logs.js

@@ -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/commands/restore.js

@@ -0,0 +1,227 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { join, basename } from 'path';
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { execa } from 'execa';
+import { getInstallDir } from '../utils/config.js';
+import { execInContainer, stopServices, startServices } from '../utils/docker.js';
+
+/**
+ * Restore ANTE ERP from backup
+ */
+export async function restore(backupFile, options = {}) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+
+    // Validate backup file
+    if (!backupFile) {
+      const backupDir = join(installDir, 'backups');
+
+      if (!existsSync(backupDir)) {
+        console.log(chalk.red('✗ No backups directory found'));
+        console.log(chalk.gray(`Expected: ${backupDir}`));
+        return;
+      }
+
+      const backups = readdirSync(backupDir)
+        .filter(f => f.endsWith('.tar.gz'))
+        .sort()
+        .reverse();
+
+      if (backups.length === 0) {
+        console.log(chalk.red('✗ No backups found'));
+        console.log(chalk.gray('Create a backup first: ante backup'));
+        return;
+      }
+
+      // Prompt user to select backup
+      const { selectedBackup } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selectedBackup',
+          message: 'Select backup to restore:',
+          choices: backups.map(b => ({
+            name: `${b} (${getSizeSync(join(backupDir, b))})`,
+            value: b
+          }))
+        }
+      ]);
+
+      backupFile = join(backupDir, selectedBackup);
+    }
+
+    if (!existsSync(backupFile)) {
+      console.log(chalk.red('✗ Backup file not found:'), backupFile);
+      return;
+    }
+
+    // Warning and confirmation
+    console.log(chalk.yellow('\n⚠  WARNING: This will restore ANTE from backup'));
+    console.log(chalk.gray('Current data will be replaced with backup data'));
+    console.log(chalk.white('\nBackup file:'), chalk.cyan(basename(backupFile)));
+
+    if (!options.force) {
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Continue with restore?',
+          default: false
+        }
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.gray('\nRestore cancelled.'));
+        return;
+      }
+    }
+
+    const spinner = ora('Preparing restore...').start();
+
+    try {
+      // Create temporary directory
+      const tempDir = join(installDir, '.restore-temp');
+      if (existsSync(tempDir)) {
+        await execa('rm', ['-rf', tempDir]);
+      }
+      mkdirSync(tempDir, { recursive: true });
+
+      // Extract backup
+      spinner.text = 'Extracting backup...';
+      await execa('tar', ['-xzf', backupFile, '-C', tempDir]);
+
+      // Stop services
+      spinner.text = 'Stopping services...';
+      await stopServices(composeFile);
+
+      // Wait for services to stop
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Start only database services for restore
+      spinner.text = 'Starting database services...';
+      await startServices(composeFile, ['postgres', 'mongodb', 'redis']);
+
+      // Wait for databases to be ready
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      // Restore PostgreSQL
+      spinner.text = 'Restoring PostgreSQL database...';
+      const pgDumpFile = join(tempDir, 'postgres.dump');
+      if (existsSync(pgDumpFile)) {
+        // Drop and recreate database
+        await execInContainer(
+          composeFile,
+          'postgres',
+          ['psql', '-U', 'ante', '-c', 'DROP DATABASE IF EXISTS ante_db;']
+        );
+        await execInContainer(
+          composeFile,
+          'postgres',
+          ['psql', '-U', 'ante', '-c', 'CREATE DATABASE ante_db;']
+        );
+
+        // Restore from dump
+        const dumpContent = await execa('cat', [pgDumpFile]);
+        await execInContainer(
+          composeFile,
+          'postgres',
+          ['pg_restore', '-U', 'ante', '-d', 'ante_db'],
+          { input: dumpContent.stdout }
+        );
+      }
+
+      // Restore MongoDB
+      spinner.text = 'Restoring MongoDB database...';
+      const mongoDumpDir = join(tempDir, 'mongodb');
+      if (existsSync(mongoDumpDir)) {
+        await execa('docker', [
+          'cp',
+          mongoDumpDir,
+          'ante-mongodb:/tmp/restore'
+        ]);
+
+        await execInContainer(
+          composeFile,
+          'mongodb',
+          ['mongorestore', '--drop', '--db', 'ante', '/tmp/restore/ante']
+        );
+      }
+
+      // Restore uploaded files
+      spinner.text = 'Restoring uploaded files...';
+      const uploadsDir = join(tempDir, 'uploads');
+      if (existsSync(uploadsDir)) {
+        await execa('docker', [
+          'cp',
+          uploadsDir,
+          'ante-backend:/app/'
+        ]);
+      }
+
+      // Restore configuration files
+      spinner.text = 'Restoring configuration...';
+      const envBackup = join(tempDir, 'env.backup');
+      if (existsSync(envBackup)) {
+        await execa('cp', [envBackup, join(installDir, '.env')]);
+      }
+
+      const composeBackup = join(tempDir, 'docker-compose.yml');
+      if (existsSync(composeBackup)) {
+        await execa('cp', [composeBackup, composeFile]);
+      }
+
+      // Start all services
+      spinner.text = 'Starting all services...';
+      await startServices(composeFile);
+
+      // Cleanup
+      spinner.text = 'Cleaning up...';
+      await execa('rm', ['-rf', tempDir]);
+
+      spinner.succeed(chalk.green('Restore completed successfully!'));
+
+      console.log(chalk.white('\n✓ PostgreSQL database restored'));
+      console.log(chalk.white('✓ MongoDB database restored'));
+      console.log(chalk.white('✓ Uploaded files restored'));
+      console.log(chalk.white('✓ Configuration restored'));
+      console.log(chalk.white('✓ All services started'));
+
+      console.log(chalk.cyan('\nANTE is now running with restored data'));
+
+    } catch (error) {
+      spinner.fail(chalk.red('Restore failed'));
+      console.error(chalk.red('\nError:'), error.message);
+
+      // Try to start services anyway
+      try {
+        await startServices(composeFile);
+      } catch (startError) {
+        console.error(chalk.red('Failed to start services:'), startError.message);
+      }
+
+      throw error;
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\nRestore failed:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Get file size in human-readable format
+ */
+function getSizeSync(filePath) {
+  try {
+    const stats = require('fs').statSync(filePath);
+    const bytes = stats.size;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    if (bytes === 0) return '0 B';
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+  } catch (error) {
+    return 'Unknown';
+  }
+}

package/src/commands/service.js

@@ -0,0 +1,72 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { join } from 'path';
+import { getInstallDir } from '../utils/config.js';
+import { startServices, stopServices, restartServices } from '../utils/docker.js';
+
+/**
+ * Start ANTE services
+ */
+export async function start(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+    
+    const spinner = ora('Starting ANTE services...').start();
+    
+    const services = options.service ? [options.service] : [];
+    await startServices(composeFile, services);
+    
+    spinner.succeed(services.length ? `${options.service} started` : 'All services started');
+    console.log(chalk.gray('\nRun "ante status" to check service status\n'));
+    
+  } catch (error) {
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Stop ANTE services
+ */
+export async function stop(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+    
+    const spinner = ora('Stopping ANTE services...').start();
+    
+    const services = options.service ? [options.service] : [];
+    await stopServices(composeFile, services);
+    
+    spinner.succeed(services.length ? `${options.service} stopped` : 'All services stopped');
+    console.log();
+    
+  } catch (error) {
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Restart ANTE services
+ */
+export async function restart(options) {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+    
+    const spinner = ora('Restarting ANTE services...').start();
+    
+    const services = options.service ? [options.service] : [];
+    await restartServices(composeFile, services);
+    
+    spinner.succeed(services.length ? `${options.service} restarted` : 'All services restarted');
+    console.log(chalk.gray('\nRun "ante status" to check service status\n'));
+    
+  } catch (error) {
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+}
+

package/src/commands/status.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { join } from 'path';
+import { getInstallDir } from '../utils/config.js';
+import { getServiceStatus } from '../utils/docker.js';
+
+/**
+ * Show ANTE service status
+ */
+export async function status() {
+  try {
+    const installDir = getInstallDir();
+    const composeFile = join(installDir, 'docker-compose.yml');
+    
+    console.log(chalk.bold('\n📊 ANTE ERP Status\n'));
+    
+    const services = await getServiceStatus(composeFile);
+    
+    if (services.length === 0) {
+      console.log(chalk.yellow('No services running'));
+      console.log(chalk.gray('Run "ante start" to start services\n'));
+      return;
+    }
+    
+    const table = new Table({
+      head: [
+        chalk.cyan('Service'),
+        chalk.cyan('Status'),
+        chalk.cyan('Health'),
+        chalk.cyan('Ports')
+      ],
+      style: {
+        head: [],
+        border: ['gray']
+      }
+    });
+    
+    for (const service of services) {
+      const statusIcon = service.State === 'running' ? chalk.green('●') : chalk.red('●');
+      const healthIcon = service.Health === 'healthy' ? chalk.green('✓') : 
+                        service.Health === 'unhealthy' ? chalk.red('✗') : 
+                        chalk.yellow('○');
+      
+      table.push([
+        service.Service,
+        `${statusIcon} ${service.State}`,
+        service.Health ? `${healthIcon} ${service.Health}` : chalk.gray('N/A'),
+        service.Publishers?.map(p => `${p.PublishedPort}→${p.TargetPort}`).join(', ') || chalk.gray('internal')
+      ]);
+    }
+    
+    console.log(table.toString());
+    console.log();
+    
+    const allHealthy = services.every(s => s.State === 'running');
+    
+    if (allHealthy) {
+      console.log(chalk.green('✓ All services running\n'));
+    } else {
+      console.log(chalk.yellow('⚠ Some services are not running'));
+      console.log(chalk.gray('Run "ante restart" to restart services\n'));
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+