devicely 2.1.4 → 2.1.5

package/package.json

@@ -1,19 +1,13 @@
 {
   "name": "devicely",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "description": "Devicely - One Command, All Devices. AI Powered Mobile Automation for iOS and Android",
   "main": "lib/index.js",
   "bin": {
     "devicely": "./bin/devicely.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "node scripts/build-simple.js",
-    "build:obfuscated": "node scripts/build.js",
-    "compile:shell": "node scripts/compile-shell-scripts.js",
-    "verify:protection": "cd .. && ./verify-shell-protection.sh",
-    "postinstall": "node scripts/postinstall.js",
-    "prepack": "echo '📦 Packing for distribution...'"
+    "postinstall": "node scripts/postinstall.js"
   },
   "keywords": [
     "ios",
@@ -79,8 +73,5 @@
   "preferGlobal": true,
   "publishConfig": {
     "access": "public"
-  },
-  "devDependencies": {
-    "javascript-obfuscator": "^5.2.1"
   }
-}
+}

package/scripts/compile-shell-scripts.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * Shell Script Compiler using shc
+ * Compiles shell scripts to binary executables for protection
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SCRIPTS_DIR = path.join(__dirname, 'shell');
+const DIST_SHELL_DIR = path.join(__dirname, '../dist/scripts/shell');
+
+// Ensure dist directory structure exists
+function ensureDistStructure() {
+  const dirs = [
+    path.join(__dirname, '../dist'),
+    path.join(__dirname, '../dist/scripts'),
+    DIST_SHELL_DIR
+  ];
+  
+  dirs.forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+}
+
+// Check if shc is installed
+function checkShcInstalled() {
+  try {
+    execSync('which shc', { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+// Install shc if not present
+function installShc() {
+  console.log('📥 Installing shc (Shell Script Compiler)...');
+  
+  const platform = os.platform();
+  
+  try {
+    if (platform === 'darwin') {
+      console.log('   Using Homebrew to install shc...');
+      execSync('brew install shc', { stdio: 'inherit' });
+    } else if (platform === 'linux') {
+      console.log('   Installing shc on Linux...');
+      // Try different package managers
+      try {
+        execSync('sudo apt-get update && sudo apt-get install -y shc', { stdio: 'inherit' });
+      } catch (e) {
+        try {
+          execSync('sudo yum install -y shc', { stdio: 'inherit' });
+        } catch (e2) {
+          console.error('❌ Could not install shc. Please install manually.');
+          return false;
+        }
+      }
+    } else {
+      console.error('❌ Unsupported platform for automatic shc installation.');
+      return false;
+    }
+    console.log('✅ shc installed successfully!');
+    return true;
+  } catch (error) {
+    console.error('❌ Failed to install shc:', error.message);
+    return false;
+  }
+}
+
+// Compile a single shell script
+function compileShellScript(scriptPath, outputDir) {
+  const scriptName = path.basename(scriptPath, '.sh');
+  const outputBinary = path.join(outputDir, scriptName);
+  
+  console.log(`🔒 Compiling: ${scriptName}.sh -> ${scriptName} (binary)`);
+  
+  try {
+    // Copy script to output directory first
+    const tempScript = path.join(outputDir, path.basename(scriptPath));
+    fs.copyFileSync(scriptPath, tempScript);
+    
+    // Compile with shc
+    // -f: input file
+    // -o: output binary file
+    // -r: make binary relocatable (not require original .sh file)
+    // -v: verbose
+    const cmd = `shc -r -f "${tempScript}" -o "${outputBinary}"`;
+    execSync(cmd, { stdio: 'pipe' });
+    
+    // Make binary executable
+    fs.chmodSync(outputBinary, 0o755);
+    
+    // Clean up temporary files created by shc
+    const tempFiles = [
+      tempScript + '.x.c',  // C source file
+      tempScript           // Original script copy
+    ];
+    
+    tempFiles.forEach(file => {
+      if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+      }
+    });
+    
+    console.log(`   ✓ Binary created: ${scriptName}`);
+    return true;
+  } catch (error) {
+    console.error(`   ❌ Failed to compile ${scriptName}:`, error.message);
+    // Copy the original script as fallback
+    fs.copyFileSync(scriptPath, path.join(outputDir, path.basename(scriptPath)));
+    console.log(`   ⚠️  Fallback: Copied original script`);
+    return false;
+  }
+}
+
+// Compile all shell scripts
+function compileAllScripts() {
+  console.log('\n🛡️  Shell Script Protection Starting...\n');
+  
+  // Ensure dist structure exists
+  ensureDistStructure();
+  
+  // Check/install shc
+  if (!checkShcInstalled()) {
+    console.log('⚠️  shc not found. Attempting to install...');
+    if (!installShc()) {
+      console.error('❌ Cannot proceed without shc. Exiting...');
+      process.exit(1);
+    }
+  } else {
+    console.log('✅ shc is installed');
+  }
+  
+  // Ensure output directory exists
+  if (!fs.existsSync(DIST_SHELL_DIR)) {
+    fs.mkdirSync(DIST_SHELL_DIR, { recursive: true });
+  }
+  
+  // Get all shell scripts
+  if (!fs.existsSync(SCRIPTS_DIR)) {
+    console.error(`❌ Scripts directory not found: ${SCRIPTS_DIR}`);
+    process.exit(1);
+  }
+  
+  const shellScripts = fs.readdirSync(SCRIPTS_DIR)
+    .filter(file => file.endsWith('.sh'))
+    .map(file => path.join(SCRIPTS_DIR, file));
+  
+  if (shellScripts.length === 0) {
+    console.log('⚠️  No shell scripts found to compile');
+    return;
+  }
+  
+  console.log(`\n📋 Found ${shellScripts.length} shell scripts to compile\n`);
+  
+  let successCount = 0;
+  let failCount = 0;
+  
+  // Compile each script
+  shellScripts.forEach(scriptPath => {
+    if (compileShellScript(scriptPath, DIST_SHELL_DIR)) {
+      successCount++;
+    } else {
+      failCount++;
+    }
+  });
+  
+  // Summary
+  console.log('\n' + '='.repeat(60));
+  console.log('📊 Compilation Summary');
+  console.log('='.repeat(60));
+  console.log(`✅ Successfully compiled: ${successCount}`);
+  if (failCount > 0) {
+    console.log(`⚠️  Failed compilations: ${failCount}`);
+  }
+  console.log('='.repeat(60));
+  
+  // Remove .sh files from distribution (keep only binaries)
+  console.log('\n🗑️  Removing .sh files from distribution (keeping only binaries)...');
+  const shFiles = fs.readdirSync(DIST_SHELL_DIR).filter(f => f.endsWith('.sh'));
+  shFiles.forEach(shFile => {
+    const filePath = path.join(DIST_SHELL_DIR, shFile);
+    fs.unlinkSync(filePath);
+    console.log(`   ✓ Removed: ${shFile}`);
+  });
+  
+  console.log('\n✅ Shell script protection complete!');
+  console.log(`📁 Protected scripts in: ${DIST_SHELL_DIR}`);
+  console.log(`🛡️  Only binary executables remain (${successCount} files)\n`);
+}
+
+// Run if called directly
+if (require.main === module) {
+  try {
+    compileAllScripts();
+  } catch (error) {
+    console.error('❌ Error during compilation:', error);
+    process.exit(1);
+  }
+}
+
+module.exports = { compileAllScripts, compileShellScript };

package/scripts/encrypt-shell-simple.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * Simple Shell Script Encryption
+ * Encrypts .sh files to .enc files that are decrypted at runtime
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Generate encryption key
+function generateKey() {
+  const pkg = require('../package.json');
+  // Use only package name for consistent key across versions
+  return crypto.createHash('sha256').update(pkg.name + 'devicely-encryption-key-v1').digest();
+}
+
+// Encrypt a file
+function encryptFile(inputPath, outputPath) {
+  const content = fs.readFileSync(inputPath, 'utf8');
+  const key = generateKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+  
+  let encrypted = cipher.update(content, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  const data = JSON.stringify({
+    iv: iv.toString('hex'),
+    content: encrypted
+  });
+  
+  fs.writeFileSync(outputPath, data);
+  console.log(`   ✓ ${path.basename(inputPath)} → ${path.basename(outputPath)}`);
+}
+
+// Encrypt all shell scripts
+function encryptShellScripts(sourceDir, outputDir) {
+  console.log('🔐 Encrypting shell scripts...\n');
+  
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  const scripts = [
+    'android_device_control.sh',
+    'connect_android_usb_multi_final.sh',
+    'connect_android_wireless.sh',
+    'connect_android_wireless_multi_final.sh',
+    'connect_ios_usb_multi_final.sh',
+    'connect_ios_wireless_multi_final.sh',
+    'ios_device_control.sh'
+  ];
+
+  let encrypted = 0;
+  scripts.forEach(script => {
+    const srcPath = path.join(sourceDir, script);
+    if (fs.existsSync(srcPath)) {
+      const encPath = path.join(outputDir, script.replace('.sh', '.enc'));
+      encryptFile(srcPath, encPath);
+      encrypted++;
+    }
+  });
+
+  console.log(`\n✅ Encrypted ${encrypted} shell scripts\n`);
+}
+
+module.exports = { encryptShellScripts };
+
+if (require.main === module) {
+  const srcDir = path.join(__dirname, '../../');
+  const outDir = path.join(__dirname, '../dist/scripts/shell');
+  encryptShellScripts(srcDir, outDir);
+}

package/scripts/obfuscate-shell.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+/**
+ * Shell Script Obfuscator
+ * Obfuscates shell scripts using base64 encoding and encryption
+ * Cross-platform compatible
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Generate a key from package info (consistent across installations)
+function generateKey() {
+  const pkg = require('../package.json');
+  return crypto.createHash('sha256').update(pkg.name + pkg.version).digest();
+}
+
+// Encrypt script content
+function encryptScript(content) {
+  const key = generateKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+  
+  let encrypted = cipher.update(content, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  return {
+    iv: iv.toString('hex'),
+    content: encrypted
+  };
+}
+
+// Create wrapper script that decrypts and executes
+function createWrapper(scriptName, encrypted) {
+  return `#!/bin/bash
+# Protected Shell Script - Devicely
+# This script is encrypted for code protection
+
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+NODE_BIN="node"
+
+# Check if node is available
+if ! command -v node &> /dev/null; then
+    echo "Error: Node.js is required to run Devicely"
+    exit 1
+fi
+
+# Decrypt and execute
+$NODE_BIN -e "
+const crypto = require('crypto');
+const pkg = require('$SCRIPT_DIR/../../package.json');
+
+function generateKey() {
+  return crypto.createHash('sha256').update(pkg.name + pkg.version).digest();
+}
+
+function decrypt(iv, content) {
+  const key = generateKey();
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key, Buffer.from(iv, 'hex'));
+  let decrypted = decipher.update(content, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+}
+
+const encrypted = {
+  iv: '${encrypted.iv}',
+  content: '${encrypted.content}'
+};
+
+const script = decrypt(encrypted.iv, encrypted.content);
+const { spawn } = require('child_process');
+
+// Get arguments passed to this wrapper
+// When called as: node -e "..." -- arg1 arg2
+// process.argv is: ['/path/to/node', 'arg1', 'arg2', ...]
+// So we need slice(1) not slice(2)
+const args = process.argv.slice(1);
+
+// Create a temporary file for the decrypted script
+const tmpScript = require('path').join(require('os').tmpdir(), 'devicely_' + Date.now() + '.sh');
+require('fs').writeFileSync(tmpScript, script, { mode: 0o755 });
+
+// Execute the decrypted script with arguments using spawn
+const child = spawn(tmpScript, args, {
+  stdio: 'inherit',
+  env: process.env
+});
+
+child.on('exit', (code) => {
+  // Clean up temp file
+  try { require('fs').unlinkSync(tmpScript); } catch(e) {}
+  process.exit(code || 0);
+});
+
+child.on('error', (error) => {
+  // Clean up temp file on error
+  try { require('fs').unlinkSync(tmpScript); } catch(e) {}
+  console.error('Error executing script:', error);
+  process.exit(1);
+});
+"
+`;
+}
+
+// Obfuscate all shell scripts
+function obfuscateShellScripts(shellDir, outputDir) {
+  console.log('🔐 Obfuscating shell scripts...');
+  
+  if (!fs.existsSync(shellDir)) {
+    console.error('❌ Shell scripts directory not found');
+    return;
+  }
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  const shellScripts = fs.readdirSync(shellDir).filter(f => f.endsWith('.sh'));
+  
+  if (shellScripts.length === 0) {
+    console.log('⚠️  No shell scripts found');
+    return;
+  }
+
+  let processed = 0;
+  shellScripts.forEach(script => {
+    try {
+      const scriptPath = path.join(shellDir, script);
+      const content = fs.readFileSync(scriptPath, 'utf8');
+      
+      // Encrypt the script
+      const encrypted = encryptScript(content);
+      
+      // Create wrapper script
+      const wrapper = createWrapper(script, encrypted);
+      
+      // Write wrapper to output
+      const outputPath = path.join(outputDir, script);
+      fs.writeFileSync(outputPath, wrapper);
+      fs.chmodSync(outputPath, 0o755);
+      
+      console.log(`   ✓ ${script} → encrypted wrapper`);
+      processed++;
+    } catch (error) {
+      console.error(`   ❌ Failed to obfuscate ${script}:`, error.message);
+    }
+  });
+
+  console.log(`✅ Obfuscated ${processed} shell scripts`);
+}
+
+module.exports = { obfuscateShellScripts };
+
+// Run if called directly
+if (require.main === module) {
+  const shellSrc = path.join(__dirname, 'shell');
+  const distShell = path.join(__dirname, '../dist/scripts/shell');
+  obfuscateShellScripts(shellSrc, distShell);
+}