cli.js

#!/usr/bin/env node

/**
 * CLI interface for the JavaScript Reverse Engineering Tool
 */

const fs = require('fs');
const path = require('path');
const ReverseEngineer = require('./index.js');

const args = process.argv.slice(2);

function printHelp() {
  console.log(`
JavaScript Reverse Engineering Tool
====================================

Usage:
  reverse-engineer <command> <file> [options]

Commands:
  analyze <file>     - Analyze JavaScript code and show statistics
  beautify <file>    - Beautify/deobfuscate JavaScript code
  strings <file>     - Extract all unique strings from code
  functions <file>   - List all functions in the code
  patterns <file>    - Detect obfuscation patterns
  complexity <file>  - Analyze control flow and code complexity
  report <file>      - Generate full analysis report

Options:
  -o, --output <file>  - Save output to file (for beautify command)
  -h, --help          - Show this help message

Examples:
  reverse-engineer analyze script.js
  reverse-engineer beautify obfuscated.js -o clean.js
  reverse-engineer strings malware.js
  reverse-engineer report suspicious.js
  `);
}

function readFile(filePath) {
  try {
    const fullPath = path.resolve(filePath);
    if (!fs.existsSync(fullPath)) {
      console.error(`Error: File not found: ${filePath}`);
      process.exit(1);
    }
    return fs.readFileSync(fullPath, 'utf8');
  } catch (error) {
    console.error(`Error reading file: ${error.message}`);
    process.exit(1);
  }
}

function writeFile(filePath, content) {
  try {
    fs.writeFileSync(filePath, content, 'utf8');
    console.log(`Output written to: ${filePath}`);
  } catch (error) {
    console.error(`Error writing file: ${error.message}`);
    process.exit(1);
  }
}

function main() {
  if (args.length === 0 || args[0] === '-h' || args[0] === '--help') {
    printHelp();
    process.exit(0);
  }

  const command = args[0];
  const filePath = args[1];

  if (!filePath) {
    console.error('Error: No input file specified');
    printHelp();
    process.exit(1);
  }

  const code = readFile(filePath);
  const re = new ReverseEngineer(code);

  switch (command) {
    case 'analyze': {
      console.log('\n=== Code Analysis ===\n');
      const stats = re.getStatistics();
      console.log('Statistics:');
      console.log(`  Total Lines: ${stats.totalLines}`);
      console.log(`  Non-Empty Lines: ${stats.nonEmptyLines}`);
      console.log(`  Functions: ${stats.functionCount}`);
      console.log(`  Variables: ${stats.variableCount}`);
      console.log(`  String Literals: ${stats.stringCount} (${stats.uniqueStrings} unique)`);
      console.log(`  Number Literals: ${stats.numberCount}`);
      console.log(`  Avg Line Length: ${stats.averageLineLength} chars`);
      
      const patterns = re.getPatterns();
      if (patterns.length > 0) {
        console.log('\nDetected Patterns:');
        patterns.forEach(p => console.log(`  - ${p}`));
      }
      break;
    }

    case 'beautify': {
      console.log('Beautifying code...');
      const beautified = re.beautify();
      
      if (!beautified) {
        console.error('Error: Failed to beautify code');
        process.exit(1);
      }

      const outputIndex = args.indexOf('-o') !== -1 ? args.indexOf('-o') : args.indexOf('--output');
      
      if (outputIndex !== -1 && args[outputIndex + 1]) {
        writeFile(args[outputIndex + 1], beautified);
      } else {
        console.log('\n' + beautified);
      }
      break;
    }

    case 'strings': {
      console.log('\n=== Extracted Strings ===\n');
      const strings = re.getStrings();
      
      if (strings.length === 0) {
        console.log('No strings found.');
      } else {
        strings.forEach((str, idx) => {
          const preview = str.length > 60 ? str.substring(0, 60) + '...' : str;
          console.log(`${idx + 1}. "${preview}"`);
        });
        console.log(`\nTotal: ${strings.length} unique strings`);
      }
      break;
    }

    case 'functions': {
      console.log('\n=== Functions ===\n');
      const functions = re.getFunctions();
      
      if (functions.length === 0) {
        console.log('No functions found.');
      } else {
        functions.forEach((func, idx) => {
          const params = func.params.join(', ');
          const modifiers = [];
          if (func.async) modifiers.push('async');
          if (func.generator) modifiers.push('generator');
          const modStr = modifiers.length > 0 ? `[${modifiers.join(', ')}] ` : '';
          
          console.log(`${idx + 1}. ${modStr}${func.name}(${params})`);
          if (func.location) {
            console.log(`   Line: ${func.location.start.line}`);
          }
        });
        console.log(`\nTotal: ${functions.length} functions`);
      }
      break;
    }

    case 'patterns': {
      console.log('\n=== Detected Patterns ===\n');
      const patterns = re.getPatterns();
      
      if (patterns.length === 0) {
        console.log('No suspicious patterns detected.');
      } else {
        patterns.forEach((pattern, idx) => {
          console.log(`${idx + 1}. ${pattern}`);
        });
      }
      break;
    }

    case 'complexity': {
      console.log('\n=== Control Flow & Complexity Analysis ===\n');
      const cf = re.getControlFlow();
      
      // Complexity interpretation
      let complexityLevel = 'Low';
      let complexityColor = '✓';
      if (cf.complexity > 20) {
        complexityLevel = 'Very High';
        complexityColor = '⚠⚠⚠';
      } else if (cf.complexity > 10) {
        complexityLevel = 'High';
        complexityColor = '⚠⚠';
      } else if (cf.complexity > 5) {
        complexityLevel = 'Moderate';
        complexityColor = '⚠';
      }
      
      console.log('COMPLEXITY METRICS:');
      console.log(`  Cyclomatic Complexity: ${cf.complexity} ${complexityColor}`);
      console.log(`  Complexity Level: ${complexityLevel}`);
      console.log(`  Max Nesting Depth: ${cf.maxNesting}`);
      console.log(`  Control Flow Structures: ${cf.structures.length}`);
      
      if (cf.structures.length > 0) {
        console.log('\nCONTROL FLOW STRUCTURES:');
        
        // Group structures by type
        const byType = {};
        cf.structures.forEach(s => {
          const type = s.type;
          byType[type] = (byType[type] || 0) + 1;
        });
        
        Object.entries(byType).forEach(([type, count]) => {
          console.log(`  ${type}: ${count}`);
        });
        
        console.log('\nDETAILED STRUCTURES:');
        cf.structures.forEach((struct, idx) => {
          const indent = '  '.repeat(struct.nesting + 1);
          let info = `${indent}${idx + 1}. ${struct.type}`;
          
          if (struct.hasElse !== undefined) {
            info += struct.hasElse ? ' (with else)' : ' (no else)';
          }
          if (struct.cases !== undefined) {
            info += ` (${struct.cases} cases)`;
          }
          if (struct.hasCatch !== undefined || struct.hasFinally !== undefined) {
            const parts = [];
            if (struct.hasCatch) parts.push('catch');
            if (struct.hasFinally) parts.push('finally');
            info += ` (with ${parts.join(' and ')})`;
          }
          
          if (struct.location) {
            info += ` [Line ${struct.location.start.line}]`;
          }
          
          console.log(info);
        });
      }
      
      // Recommendations
      console.log('\nRECOMMENDATIONS:');
      const recs = re.getRecommendations();
      recs.forEach(r => console.log('  ' + r));
      break;
    }

    case 'report': {
      console.log('\n=== Full Analysis Report ===\n');
      const report = re.generateReport();
      
      console.log('STATISTICS:');
      console.log(`  Total Lines: ${report.statistics.totalLines}`);
      console.log(`  Non-Empty Lines: ${report.statistics.nonEmptyLines}`);
      console.log(`  Functions: ${report.statistics.functionCount}`);
      console.log(`  Variables: ${report.statistics.variableCount}`);
      console.log(`  Unique Strings: ${report.statistics.uniqueStrings}`);
      console.log(`  Numbers: ${report.statistics.numberCount}`);
      
      if (report.patterns.length > 0) {
        console.log('\nDETECTED PATTERNS:');
        report.patterns.forEach(p => console.log(`  - ${p}`));
      }
      
      console.log('\nCOMPLEXITY:');
      console.log(`  Cyclomatic Complexity: ${report.controlFlow.complexity}`);
      console.log(`  Max Nesting Depth: ${report.controlFlow.maxNesting}`);
      console.log(`  Control Structures: ${report.controlFlow.structures.length}`);
      
      console.log('\nFUNCTIONS:');
      report.functions.slice(0, 10).forEach((func, idx) => {
        console.log(`  ${idx + 1}. ${func.name}(${func.params.join(', ')})`);
      });
      if (report.functions.length > 10) {
        console.log(`  ... and ${report.functions.length - 10} more`);
      }
      
      console.log('\nSAMPLE STRINGS:');
      report.uniqueStrings.slice(0, 10).forEach((str, idx) => {
        const preview = str.length > 50 ? str.substring(0, 50) + '...' : str;
        console.log(`  ${idx + 1}. "${preview}"`);
      });
      if (report.uniqueStrings.length > 10) {
        console.log(`  ... and ${report.uniqueStrings.length - 10} more`);
      }
      break;
    }

    default:
      console.error(`Error: Unknown command: ${command}`);
      printHelp();
      process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = { main };