dbsafedump 0.0.1 → 1.0.3

package/bin/cli.js

@@ -1 +1,719 @@
-console.log('DBSafeDump CLI placeholder');
+const { Command } = require('commander');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { loadConfig, saveConfig, getDefaultConfig, generateSalt, generateConfig, getDefaultConfigPath, updateConfigField, listProfiles, validateProfile } = require('../src/config');
+const { runDump, runSchema, runImport, runScrub, runTestConnections } = require('../src/commands');
+const { checkLicense, getTierInfo, getMaxRows, canScrub, canUseMultiProfile, canUseCI, canUseSmartDiscovery, shouldShowBadge } = require('../src/license');
+const { activate, deactivate, isActivated, getLicenseInfo, getCachePath, removeAll, saveLicenseKey, loadCache, decrypt } = require('../src/license');
+const { getFingerprintData } = require('../src/license');
+const { discoverSensitiveColumns, applyDiscoveryToConfig } = require('../src/smartDiscovery');
+const { createConnection, closeConnection, getTables } = require('../src/database');
+
+let currentTier = 'free';
+
+async function checkAndShowLicense() {
+    const result = await checkLicense();
+    currentTier = result.tier || 'free';
+    
+    if (shouldShowBadge()) {
+        console.log(chalk.gray(`DBSafeDump FREE Edition - Row limit: ${getMaxRows()}/table`));
+        console.log(chalk.gray('Activate license: dbsafedump activate "LICENSE-KEY"'));
+        console.log(chalk.gray('Upgrade at: https://dbsafedump.com/pricing\n'));
+    }
+    
+    return currentTier;
+}
+
+const program = new Command();
+
+program
+    .name('dbsafedump')
+    .description('Safe database dump with anonymization')
+    .version('1.0.1');
+
+program
+    .command('init')
+    .description('Initialize DBSafeDump configuration')
+    .option('-f, --force', 'Overwrite existing config')
+    .action(async (options) => {
+        const configPath = getDefaultConfigPath();
+        const fs = require('fs');
+        
+        if (fs.existsSync(configPath) && !options.force) {
+            console.log(chalk.yellow(`Config already exists: ${configPath}`));
+            console.log(chalk.gray('Use --force to overwrite'));
+            console.log(chalk.gray('Running config wizard...\n'));
+        } else {
+            const config = generateConfig();
+            saveConfig(config);
+            console.log(chalk.green(`Configuration created: ${configPath}`));
+            console.log(chalk.gray('\nGenerated unique salt for deterministic masking.\n'));
+        }
+        
+        const { runConfigWizard } = require('../src/commands/config');
+        await runConfigWizard();
+    });
+
+program
+    .command('activate')
+    .description('Activate license on this machine')
+    .argument('<key>', 'License key')
+    .action(async (key) => {
+        console.log(chalk.blue(`\nDBSafeDump - License Activation\n`));
+        
+        if (isActivated()) {
+            console.log(chalk.yellow('License already activated on this machine.'));
+            console.log(chalk.gray('Use: dbsafedump deactivate first\n'));
+            return;
+        }
+        
+        console.log(chalk.gray('Connecting to license server...\n'));
+        
+        try {
+            const result = await activate(key);
+            
+            if (result.data && result.checksum) {
+                try {
+                    const data = decrypt(result.data, result.checksum);
+                    
+                    if (data.valid) {
+                        saveLicenseKey(key);
+                        
+                        console.log(chalk.green('License activated successfully!'));
+                        console.log(chalk.gray(`   Tier: ${data.tier.toUpperCase()}`));
+                        console.log(chalk.gray(`   Expires: ${data.expiresAt || 'N/A'}`));
+                        console.log('');
+                    } else {
+                        console.log(chalk.red('License activation failed.'));
+                        if (data.error) {
+                            console.log(chalk.red(`   Error: ${data.error}`));
+                        }
+                        console.log('');
+                        console.log(chalk.gray(`[LOG] Activation failed: ${JSON.stringify(data)}\n`));
+                    }
+                } catch (decryptError) {
+                    console.log(chalk.red('Failed to verify license response.'));
+                    console.log(chalk.red(`   ${decryptError.message}`));
+                    console.log(chalk.gray('\n   This may indicate a server configuration issue.\n'));
+                    console.log(chalk.gray(`[LOG] Decrypt error: ${decryptError.message}\n`));
+                }
+            } else {
+                console.log(chalk.red('Invalid response from license server.'));
+                console.log(chalk.gray('   Received:', JSON.stringify(result)));
+                console.log('');
+                console.log(chalk.gray(`[LOG] Invalid API response: ${JSON.stringify(result)}\n`));
+            }
+        } catch (error) {
+            console.log(chalk.red('Activation failed:'));
+            console.log(chalk.red(`   ${error.message}`));
+            console.log(chalk.gray('\nMake sure you have an internet connection.\n'));
+            console.log(chalk.gray(`[LOG] Activation error: ${error.message}\n`));
+        }
+    });
+
+program
+    .command('deactivate')
+    .description('Deactivate license (releases for another machine)')
+    .action(async () => {
+        console.log(chalk.blue(`\nDBSafeDump - License Deactivation\n`));
+        
+        if (!isActivated()) {
+            console.log(chalk.yellow('No license activated on this machine.\n'));
+            return;
+        }
+        
+        const licenseInfo = getLicenseInfo();
+        console.log(chalk.gray(`Current license: ${licenseInfo.key}`));
+        console.log(chalk.gray(`Tier: ${(licenseInfo.cached?.tier || 'unknown').toUpperCase()}\n`));
+        
+        try {
+            const result = await deactivate(licenseInfo.key);
+            
+            let reason = null;
+            
+            if (result.data && result.checksum) {
+                try {
+                    const data = decrypt(result.data, result.checksum);
+                    reason = data.reason;
+                } catch (e) {
+                    // Nie udało się odszyfrować
+                }
+            }
+            
+            if (reason === 'license_deactivated') {
+                removeAll();
+                console.log(chalk.green('License deactivated successfully.'));
+                console.log(chalk.gray('You can now activate this license on another machine.\n'));
+            } else if (reason === 'fingerprint_mismatch') {
+                console.log(chalk.red('This license is registered to a different machine.'));
+                console.log(chalk.gray('Local license data removed.\n'));
+                removeAll();
+            } else if (reason === 'license_not_found') {
+                console.log(chalk.red('License not found on server.'));
+                console.log(chalk.gray('Local license data removed.\n'));
+                removeAll();
+            } else {
+                console.log(chalk.yellow('Warning: Could not deactivate on server.'));
+                console.log(chalk.gray('Removing local license data...\n'));
+                removeAll();
+            }
+        } catch (error) {
+            console.log(chalk.yellow('Warning: Could not connect to server.'));
+            console.log(chalk.gray('Removing local license data anyway...\n'));
+            removeAll();
+            console.log(chalk.green('Local license removed.'));
+            console.log(chalk.gray('Note: Server-side license may still be registered to this machine.\n'));
+        }
+    });
+
+program
+    .command('license')
+    .description('Show current license status')
+    .action(async () => {
+        console.log(chalk.blue(`\nDBSafeDump - License Status\n`));
+        
+        if (!isActivated()) {
+            console.log(chalk.yellow('No license activated.'));
+            console.log(chalk.gray('Usage: dbsafedump activate "LICENSE-KEY"\n'));
+            return;
+        }
+        
+        const info = getLicenseInfo();
+        const cached = loadCache();
+        
+        console.log(chalk.green('License is activated\n'));
+        console.log(chalk.gray(`Key: ${info.key}`));
+        console.log(chalk.gray(`Tier: ${(cached?.tier || 'unknown').toUpperCase()}`));
+        console.log(chalk.gray(`Valid: ${cached?.valid ? 'Yes' : 'Unknown'}`));
+        
+        if (info.cacheAge) {
+            const ageMinutes = Math.floor(info.cacheAge / 60000);
+            console.log(chalk.gray(`Cache age: ${ageMinutes} minutes`));
+        }
+        
+        console.log(chalk.gray(`\nStored in: ${getCachePath()}\n`));
+        
+        await checkAndShowLicense();
+    });
+
+program
+    .command('profiles')
+    .description('List available profiles (STARTER/PRO)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .action(async (options) => {
+        const config = loadConfig(options.config);
+        
+            if (!config) {
+                console.log(chalk.yellow('Config file not found. Running configuration wizard...\n'));
+                const runConfig = require('../src/commands/config');
+                await runConfig();
+                return;
+            }
+        
+            await checkAndShowLicense();
+            
+            if (!canUseMultiProfile()) {
+            console.log(chalk.red('\nMulti-profile requires STARTER or PRO license.'));
+            console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+            return;
+        }
+        
+        const profiles = listProfiles(options.config);
+        
+        if (profiles.length === 0) {
+            console.log(chalk.yellow('\nNo profiles defined in config.'));
+            console.log(chalk.gray('\nAdd profiles to config.yml:'));
+            console.log(chalk.gray('  profiles:'));
+            console.log(chalk.gray('    dev:'));
+            console.log(chalk.gray('      connections:'));
+            console.log(chalk.gray('        source: { host: localhost, ... }'));
+            console.log(chalk.gray('\nThen use: dbsafedump dump --profile dev\n'));
+            return;
+        }
+        
+        console.log(chalk.blue(`\nAvailable profiles:\n`));
+        for (const name of profiles) {
+            const validation = validateProfile(config, name);
+            if (validation.valid) {
+                console.log(chalk.green(`  ${name}`));
+            } else {
+                console.log(chalk.red(`  ${name} (invalid: ${validation.error})`));
+            }
+        }
+        console.log('');
+    });
+
+program
+    .command('generate-salt')
+    .description('Generate new salt for config (forces re-masking)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+        const configPath = options.config || getDefaultConfigPath();
+        const fs = require('fs');
+        
+        const config = loadConfig(configPath);
+        
+        if (!config) {
+            console.log(chalk.red('Config file not found'));
+            console.log(chalk.gray('Run: dbsafedump init first'));
+            return;
+        }
+        
+        const oldSalt = config.salt;
+        
+        if (!options.yes) {
+            console.log(chalk.yellow('Warning: Generating new salt will change all masked values!'));
+            console.log(chalk.yellow('   Existing masked data will no longer match.'));
+            console.log(chalk.gray(`   Old salt: ${oldSalt ? oldSalt.substring(0, 8) + '...' : 'none'}\n`));
+            
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Generate new salt?',
+                    default: false
+                }
+            ]);
+            
+            if (!confirm) {
+                console.log(chalk.gray('Cancelled.\n'));
+                return;
+            }
+        }
+        
+        const newSalt = generateSalt();
+        updateConfigField(configPath, 'salt', newSalt);
+        
+        console.log(chalk.green('New salt generated!'));
+        console.log(chalk.gray(`   Old salt: ${oldSalt ? oldSalt.substring(0, 16) + '...' : 'none'}`));
+        console.log(chalk.green(`   New salt: ${newSalt.substring(0, 16)}...`));
+        console.log(chalk.yellow('\nWarning: Re-run dump/import to apply new masking!\n'));
+    });
+
+async function runDumpWithSchema(config, options) {
+    const isCI = options.ci || options.yes;
+    
+    if (!isCI) {
+        console.log(chalk.blue(`\nRunning schema check first...\n`));
+        await runSchema(config);
+        
+        console.log(chalk.yellow(`\nProceed with dump?`));
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Continue with dump?',
+                default: true
+            }
+        ]);
+        
+        if (!confirm) {
+            console.log(chalk.gray('\nDump cancelled.\n'));
+            return;
+        }
+    }
+    
+    if (isCI) {
+        console.log(chalk.gray(`\n[CI MODE] Running in automated mode...\n`));
+    }
+    
+    await runDump(config, options);
+}
+
+program
+    .command('dump')
+    .description('Dump database with anonymization')
+    .option('-o, --output <file>', 'Output file', 'dump.sql')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .option('-p, --profile <name>', 'Use named profile (STARTER/PRO)')
+    .option('-y, --yes', 'Skip schema check and confirmation (for CI/CD)')
+    .option('--ci', 'CI/CD mode - no prompts (PRO)')
+    .action(async (options) => {
+        try {
+            const config = loadConfig(options.config, options.profile);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            
+            if (options.profile && !canUseMultiProfile()) {
+                console.log(chalk.red('\nProfiles require STARTER or PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (options.ci && !canUseCI()) {
+                console.log(chalk.red('\nCI/CD mode requires PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source) {
+                console.log(chalk.red('Invalid config: missing source connection'));
+                return;
+            }
+            
+            await runDumpWithSchema(config, options);
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+async function runImportWithSchema(config, options) {
+    const validModes = ['truncate', 'append'];
+    const isCI = options.ci || options.yes;
+    
+    if (!isCI) {
+        console.log(chalk.blue(`\nRunning schema check first...\n`));
+        await runSchema(config);
+        
+        console.log(chalk.yellow(`\nProceed with import?`));
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Continue with import?',
+                default: true
+            }
+        ]);
+        
+        if (!confirm) {
+            console.log(chalk.gray('\nImport cancelled.\n'));
+            return;
+        }
+        
+        const { mode } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'mode',
+                message: 'Select import mode:',
+                choices: [
+                    { name: 'Truncate & Replace', value: 'truncate' },
+                    { name: 'Append', value: 'append' }
+                ],
+                default: 'truncate'
+            }
+        ]);
+        
+        options.mode = mode;
+    }
+    
+    if (isCI) {
+        console.log(chalk.gray(`\n[CI MODE] Running in automated mode...\n`));
+    }
+    
+    await runImport(config, options);
+}
+
+program
+    .command('import')
+    .description('Dump and import directly to target database (STARTER/PRO only)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .option('-p, --profile <name>', 'Use named profile (STARTER/PRO)')
+    .option('-m, --mode <mode>', 'Import mode: truncate or append (skip prompt)', 'prompt')
+    .option('-y, --yes', 'Skip schema check and confirmation (for CI/CD)')
+    .option('--ci', 'CI/CD mode - no prompts (PRO)')
+    .action(async (options) => {
+        try {
+            const validModes = ['truncate', 'append', 'prompt'];
+            if (options.mode && !validModes.includes(options.mode)) {
+                console.log(chalk.red(`Invalid mode: ${options.mode}`));
+                console.log(chalk.gray('Valid modes: truncate, append'));
+                return;
+            }
+            
+            if (options.mode === 'prompt') {
+                options.mode = undefined;
+            }
+            
+            const config = loadConfig(options.config, options.profile);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            
+            if (options.profile && !canUseMultiProfile()) {
+                console.log(chalk.red('\nProfiles require STARTER or PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (options.ci && !canUseCI()) {
+                console.log(chalk.red('\nCI/CD mode requires PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (!canScrub()) {
+                console.log(chalk.red('\nImport/Scrub requires STARTER or PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source || !config.connections.target) {
+                console.log(chalk.red('Invalid config: missing source or target connection'));
+                return;
+            }
+            
+            await runImportWithSchema(config, options);
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('schema')
+    .description('Show database schema (tables, keys, row counts)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .action(async (options) => {
+        try {
+            const config = loadConfig(options.config);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source) {
+                console.log(chalk.red('Invalid config: missing source connection'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            await runSchema(config);
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('test-connection')
+    .description('Test database connections (source and target)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .action(async (options) => {
+        try {
+            const config = loadConfig(options.config);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source) {
+                console.log(chalk.red('Invalid config: missing source connection'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            await runTestConnections(config);
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('config')
+    .description('Configure database connections interactively')
+    .action(async () => {
+        const runConfig = require('../src/commands/config');
+        await runConfig();
+    });
+
+program
+    .command('discover')
+    .description('Analyze database and suggest masking rules (STARTER/PRO)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .option('-p, --profile <name>', 'Use named profile (STARTER/PRO)')
+    .option('-o, --output <file>', 'Save suggestions to file')
+    .option('-a, --apply', 'Apply suggestions to config file')
+    .action(async (options) => {
+        try {
+            const config = loadConfig(options.config, options.profile);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            
+            if (!canUseSmartDiscovery()) {
+                console.log(chalk.red('\nSmart Discovery requires STARTER or PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source) {
+                console.log(chalk.red('Invalid config: missing source connection'));
+                return;
+            }
+            
+            const tier = getTierInfo();
+            console.log(chalk.blue(`\nDBSafeDump - Smart Discovery`));
+            console.log(chalk.gray(`Running ${tier === 'pro' ? 'FULL' : 'BASIC'} analysis...\n`));
+            
+            const sourceConfig = config.connections.source;
+            const driver = sourceConfig.driver || 'mysql';
+            
+            const sourceTest = await require('../src/database').testConnection(sourceConfig);
+            if (!sourceTest.success) {
+                console.log(chalk.red(`Source connection failed!`));
+                console.log(chalk.red(`   ${sourceTest.message}\n`));
+                return;
+            }
+            console.log(chalk.green(`Connected to ${driver}://${sourceConfig.host}/${sourceConfig.database}\n`));
+            
+            const conn = await createConnection(sourceConfig);
+            const allTables = await getTables(conn, driver);
+            const { shouldProcessTable } = require('../src/commands/utils');
+            const tables = allTables.filter(t => shouldProcessTable(t, config));
+            
+            console.log(chalk.gray(`Analyzing ${tables.length} tables...\n`));
+            
+            const discoveryResults = await discoverSensitiveColumns(conn, driver, tables, config);
+            
+            await closeConnection(conn, driver);
+            
+            if (Object.keys(discoveryResults).length === 0) {
+                console.log(chalk.yellow('\nNo sensitive columns detected.\n'));
+                return;
+            }
+            
+            console.log(chalk.green(`\nDiscovered ${Object.keys(discoveryResults).length} tables with sensitive data:\n`));
+            
+            for (const [table, columns] of Object.entries(discoveryResults)) {
+                console.log(chalk.cyan(`  ${table}:`));
+                for (const col of columns) {
+                    const mask = col.suggestedMask || 'sensitive';
+                    const confidence = col.confidence || 'unknown';
+                    console.log(chalk.gray(`    - ${col.column}: ${mask} (${confidence})`));
+                }
+            }
+            
+            const suggestions = require('../src/smartDiscovery').generateConfigSuggestions(discoveryResults);
+            
+            console.log(chalk.blue(`\nSuggested rules:\n`));
+            for (const [key, mask] of Object.entries(suggestions)) {
+                console.log(chalk.gray(`  "${key}": ${mask}`));
+            }
+            
+            if (!options.apply && !options.output) {
+                console.log(chalk.blue(`\nNext steps:\n`));
+                console.log(chalk.gray(`  dbsafedump discover --apply     # Apply rules to config.yml`));
+                console.log(chalk.gray(`  dbsafedump discover --output rules.json  # Save to file\n`));
+            }
+            
+            if (options.apply) {
+                const { updateConfigField } = require('../src/config');
+                let applied = 0;
+                for (const [key, mask] of Object.entries(suggestions)) {
+                    if (updateConfigField(options.config || getDefaultConfigPath(), key, mask)) {
+                        applied++;
+                    }
+                }
+                console.log(chalk.green(`\nApplied ${applied} rules to config.\n`));
+            }
+            
+            if (options.output) {
+                const fs = require('fs');
+                fs.writeFileSync(options.output, JSON.stringify(suggestions, null, 2));
+                console.log(chalk.green(`Saved suggestions to: ${options.output}\n`));
+            }
+            
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            console.error(chalk.gray(error.stack));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('scrub')
+    .description('Anonymize data in-place in database (PRO)')
+    .option('-c, --config <file>', 'Config file', getDefaultConfigPath())
+    .option('-p, --profile <name>', 'Use named profile (STARTER/PRO)')
+    .option('-y, --yes', 'Skip confirmation')
+    .option('--ci', 'CI/CD mode (PRO)')
+    .option('--force', 'Skip confirmation (for CI/CD)')
+    .action(async (options) => {
+        try {
+            const config = loadConfig(options.config, options.profile);
+            
+            if (!config) {
+                console.log(chalk.red('Config file not found'));
+                console.log(chalk.gray('Run: dbsafedump init'));
+                return;
+            }
+            
+            await checkAndShowLicense();
+            
+            if (!canUseCI()) {
+                console.log(chalk.red('\nScrub requires PRO license.'));
+                console.log(chalk.gray('Get your license at: https://dbsafedump.com/pricing\n'));
+                return;
+            }
+            
+            if (!config.connections || !config.connections.source) {
+                console.log(chalk.red('Invalid config: missing source connection'));
+                return;
+            }
+            
+            const skipConfirm = options.ci || options.yes || options.force;
+            const dbConfig = config.connections.source;
+            const driver = dbConfig.driver || 'mysql';
+            
+            if (!skipConfirm) {
+                console.log(chalk.yellow(`\nWARNING: This will MODIFY data in your database!`));
+                console.log(chalk.yellow(`This operation CANNOT be undone!\n`));
+                console.log(chalk.red(`Target database:`));
+                console.log(chalk.red(`  ${driver}://${dbConfig.host}/${dbConfig.database}\n`));
+                
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Type "yes" to confirm the scrub operation:',
+                        default: false
+                    }
+                ]);
+                
+                if (!confirm) {
+                    console.log(chalk.gray('\nScrub cancelled.\n'));
+                    return;
+                }
+            } else {
+                console.log(chalk.yellow(`\nWARNING: This will MODIFY data in your database!`));
+                console.log(chalk.yellow(`This operation CANNOT be undone!\n`));
+                console.log(chalk.red(`Target database:`));
+                console.log(chalk.red(`  ${driver}://${dbConfig.host}/${dbConfig.database}\n`));
+                console.log(chalk.gray(`[${options.force ? 'FORCE' : 'CI MODE'}] Proceeding with scrub...\n`));
+            }
+            
+            await runScrub(config, options);
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}