@kakuzu_aon/apkz 1.0.0

package/src/commands/config.js

@@ -0,0 +1,343 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : config.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : Configuration management command
+// ────────────────★─────────────────────────────────
+
+const { Command } = require('commander');
+const chalk = require('chalk').default;
+const { default: ora } = require('ora');
+const fs = require('fs-extra');
+const path = require('path');
+const ConfigManager = require('../utils/config');
+
+const configCommand = new Command('config')
+    .description('Manage APKZ configuration settings')
+    .addHelpCommand(true)
+    .addCommand(new Command('show')
+        .description('Show current configuration')
+        .option('-j, --json', 'Output as JSON')
+        .option('-s, --summary', 'Show configuration summary')
+        .action(async (options) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                if (options.summary) {
+                    const summary = config.getSummary();
+                    
+                    console.log(chalk.bold('📋 Configuration Summary:'));
+                    console.log(chalk.gray('─'.repeat(40)));
+                    console.log(chalk.cyan(`Version: ${summary.version}`));
+                    console.log(chalk.cyan(`Log Level: ${summary.logLevel}`));
+                    console.log(chalk.cyan(`Web Port: ${summary.webPort}`));
+                    console.log(chalk.cyan(`Parallel Processing: ${summary.parallelProcessing}`));
+                    console.log(chalk.cyan(`Security Level: ${summary.securityLevel}`));
+                    console.log(chalk.cyan(`Plugins Enabled: ${summary.pluginsEnabled}`));
+                    console.log(chalk.cyan(`Theme: ${summary.theme}`));
+                    console.log(chalk.cyan(`Cache Enabled: ${summary.cacheEnabled}`));
+                    
+                } else if (options.json) {
+                    console.log(config.toJSON());
+                    
+                } else {
+                    console.log(chalk.bold('⚙️  Current Configuration:'));
+                    console.log(chalk.gray('─'.repeat(50)));
+                    console.log(config.toJSON());
+                }
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('get <key>')
+        .description('Get a configuration value')
+        .action(async (key) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const value = config.get(key);
+                
+                if (value === null) {
+                    console.log(chalk.yellow(`⚠️  Configuration key not found: ${key}`));
+                    return;
+                }
+                
+                console.log(chalk.cyan(`📋 ${key}:`));
+                if (typeof value === 'object') {
+                    console.log(JSON.stringify(value, null, 2));
+                } else {
+                    console.log(value);
+                }
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('set <key> <value>')
+        .description('Set a configuration value')
+        .option('-t, --type <type>', 'Value type (string, number, boolean, json)', 'string')
+        .action(async (key, value, options) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                // Convert value based on type
+                let parsedValue = value;
+                
+                switch (options.type) {
+                    case 'number':
+                        parsedValue = parseFloat(value);
+                        if (isNaN(parsedValue)) {
+                            throw new Error('Invalid number value');
+                        }
+                        break;
+                    case 'boolean':
+                        parsedValue = value.toLowerCase() === 'true';
+                        break;
+                    case 'json':
+                        try {
+                            parsedValue = JSON.parse(value);
+                        } catch (e) {
+                            throw new Error('Invalid JSON value');
+                        }
+                        break;
+                }
+                
+                config.set(key, parsedValue);
+                await config.saveConfig();
+                
+                console.log(chalk.green(`✅ Set ${key} = ${JSON.stringify(parsedValue)}`));
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('delete <key>')
+        .description('Delete a configuration key')
+        .action(async (key) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const currentValue = config.get(key);
+                if (currentValue === null) {
+                    console.log(chalk.yellow(`⚠️  Configuration key not found: ${key}`));
+                    return;
+                }
+                
+                config.delete(key);
+                await config.saveConfig();
+                
+                console.log(chalk.green(`✅ Deleted configuration key: ${key}`));
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('reset')
+        .description('Reset configuration to defaults')
+        .option('-f, --force', 'Force reset without confirmation')
+        .action(async (options) => {
+            try {
+                if (!options.force) {
+                    const inquirer = require('inquirer');
+                    const { confirm } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: 'Are you sure you want to reset all configuration to defaults?',
+                            default: false
+                        }
+                    ]);
+                    
+                    if (!confirm) {
+                        console.log(chalk.yellow('⚠️  Reset cancelled'));
+                        return;
+                    }
+                }
+                
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('🔄 Resetting configuration...').start();
+                
+                await config.reset();
+                
+                spinner.succeed('Configuration reset to defaults');
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('export <file>')
+        .description('Export configuration to file')
+        .action(async (filePath) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('📤 Exporting configuration...').start();
+                
+                await config.export(filePath);
+                
+                spinner.succeed(`Configuration exported to: ${filePath}`);
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('import <file>')
+        .description('Import configuration from file')
+        .option('-m, --merge', 'Merge with existing configuration instead of replacing')
+        .action(async (filePath, options) => {
+            try {
+                if (!fs.existsSync(filePath)) {
+                    console.error(chalk.red(`🔴 Configuration file not found: ${filePath}`));
+                    process.exit(1);
+                }
+                
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('📥 Importing configuration...').start();
+                
+                if (options.merge) {
+                    // Merge logic would go here
+                    console.log(chalk.yellow('⚠️  Merge mode not yet implemented, using replace'));
+                }
+                
+                await config.import(filePath);
+                
+                spinner.succeed(`Configuration imported from: ${filePath}`);
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('backup')
+        .description('Create configuration backup')
+        .action(async () => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('💾 Creating backup...').start();
+                
+                const backupPath = await config.createBackup();
+                
+                spinner.succeed(`Backup created: ${backupPath}`);
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('restore <backup>')
+        .description('Restore configuration from backup')
+        .action(async (backupFile) => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('🔄 Restoring backup...').start();
+                
+                await config.restoreBackup(backupFile);
+                
+                spinner.succeed(`Configuration restored from: ${backupFile}`);
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('list-backups')
+        .description('List available configuration backups')
+        .action(async () => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const backups = await config.listBackups();
+                
+                if (backups.length === 0) {
+                    console.log(chalk.yellow('⚠️  No configuration backups found'));
+                    return;
+                }
+                
+                console.log(chalk.bold('💾 Available Backups:'));
+                console.log(chalk.gray('─'.repeat(60)));
+                
+                for (const backup of backups) {
+                    console.log(chalk.cyan(`📦 ${backup.name}`));
+                    console.log(chalk.gray(`  Size: ${backup.size} bytes`));
+                    console.log(chalk.gray(`  Created: ${backup.created.toLocaleString()}`));
+                    console.log(chalk.gray(`  Path: ${backup.path}`));
+                    console.log();
+                }
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('features')
+        .description('Show enabled/disabled features')
+        .action(async () => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const features = [
+                    'web', 'batch', 'monitoring', 'plugins', 'caching',
+                    'animations', 'colors', 'progressBars', 'autoBackup',
+                    'autoCleanup', 'webhook'
+                ];
+                
+                console.log(chalk.bold('🚀 Feature Status:'));
+                console.log(chalk.gray('─'.repeat(40)));
+                
+                for (const feature of features) {
+                    const enabled = config.isFeatureEnabled(feature);
+                    const icon = enabled ? '✅' : '❌';
+                    const color = enabled ? chalk.green : chalk.red;
+                    console.log(`${color(icon)} ${feature.padEnd(15)} ${enabled ? 'Enabled' : 'Disabled'}`);
+                }
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }))
+    .addCommand(new Command('validate')
+        .description('Validate current configuration')
+        .action(async () => {
+            try {
+                const config = new ConfigManager();
+                await config.initialize();
+                
+                const spinner = ora('🔍 Validating configuration...').start();
+                
+                // Validation is done during initialization
+                spinner.succeed('Configuration is valid');
+                
+                console.log(chalk.green('✅ All configuration values are valid'));
+                
+            } catch (error) {
+                console.error(chalk.red('🔴 Error:'), error.message);
+                process.exit(1);
+            }
+        }));
+
+module.exports = configCommand;

package/src/commands/decode.js

@@ -0,0 +1,133 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : decode.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : APK decode command implementation
+// ────────────────★─────────────────────────────────
+
+const { Command } = require('commander');
+const chalk = require('chalk').default;
+const { default: ora } = require('ora');
+const fs = require('fs-extra');
+const path = require('path');
+const AdmZip = require('adm-zip');
+const cliProgress = require('cli-progress');
+
+const decodeCommand = new Command('decode')
+    .description('Decode APK resources and extract contents')
+    .argument('<apk-file>', 'APK file to decode')
+    .option('-o, --output <dir>', 'Output directory', './decoded')
+    .option('-f, --force', 'Overwrite existing output directory')
+    .option('--no-resources', 'Skip resource decoding')
+    .option('--no-dex', 'Skip DEX file extraction')
+    .action(async (apkFile, options) => {
+        let spinner;
+        try {
+            if (!fs.existsSync(apkFile)) {
+                console.error(chalk.red(`🔴 Error: APK file not found: ${apkFile}`));
+                process.exit(1);
+            }
+
+            const outputDir = path.resolve(options.output);
+            
+            if (fs.existsSync(outputDir) && !options.force) {
+                console.error(chalk.red(`🔴 Error: Output directory exists: ${outputDir}`));
+                console.error(chalk.yellow('💡 Use --force to overwrite'));
+                process.exit(1);
+            }
+
+            spinner = ora('🔧 Preparing to decode APK...').start();
+            
+            await decodeAPK(apkFile, outputDir, options);
+            
+            spinner.succeed('APK decoded successfully!');
+            
+            console.log(chalk.green(`✅ Decoded APK to: ${outputDir}`));
+            
+        } catch (error) {
+            if (spinner) spinner.fail('Decoding failed');
+            console.error(chalk.red('🔴 Error:'), error.message);
+            process.exit(1);
+        }
+    });
+
+async function decodeAPK(apkPath, outputDir, options) {
+    const zip = new AdmZip(apkPath);
+    const entries = zip.getEntries();
+    
+    // Create output directory
+    await fs.ensureDir(outputDir);
+    
+    const progressBar = new cliProgress.SingleBar({
+        format: chalk.cyan('📦 Extracting') + ' |{bar}| |{percentage}%| |{value}/{total}| files',
+        barCompleteChar: '█',
+        barIncompleteChar: '░',
+        hideCursor: true
+    });
+    
+    progressBar.start(entries.length, 0);
+    
+    let processed = 0;
+    
+    for (const entry of entries) {
+        const entryPath = path.join(outputDir, entry.entryName);
+        
+        try {
+            if (entry.isDirectory) {
+                await fs.ensureDir(entryPath);
+            } else {
+                // Skip certain files based on options
+                if (!options.dex && entry.entryName.endsWith('.dex')) {
+                    processed++;
+                    progressBar.update(processed);
+                    continue;
+                }
+                
+                if (!options.resources && entry.entryName === 'resources.arsc') {
+                    processed++;
+                    progressBar.update(processed);
+                    continue;
+                }
+                
+                await fs.ensureDir(path.dirname(entryPath));
+                await fs.writeFile(entryPath, entry.getData());
+            }
+        } catch (error) {
+            console.warn(chalk.yellow(`⚠️  Warning: Could not extract ${entry.entryName}: ${error.message}`));
+        }
+        
+        processed++;
+        progressBar.update(processed);
+    }
+    
+    progressBar.stop();
+    
+    // Create info file
+    const info = {
+        decoded_at: new Date().toISOString(),
+        source_apk: path.resolve(apkPath),
+        total_files: entries.length,
+        extracted_files: processed,
+        options: options
+    };
+    
+    await fs.writeJson(path.join(outputDir, 'decode_info.json'), info, { spaces: 2 });
+    
+    // Display summary
+    console.log(chalk.bold('\n📊 Decode Summary:'));
+    console.log(chalk.gray(`  • Total files: ${entries.length}`));
+    console.log(chalk.gray(`  • Extracted: ${processed}`));
+    console.log(chalk.gray(`  • Output: ${outputDir}`));
+    
+    if (!options.dex) {
+        console.log(chalk.yellow('  ⚠️  DEX files skipped'));
+    }
+    
+    if (!options.resources) {
+        console.log(chalk.yellow('  ⚠️  Resources skipped'));
+    }
+}
+
+module.exports = decodeCommand;