ante-erp-cli 1.10.2 → 1.10.4

package/bin/ante-cli.js

@@ -94,6 +94,7 @@ const backupCmd = program
   .description('Create backup of ANTE ERP databases (PostgreSQL and MongoDB)')
   .option('-o, --output <path>', 'Output file path')
   .option('-k, --keyword <text>', 'Add keyword to backup filename for easier identification')
+  .option('--clean', 'Clean up backups older than 24 hours before creating new backup')
   .action(backup);
 
 backupCmd

package/package.json

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

package/src/commands/backup.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import inquirer from 'inquirer';
 import { join } from 'path';
-import { readdirSync, readFileSync } from 'fs';
+import { readdirSync, readFileSync, statSync } from 'fs';
 import { execa } from 'execa';
 import Table from 'cli-table3';
 import { getInstallDir } from '../utils/config.js';
@@ -31,6 +31,37 @@ function generateTimestamp() {
   return `${year}-${month}-${day}_${hoursStr}-${minutes}-${seconds}-${ampm}`;
 }
 
+/**
+ * Clean up backups older than 24 hours
+ * @param {string} backupDir - Path to backups directory
+ * @returns {Promise<Array>} Array of deleted backup info
+ */
+async function cleanOldBackups(backupDir) {
+  try {
+    const files = readdirSync(backupDir).filter(f => f.endsWith('.tar.gz'));
+    const now = Date.now();
+    const twentyFourHours = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+
+    const deleted = [];
+
+    for (const file of files) {
+      const filePath = join(backupDir, file);
+      const stats = statSync(filePath);
+      const fileAge = now - stats.mtimeMs;
+
+      if (fileAge > twentyFourHours) {
+        await execa('rm', [filePath]);
+        const ageInHours = Math.floor(fileAge / (60 * 60 * 1000));
+        deleted.push({ file, age: ageInHours });
+      }
+    }
+
+    return deleted;
+  } catch (error) {
+    throw new Error(`Cleanup failed: ${error.message}`);
+  }
+}
+
 /**
  * Create backup of ANTE ERP databases (PostgreSQL and MongoDB)
  */
@@ -40,6 +71,27 @@ export async function backup(options) {
     const composeFile = join(installDir, 'docker-compose.yml');
     const backupDir = join(installDir, 'backups');
 
+    // Clean old backups if --clean flag is provided
+    if (options.clean) {
+      console.log(chalk.cyan('\n🧹 Cleaning up old backups...\n'));
+
+      try {
+        const deleted = await cleanOldBackups(backupDir);
+
+        if (deleted.length > 0) {
+          console.log(chalk.green(`✓ Deleted ${deleted.length} backup(s) older than 24 hours:\n`));
+          deleted.forEach(({ file, age }) => {
+            console.log(chalk.gray(`  - ${file} (${age} hours old)`));
+          });
+          console.log();
+        } else {
+          console.log(chalk.gray('No backups older than 24 hours found.\n'));
+        }
+      } catch (cleanupError) {
+        console.log(chalk.yellow(`⚠ Warning: ${cleanupError.message}\n`));
+      }
+    }
+
     // Prompt for keyword if not provided via flag
     let keyword = options.keyword;
     if (!keyword) {
@@ -87,7 +139,18 @@ export async function backup(options) {
         'ante_db'
       ]);
 
+      // Get PostgreSQL dump size for progress indication
+      const { stdout: pgSizeOutput } = await execa('docker', [
+        'exec',
+        'ante-postgres',
+        'sh',
+        '-c',
+        'du -h /tmp/postgres.dump | cut -f1'
+      ]);
+      const pgSize = pgSizeOutput.trim();
+
       // Copy dump file from container to temp directory
+      spinner.text = `Copying PostgreSQL dump from container (${pgSize})...`;
       await execa('docker', [
         'cp',
         'ante-postgres:/tmp/postgres.dump',
@@ -139,7 +202,12 @@ export async function backup(options) {
         throw new Error(`MongoDB backup failed: ${mongoResult.error}`);
       }
 
+      // Get MongoDB dump size for progress indication
+      const { stdout: mongoSizeOutput } = await execa('du', ['-sh', join(mongoDumpTempDir, mongoInfo.database)]);
+      const mongoSize = mongoSizeOutput.split('\t')[0];
+
       // Move MongoDB dump to final structure (mongodb/ folder)
+      spinner.text = `Organizing MongoDB dump (${mongoSize})...`;
       await execa('mv', [
         join(mongoDumpTempDir, mongoInfo.database),
         join(tempDir, 'mongodb')
@@ -148,8 +216,12 @@ export async function backup(options) {
       // Remove temporary MongoDB dump directory
       await execa('rm', ['-rf', mongoDumpTempDir]);
 
+      // Get total size before compression
+      const { stdout: totalSizeOutput } = await execa('du', ['-sh', tempDir]);
+      const totalSize = totalSizeOutput.split('\t')[0];
+
       // Create tar.gz archive
-      spinner.text = 'Creating compressed archive...';
+      spinner.text = `Creating compressed archive (${totalSize})...`;
       await execa('mkdir', ['-p', backupDir]);
       await execa('tar', [
         '-czf',

package/src/commands/clone-db.js

@@ -261,32 +261,38 @@ export async function cloneDb(sourceUrl, options = {}) {
 
       // Generate Prisma client
       const generateSpinner = ora('Generating Prisma client...').start();
+      const generateStartTime = Date.now();
       try {
         await execInContainer(
           composeFile,
           'backend',
           ['npx', 'prisma', 'generate']
         );
-        generateSpinner.succeed(chalk.green('Prisma client generated'));
+        const generateDuration = ((Date.now() - generateStartTime) / 1000).toFixed(1);
+        generateSpinner.succeed(chalk.green(`Prisma client generated (${generateDuration}s)`));
         generateSuccess = true;
       } catch (error) {
         generateSpinner.fail(chalk.red('Prisma generate failed'));
         console.log(chalk.yellow('  Warning: You may need to run "npx prisma generate" manually in the backend container'));
+        console.log(chalk.gray(`  Error: ${error.message}`));
       }
 
       // Run Prisma migrations
       const migrateSpinner = ora('Running Prisma migrations...').start();
+      const migrateStartTime = Date.now();
       try {
         await execInContainer(
           composeFile,
           'backend',
           ['npx', 'prisma', 'migrate', 'deploy']
         );
-        migrateSpinner.succeed(chalk.green('Prisma migrations completed'));
+        const migrateDuration = ((Date.now() - migrateStartTime) / 1000).toFixed(1);
+        migrateSpinner.succeed(chalk.green(`Prisma migrations completed (${migrateDuration}s)`));
         migrateSuccess = true;
       } catch (error) {
         migrateSpinner.fail(chalk.red('Prisma migrate failed'));
         console.log(chalk.yellow('  Note: Database schema already exists from restore. Migrations may not be needed.'));
+        console.log(chalk.gray(`  Error: ${error.message}`));
       }
       console.log('');
     }

package/src/commands/restore.js

@@ -2,10 +2,10 @@ import chalk from 'chalk';
 import ora from 'ora';
 import inquirer from 'inquirer';
 import { join, basename } from 'path';
-import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, statSync } from 'fs';
 import { execa } from 'execa';
 import { getInstallDir } from '../utils/config.js';
-import { execInContainer, stopServices, startServices } from '../utils/docker.js';
+import { execInContainer, stopServices, startServices, waitForHealthy } from '../utils/docker.js';
 
 /**
  * Restore ANTE ERP databases from backup (PostgreSQL and MongoDB only)
@@ -96,46 +96,62 @@ export async function restore(backupFile, options = {}) {
       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));
+      // Wait for databases to be healthy (replaces fixed waits)
+      spinner.text = 'Waiting for databases to be ready...';
+      await waitForHealthy(composeFile, ['postgres', 'mongodb', 'redis'], 60);
 
       // Restore PostgreSQL
-      spinner.text = 'Restoring PostgreSQL database...';
       const pgDumpFile = join(tempDir, 'postgres.dump');
       if (existsSync(pgDumpFile)) {
-        // Drop and recreate database
+        // Get dump size for progress indication
+        const stats = statSync(pgDumpFile);
+        const sizeInMB = Math.round(stats.size / (1024 * 1024));
+
+        // Copy dump file to container (file-based restore, zero memory usage)
+        spinner.text = `Copying PostgreSQL dump to container (${sizeInMB}MB)...`;
+        await execa('docker', [
+          'cp',
+          pgDumpFile,
+          'ante-postgres:/tmp/postgres.dump'
+        ]);
+
+        // Drop database (connect to postgres database to avoid connection errors)
+        spinner.text = 'Preparing PostgreSQL database...';
         await execInContainer(
           composeFile,
           'postgres',
-          ['psql', '-U', 'ante', '-c', 'DROP DATABASE IF EXISTS ante_db;']
+          ['psql', '-U', 'ante', '-d', 'postgres', '-c', 'DROP DATABASE IF EXISTS ante_db;']
         );
+
+        // Create database (connect to postgres database)
         await execInContainer(
           composeFile,
           'postgres',
-          ['psql', '-U', 'ante', '-c', 'CREATE DATABASE ante_db;']
+          ['psql', '-U', 'ante', '-d', 'postgres', '-c', 'CREATE DATABASE ante_db;']
         );
 
-        // Restore from dump
-        const dumpContent = await execa('cat', [pgDumpFile]);
+        // Restore from file inside container (streaming, zero memory)
+        spinner.text = `Restoring PostgreSQL database (${sizeInMB}MB)...`;
         await execInContainer(
           composeFile,
           'postgres',
-          ['pg_restore', '-U', 'ante', '-d', 'ante_db'],
-          { input: dumpContent.stdout }
+          ['sh', '-c', 'pg_restore -U ante -d ante_db /tmp/postgres.dump && rm /tmp/postgres.dump']
         );
       }
 
       // Restore MongoDB
-      spinner.text = 'Restoring MongoDB database...';
       const mongoDumpDir = join(tempDir, 'mongodb');
       if (existsSync(mongoDumpDir)) {
+        // Get folder size for progress indication
+        const { stdout: mongoSize } = await execa('du', ['-sh', mongoDumpDir]);
+        const sizeStr = mongoSize.split('\t')[0];
+
+        spinner.text = `Restoring MongoDB database (${sizeStr})...`;
+
         // Copy MongoDB dump directory to container
         // The backup structure is: mongodb/ contains the database files directly
         await execa('docker', [
@@ -145,7 +161,6 @@ export async function restore(backupFile, options = {}) {
         ]);
 
         // Restore from the mongodb directory (contains BSON files)
-        // Use --nsInclude to restore all collections from the dump
         await execInContainer(
           composeFile,
           'mongodb',

package/src/utils/docker.js

@@ -182,18 +182,53 @@ export async function isServiceHealthy(composeFile, service) {
  */
 export async function waitForServiceHealthy(composeFile, service, timeout = 120) {
   const startTime = Date.now();
-  
+
   while (Date.now() - startTime < timeout * 1000) {
     if (await isServiceHealthy(composeFile, service)) {
       return true;
     }
-    
+
     await new Promise(resolve => setTimeout(resolve, 2000));
   }
-  
+
   return false;
 }
 
+/**
+ * Wait for multiple services to be healthy
+ * @param {string} composeFile - Path to docker-compose.yml
+ * @param {string[]} services - Array of service names
+ * @param {number} timeout - Timeout in seconds (default: 60)
+ * @returns {Promise<boolean>} True if all services are healthy
+ */
+export async function waitForHealthy(composeFile, services, timeout = 60) {
+  const endTime = Date.now() + (timeout * 1000);
+
+  while (Date.now() < endTime) {
+    try {
+      const serviceStatuses = await getServiceStatus(composeFile);
+
+      const allHealthy = services.every(serviceName => {
+        const service = serviceStatuses.find(s => s.Service === serviceName);
+        if (!service) return false;
+
+        // Service is healthy if: running AND (healthy OR no healthcheck)
+        return service.State === 'running' &&
+               (service.Health === 'healthy' || service.Health === undefined || service.Health === '');
+      });
+
+      if (allHealthy) return true;
+
+    } catch (error) {
+      // Continue waiting
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 2000)); // Check every 2s
+  }
+
+  throw new Error(`Services failed to become healthy within ${timeout}s: ${services.join(', ')}`);
+}
+
 /**
  * Down all services and optionally remove volumes
  * @param {string} composeFile - Path to docker-compose.yml