server/scripts/obfuscate.js

/**
 * 代码混淆脚本
 * 使用 javascript-obfuscator 混淆代码
 */
const JavaScriptObfuscator = require('javascript-obfuscator')
const fs = require('fs')
const path = require('path')
const config = require('../obfuscate.config.js')

/**
 * 混淆单个文件
 */
function obfuscateFile(inputPath, outputPath) {
  try {
    console.log(`混淆文件: ${inputPath} -> ${outputPath}`)
    
    const code = fs.readFileSync(inputPath, 'utf8')
    const obfuscationResult = JavaScriptObfuscator.obfuscate(code, config)
    const obfuscatedCode = obfuscationResult.getObfuscatedCode()
    
    // 确保输出目录存在
    const outputDir = path.dirname(outputPath)
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true })
    }
    
    fs.writeFileSync(outputPath, obfuscatedCode, 'utf8')
    console.log(`✅ 混淆完成: ${outputPath}`)
    
    return true
  } catch (error) {
    console.error(`❌ 混淆失败: ${inputPath}`, error.message)
    return false
  }
}

/**
 * 递归混淆目录中的所有 JS 文件
 */
function obfuscateDirectory(inputDir, outputDir) {
  if (!fs.existsSync(inputDir)) {
    console.error(`❌ 输入目录不存在: ${inputDir}`)
    return false
  }
  
  const files = fs.readdirSync(inputDir)
  let successCount = 0
  let failCount = 0
  
  files.forEach(file => {
    const inputPath = path.join(inputDir, file)
    const stat = fs.statSync(inputPath)
    
    if (stat.isDirectory()) {
      // 递归处理子目录
      const subOutputDir = path.join(outputDir, file)
      if (obfuscateDirectory(inputPath, subOutputDir)) {
        successCount++
      } else {
        failCount++
      }
    } else if (file.endsWith('.js') && !file.endsWith('.min.js')) {
      // 只混淆 .js 文件，跳过已压缩的文件
      const outputPath = path.join(outputDir, file)
      if (obfuscateFile(inputPath, outputPath)) {
        successCount++
      } else {
        failCount++
      }
    } else {
      // 复制非 JS 文件
      const outputPath = path.join(outputDir, file)
      const outputPathDir = path.dirname(outputPath)
      if (!fs.existsSync(outputPathDir)) {
        fs.mkdirSync(outputPathDir, { recursive: true })
      }
      fs.copyFileSync(inputPath, outputPath)
    }
  })
  
  console.log(`\n混淆统计: 成功 ${successCount} 个文件, 失败 ${failCount} 个文件`)
  return failCount === 0
}

// 主函数
function main() {
  const args = process.argv.slice(2)
  
  if (args.length < 2) {
    console.log('用法: node obfuscate.js <输入目录> <输出目录>')
    console.log('示例: node obfuscate.js dist dist-obfuscated')
    process.exit(1)
  }
  
  const inputDir = path.resolve(args[0])
  const outputDir = path.resolve(args[1])
  
  console.log('开始混淆代码...')
  console.log(`输入目录: ${inputDir}`)
  console.log(`输出目录: ${outputDir}\n`)
  
  if (obfuscateDirectory(inputDir, outputDir)) {
    console.log('\n✅ 所有文件混淆完成!')
    process.exit(0)
  } else {
    console.log('\n❌ 混淆过程中有错误')
    process.exit(1)
  }
}

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

module.exports = { obfuscateFile, obfuscateDirectory }