@kakuzu_aon/apkz 1.0.0

package/src/commands/install.js

@@ -0,0 +1,258 @@
+// ────────────[ KAKUZU ]────────────────────────────
+// | Discord  : kakuzu_aon
+// | Telegram : kakuzu_aon
+// | Github   : kakuzu-aon
+// | File     : install.js
+// | License  : MIT License © 2026 Kakuzu
+// | Brief    : APK install 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 { exec } = require('child_process');
+const util = require('util');
+const execPromise = util.promisify(exec);
+
+const installCommand = new Command('install')
+    .description('Install APK on connected device')
+    .argument('<apk-file>', 'APK file to install')
+    .option('-d, --device <id>', 'Target specific device ID')
+    .option('-r, --replace', 'Replace existing application')
+    .option('--allow-downgrade', 'Allow downgrade of installed app')
+    .option('--no-test', 'Skip compatibility test')
+    .action(async (apkFile, options) => {
+        let spinner;
+        try {
+            if (!fs.existsSync(apkFile)) {
+                console.error(chalk.red(`🔴 Error: APK file not found: ${apkFile}`));
+                process.exit(1);
+            }
+
+            spinner = ora('📱 Installing APK...').start();
+            
+            await installAPK(apkFile, options);
+            
+            spinner.succeed('APK installed successfully!');
+            
+        } catch (error) {
+            if (spinner) spinner.fail('Installation failed');
+            console.error(chalk.red('🔴 Error:'), error.message);
+            process.exit(1);
+        }
+    });
+
+async function installAPK(apkPath, options) {
+    const resolvedApkPath = path.resolve(apkPath);
+    
+    // Check ADB availability
+    const adbAvailable = await checkADB();
+    if (!adbAvailable) {
+        throw new Error('ADB (Android Debug Bridge) not found. Please install Android SDK tools.');
+    }
+    
+    // Get connected devices
+    const devices = await getConnectedDevices();
+    if (devices.length === 0) {
+        throw new Error('No connected Android devices found. Please connect a device and enable USB debugging.');
+    }
+    
+    // Select device
+    let targetDevice;
+    if (options.device) {
+        targetDevice = devices.find(d => d.id === options.device);
+        if (!targetDevice) {
+            throw new Error(`Device not found: ${options.device}`);
+        }
+    } else if (devices.length === 1) {
+        targetDevice = devices[0];
+    } else {
+        targetDevice = await selectDevice(devices);
+    }
+    
+    console.log(chalk.blue(`📱 Installing on: ${targetDevice.model} (${targetDevice.id})`));
+    
+    // Test APK compatibility if not disabled
+    if (!options.noTest) {
+        await testCompatibility(resolvedApkPath, targetDevice.id);
+    }
+    
+    // Install APK
+    await performInstall(resolvedApkPath, targetDevice.id, options);
+}
+
+async function checkADB() {
+    try {
+        await execPromise('adb version');
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+async function getConnectedDevices() {
+    try {
+        const { stdout } = await execPromise('adb devices -l');
+        const lines = stdout.split('\n').slice(1); // Skip header
+        
+        const devices = [];
+        
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('*')) {
+                const parts = trimmed.split(/\s+/);
+                const deviceId = parts[0];
+                const status = parts[1];
+                
+                if (status === 'device') {
+                    // Get device model
+                    try {
+                        const { stdout: modelOutput } = await execPromise(`adb -s ${deviceId} shell getprop ro.product.model`);
+                        const model = modelOutput.trim();
+                        devices.push({ id: deviceId, model, status });
+                    } catch (error) {
+                        devices.push({ id: deviceId, model: 'Unknown', status });
+                    }
+                }
+            }
+        }
+        
+        return devices;
+    } catch (error) {
+        throw new Error(`Failed to get connected devices: ${error.message}`);
+    }
+}
+
+async function selectDevice(devices) {
+    const inquirer = require('inquirer');
+    
+    const { deviceId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'deviceId',
+            message: 'Select device to install on:',
+            choices: devices.map(d => ({
+                name: `${d.model} (${d.id})`,
+                value: d.id
+            }))
+        }
+    ]);
+    
+    return devices.find(d => d.id === deviceId);
+}
+
+async function testCompatibility(apkPath, deviceId) {
+    console.log(chalk.blue('🔍 Testing compatibility...'));
+    
+    try {
+        // Get device Android version
+        const { stdout: sdkVersion } = await execPromise(`adb -s ${deviceId} shell getprop ro.build.version.sdk`);
+        const deviceSDK = parseInt(sdkVersion.trim());
+        
+        // Get device architecture
+        const { stdout: abi } = await execPromise(`adb -s ${deviceId} shell getprop ro.product.cpu.abi`);
+        const deviceABI = abi.trim();
+        
+        console.log(chalk.gray(`  • Device SDK: ${deviceSDK}`));
+        console.log(chalk.gray(`  • Device ABI: ${deviceABI}`));
+        
+        // Basic APK analysis
+        const AdmZip = require('adm-zip');
+        const zip = new AdmZip(apkPath);
+        const entries = zip.getEntries();
+        
+        // Check for native libraries
+        const libEntries = entries.filter(e => e.entryName.startsWith('lib/'));
+        const supportedABIs = new Set();
+        
+        libEntries.forEach(entry => {
+            const parts = entry.entryName.split('/');
+            if (parts.length >= 3) {
+                supportedABIs.add(parts[1]);
+            }
+        });
+        
+        if (supportedABIs.size > 0 && !supportedABIs.has(deviceABI)) {
+            console.log(chalk.yellow(`⚠️  APK supports ${Array.from(supportedABIs).join(', ')} but device is ${deviceABI}`));
+            console.log(chalk.yellow('  Installation may fail due to incompatible native libraries'));
+        }
+        
+        console.log(chalk.green('✅ Compatibility test completed'));
+        
+    } catch (error) {
+        console.log(chalk.yellow(`⚠️  Could not perform compatibility test: ${error.message}`));
+    }
+}
+
+async function performInstall(apkPath, deviceId, options) {
+    let installCommand = `adb -s ${deviceId} install`;
+    
+    if (options.replace) {
+        installCommand += ' -r';
+    }
+    
+    if (options.allowDowngrade) {
+        installCommand += ' -d';
+    }
+    
+    installCommand += ` "${apkPath}"`;
+    
+    try {
+        console.log(chalk.blue('📦 Installing APK...'));
+        
+        const { stdout, stderr } = await execPromise(installCommand);
+        
+        if (stdout.includes('Success')) {
+            console.log(chalk.green('✅ APK installed successfully'));
+            
+            // Get package name for additional info
+            try {
+                const AdmZip = require('adm-zip');
+                const zip = new AdmZip(apkPath);
+                
+                // Try to extract package name from manifest
+                console.log(chalk.blue('🔍 Getting app info...'));
+                
+                // Launch app if possible
+                setTimeout(async () => {
+                    try {
+                        // This is a simplified approach - would need manifest parsing for package name
+                        console.log(chalk.gray('💡 Tip: Use apkz info to get package name for launching'));
+                    } catch (error) {
+                        // Ignore launch errors
+                    }
+                }, 2000);
+                
+            } catch (error) {
+                // Ignore info extraction errors
+            }
+            
+        } else {
+            console.log(chalk.yellow('⚠️  Installation completed with warnings:'));
+            console.log(chalk.gray(stdout));
+            if (stderr) {
+                console.log(chalk.gray(stderr));
+            }
+        }
+        
+    } catch (error) {
+        // Check for common installation errors
+        const errorMessage = error.message;
+        
+        if (errorMessage.includes('INSTALL_FAILED_INSUFFICIENT_STORAGE')) {
+            throw new Error('Device storage insufficient. Free up space and try again.');
+        } else if (errorMessage.includes('INSTALL_FAILED_ALREADY_EXISTS') && !options.replace) {
+            throw new Error('App already installed. Use --replace to update existing installation.');
+        } else if (errorMessage.includes('INSTALL_FAILED_VERSION_DOWNGRADE') && !options.allowDowngrade) {
+            throw new Error('Trying to install older version. Use --allow-downgrade to force install.');
+        } else if (errorMessage.includes('INSTALL_FAILED_NO_MATCHING_ABIS')) {
+            throw new Error('Incompatible device architecture. APK native libraries don\'t match device.');
+        } else {
+            throw new Error(`Installation failed: ${errorMessage}`);
+        }
+    }
+}
+
+module.exports = installCommand;