devicely 2.2.13 → 2.2.14

package/lib/.logging-backup/devices.js.backup

@@ -1,54 +0,0 @@
-/**
- * Device listing utility for Devicely CLI
- */
-
-// Import deviceDetection from appropriate location
-let discoverAllDevices;
-try {
-    ({ discoverAllDevices } = require('./deviceDetection'));
-} catch (err) {
-    ({ discoverAllDevices } = require('../../deviceDetection'));
-}
-
-async function listDevices(options = {}) {
-    const devices = await discoverAllDevices();
-    
-    if (!devices || devices.length === 0) {
-        console.log('\n⚠️  No devices found');
-        console.log('\n💡 Tips:');
-        console.log('   • For iOS: Connect device via USB or ensure Xcode pairing');
-        console.log('   • For Android: Enable USB debugging and connect device');
-        return;
-    }
-
-    console.log(`\n✅ Found ${devices.length} device(s):\n`);
-    
-    devices.forEach((device, index) => {
-        const status = device.status === 'online' ? '🟢' : '🔴';
-        const platform = device.platform === 'ios' ? '🍎' : '🤖';
-        
-        console.log(`${index + 1}. ${status} ${platform} ${device.name}`);
-        
-        if (options.verbose) {
-            console.log(`   Platform: ${device.platform}`);
-            console.log(`   UDID: ${device.udid}`);
-            console.log(`   Type: ${device.type}`);
-            console.log(`   Status: ${device.status}`);
-            if (device.osVersion) {
-                console.log(`   OS Version: ${device.osVersion}`);
-            }
-            if (device.port) {
-                console.log(`   Port: ${device.port}`);
-            }
-            console.log('');
-        }
-    });
-    
-    if (!options.verbose) {
-        console.log('\n💡 Use --verbose for detailed information');
-    }
-}
-
-module.exports = {
-    listDevices
-};

package/lib/.logging-backup/doctor.js.backup

@@ -1,94 +0,0 @@
-/**
- * System requirements checker for Devicely
- */
-
-const { execSync } = require('child_process');
-const chalk = require('chalk');
-
-function checkCommand(command, name) {
-    try {
-        execSync(`which ${command}`, { stdio: 'ignore' });
-        console.log(`${chalk.green('✓')} ${name} installed`);
-        return true;
-    } catch (error) {
-        console.log(`${chalk.red('✗')} ${name} not found`);
-        return false;
-    }
-}
-
-function getVersion(command) {
-    try {
-        const version = execSync(command, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
-        return version.trim().split('\n')[0];
-    } catch (error) {
-        return 'Unknown';
-    }
-}
-
-async function checkDoctor() {
-    console.log('\n📋 System Requirements Check\n');
-    
-    let allGood = true;
-    
-    // Node.js
-    console.log(chalk.bold('Node.js:'));
-    const nodeVersion = process.version;
-    console.log(`${chalk.green('✓')} Version: ${nodeVersion}\n`);
-    
-    // iOS Tools
-    console.log(chalk.bold('iOS Automation Tools:'));
-    const hasXcode = checkCommand('xcodebuild', 'Xcode');
-    const hasIdevice = checkCommand('idevice_id', 'libimobiledevice');
-    const hasIproxy = checkCommand('iproxy', 'usbmuxd');
-    allGood = allGood && hasXcode && hasIdevice && hasIproxy;
-    console.log('');
-    
-    // Android Tools
-    console.log(chalk.bold('Android Automation Tools:'));
-    const hasAdb = checkCommand('adb', 'Android Debug Bridge (adb)');
-    allGood = allGood && hasAdb;
-    
-    if (hasAdb) {
-        const adbVersion = getVersion('adb --version');
-        console.log(`  Version: ${adbVersion}`);
-    }
-    console.log('');
-    
-    // Python (for UIAutomator2)
-    console.log(chalk.bold('Python:'));
-    const hasPython = checkCommand('python3', 'Python 3');
-    if (hasPython) {
-        const pythonVersion = getVersion('python3 --version');
-        console.log(`  Version: ${pythonVersion}`);
-    }
-    console.log('');
-    
-    // Summary
-    if (allGood) {
-        console.log(chalk.green.bold('✅ All requirements met!'));
-        console.log(chalk.gray('\nYou can start using Devicely with: devicely start'));
-    } else {
-        console.log(chalk.yellow.bold('⚠️  Some requirements are missing'));
-        console.log(chalk.gray('\n📖 Installation Guide:'));
-        
-        if (!hasIdevice || !hasIproxy) {
-            console.log(chalk.gray('\nFor iOS support:'));
-            console.log('  brew install libimobiledevice usbmuxd');
-        }
-        
-        if (!hasAdb) {
-            console.log(chalk.gray('\nFor Android support:'));
-            console.log('  brew install android-platform-tools');
-        }
-        
-        if (!hasPython) {
-            console.log(chalk.gray('\nFor Python:'));
-            console.log('  brew install python3');
-        }
-    }
-    console.log('');
-}
-
-module.exports = {
-    checkDoctor
-};

package/lib/.logging-backup/encryption.js.backup

@@ -1,61 +0,0 @@
-const crypto = require('crypto');
-
-const ENCRYPTION_CONFIG = {
-  algorithm: 'aes-256-cbc',
-  encoding: {
-    input: 'utf8',
-    output: 'hex'
-  },
-  keyDerivation: 'sha256',
-  keySeed: 'devicely-encryption-key-v1'
-};
-
-function generateKey() {
-  let packageName = 'devicely';
-  try {
-    const pkg = require('../../npm-package/package.json');
-    packageName = pkg.name;
-  } catch (e) {
-    try {
-      const pkg = require('../../package.json');
-      packageName = pkg.name;
-    } catch (e2) {
-      packageName = 'devicely';
-    }
-  }
-  const keySource = `${packageName}-${ENCRYPTION_CONFIG.keySeed}`;
-  return crypto.createHash(ENCRYPTION_CONFIG.keyDerivation).update(keySource).digest();
-}
-
-function generateIV() {
-  const ivSource = `${ENCRYPTION_CONFIG.keySeed}-iv`;
-  return crypto.createHash('md5').update(ivSource).digest();
-}
-
-function encrypt(content) {
-  try {
-    const key = generateKey();
-    const iv = generateIV();
-    const cipher = crypto.createCipheriv(ENCRYPTION_CONFIG.algorithm, key, iv);
-    let encrypted = cipher.update(content, ENCRYPTION_CONFIG.encoding.input, ENCRYPTION_CONFIG.encoding.output);
-    encrypted += cipher.final(ENCRYPTION_CONFIG.encoding.output);
-    return encrypted;
-  } catch (error) {
-    throw new Error(`Encryption failed: ${error.message}`);
-  }
-}
-
-function decrypt(encrypted) {
-  try {
-    const key = generateKey();
-    const iv = generateIV();
-    const decipher = crypto.createDecipheriv(ENCRYPTION_CONFIG.algorithm, key, iv);
-    let decrypted = decipher.update(encrypted, ENCRYPTION_CONFIG.encoding.output, ENCRYPTION_CONFIG.encoding.input);
-    decrypted += decipher.final(ENCRYPTION_CONFIG.encoding.input);
-    return decrypted;
-  } catch (error) {
-    throw new Error(`Decryption failed: ${error.message}`);
-  }
-}
-
-module.exports = { encrypt, decrypt, ENCRYPTION_CONFIG };

package/lib/.logging-backup/executor.js.backup

@@ -1,104 +0,0 @@
-/**
- * Command executor for Devicely CLI
- */
-
-const { spawn } = require('child_process');
-const path = require('path');
-const chalk = require('chalk');
-
-// Import deviceDetection from appropriate location
-let discoverAllDevices;
-try {
-    ({ discoverAllDevices } = require('./deviceDetection'));
-} catch (err) {
-    ({ discoverAllDevices } = require('../../deviceDetection'));
-}
-
-async function executeCommand(command, options = {}) {
-    const devices = await discoverAllDevices();
-    
-    if (!devices || devices.length === 0) {
-        console.log(chalk.red('\n❌ No devices found'));
-        return;
-    }
-
-    let targetDevices = devices.filter(d => d.status === 'online');
-    
-    if (options.device) {
-        targetDevices = devices.filter(d => 
-            d.name === options.device && d.status === 'online'
-        );
-        
-        if (targetDevices.length === 0) {
-            console.log(chalk.red(`\n❌ Device "${options.device}" not found or offline`));
-            return;
-        }
-    }
-
-    if (targetDevices.length === 0) {
-        console.log(chalk.yellow('\n⚠️  No online devices found'));
-        return;
-    }
-
-    console.log(chalk.cyan(`\nExecuting on ${targetDevices.length} device(s):`));
-    targetDevices.forEach(d => console.log(`  • ${d.name}`));
-    console.log('');
-
-    const scriptDir = path.join(__dirname, '../../scripts/shell');
-    
-    for (const device of targetDevices) {
-        const platform = device.platform;
-        const type = device.type;
-        
-        let scriptName;
-        if (platform === 'ios' && type === 'usb') {
-            scriptName = 'connect_ios_usb_multi_final.sh';
-        } else if (platform === 'ios' && type === 'wireless') {
-            scriptName = 'connect_ios_wireless_multi_final.sh';
-        } else if (platform === 'android' && type === 'usb') {
-            scriptName = 'connect_android_usb_multi_final.sh';
-        } else if (platform === 'android' && type === 'wireless') {
-            scriptName = 'connect_android_wireless_multi_final.sh';
-        } else {
-            console.log(chalk.yellow(`⚠️  Unsupported device type: ${platform}-${type}`));
-            continue;
-        }
-
-        const scriptPath = path.join(scriptDir, scriptName);
-        
-        console.log(chalk.blue(`[${device.name}] Running command...`));
-        
-        const child = spawn(scriptPath, ['-d', device.name, ...command.split(' ')], {
-            stdio: 'pipe'
-        });
-
-        child.stdout.on('data', (data) => {
-            const lines = data.toString().split('\n').filter(l => l.trim());
-            lines.forEach(line => {
-                console.log(chalk.gray(`  ${line}`));
-            });
-        });
-
-        child.stderr.on('data', (data) => {
-            const lines = data.toString().split('\n').filter(l => l.trim());
-            lines.forEach(line => {
-                console.log(chalk.red(`  ${line}`));
-            });
-        });
-
-        await new Promise((resolve) => {
-            child.on('close', (code) => {
-                if (code === 0) {
-                    console.log(chalk.green(`[${device.name}] ✅ Success\n`));
-                } else {
-                    console.log(chalk.red(`[${device.name}] ❌ Failed (exit code: ${code})\n`));
-                }
-                resolve();
-            });
-        });
-    }
-}
-
-module.exports = {
-    executeCommand
-};

package/lib/.logging-backup/hybridAI.js.backup

@@ -1,154 +0,0 @@
-/**
- * 🤖 HYBRID AI MANAGER
- * Intelligently chooses between Tiny AI (LLM) and Rule-based AI
- */
-
-class HybridAI {
-  constructor() {
-    this.logger = console;
-    this.tinyAI = null;
-    this.ruleBasedAI = null;
-    this.preferTinyAI = true; // User preference
-    this.stats = {
-      totalRequests: 0,
-      tinyAISuccess: 0,
-      ruleBasedFallback: 0,
-      errors: 0
-    };
-  }
-
-  /**
-   * 🧠 Main AI conversion with intelligent fallback
-   */
-  async convertCommand(text, devices = [], options = {}) {
-    this.stats.totalRequests++;
-    const startTime = Date.now();
-
-    try {
-      // Try Tiny AI first if available and preferred
-      if (this.preferTinyAI && await this.isTinyAIAvailable()) {
-        this.logger.info('🧠 HybridAI: Attempting Tiny AI conversion...');
-        
-        const result = await this.getTinyAI().convertCommand(text, devices, options);
-        
-        if (result && result.success && result.method === 'tiny-ai') {
-          this.stats.tinyAISuccess++;
-          this.logger.info(`✅ HybridAI: Tiny AI succeeded in ${Date.now() - startTime}ms`);
-          return result;
-        }
-      }
-
-      // Fallback to rule-based AI
-      this.logger.info('🔄 HybridAI: Using rule-based AI...');
-      const result = await this.getRuleBasedAI().convertCommand(text, devices, options);
-      
-      if (result && result.success) {
-        this.stats.ruleBasedFallback++;
-        result.method = 'rule-based';
-        this.logger.info(`✅ HybridAI: Rule-based AI succeeded in ${Date.now() - startTime}ms`);
-        return result;
-      }
-
-      // Both failed
-      this.stats.errors++;
-      return {
-        success: false,
-        error: 'Both AI systems failed to parse command',
-        processingTime: Date.now() - startTime,
-        method: 'none'
-      };
-
-    } catch (error) {
-      this.stats.errors++;
-      this.logger.error('❌ HybridAI: Error:', error.message);
-      
-      return {
-        success: false,
-        error: error.message,
-        processingTime: Date.now() - startTime,
-        method: 'error'
-      };
-    }
-  }
-
-  /**
-   * 🔍 Check if Tiny AI is available and ready
-   */
-  async isTinyAIAvailable() {
-    try {
-      const tinyAI = this.getTinyAI();
-      return await tinyAI.initialize();
-    } catch (error) {
-      return false;
-    }
-  }
-
-  /**
-   * 🧠 Get or create Tiny AI instance
-   */
-  getTinyAI() {
-    if (!this.tinyAI) {
-      try {
-        const TinyAI = require('./tinyAI');
-        this.tinyAI = new TinyAI();
-      } catch (error) {
-        this.logger.warn('⚠️ HybridAI: TinyAI not available:', error.message);
-        throw error;
-      }
-    }
-    return this.tinyAI;
-  }
-
-  /**
-   * 📏 Get or create rule-based AI instance
-   */
-  getRuleBasedAI() {
-    if (!this.ruleBasedAI) {
-      const LocalBuiltInAI = require('./localBuiltInAI');
-      this.ruleBasedAI = new LocalBuiltInAI();
-    }
-    return this.ruleBasedAI;
-  }
-
-  /**
-   * ⚙️ Configure AI preferences
-   */
-  configure(options = {}) {
-    if (typeof options.preferTinyAI === 'boolean') {
-      this.preferTinyAI = options.preferTinyAI;
-      this.logger.info(`🔧 HybridAI: Tiny AI preference set to ${this.preferTinyAI}`);
-    }
-  }
-
-  /**
-   * 📊 Get AI statistics and status
-   */
-  getStatus() {
-    const tinyAIStatus = this.tinyAI ? this.tinyAI.getStatus() : null;
-    
-    return {
-      preferTinyAI: this.preferTinyAI,
-      tinyAI: tinyAIStatus,
-      ruleBasedAI: { ready: true }, // Always available
-      stats: { ...this.stats },
-      successRate: this.stats.totalRequests > 0 
-        ? ((this.stats.tinyAISuccess + this.stats.ruleBasedFallback) / this.stats.totalRequests * 100).toFixed(1) + '%'
-        : 'N/A'
-    };
-  }
-
-  /**
-   * 🧹 Reset statistics
-   */
-  resetStats() {
-    this.stats = {
-      totalRequests: 0,
-      tinyAISuccess: 0,
-      ruleBasedFallback: 0,
-      errors: 0
-    };
-    this.logger.info('🧹 HybridAI: Statistics reset');
-  }
-}
-
-module.exports = HybridAI;