ee-bin 1.0.0

package/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+/**
+ * rd - Moves front-end resources to a specified directory
+ */
+program
+  .command('rd')
+  .description('Move frontend resources to public/dist')
+  .option('--dist-dir <folder>', 'title to use before name', './frontend/dist')
+  .action(function() {
+    const replaceDist = require('./tools/replaceDist');
+    replaceDist.run(this.opts());
+  });
+
+/**
+ * encrypt - Code encryption
+ */
+program
+  .command('encrypt')
+  .description('Code encryption')
+  .option('--config <folder>', 'config file', './electron/config/encrypt.js')
+  .option('--out <folder>', 'output directory', './public')
+  .action(function() {
+    const encrypt = require('./tools/encrypt');
+    encrypt.run(this.opts());
+  });
+
+/**
+ * clean - Clear the encrypted code
+ */
+program
+  .command('clean')
+  .description('Clear the encrypted code')
+  .option('-d, --dir <folder>', 'clean directory')
+  .action(function() {
+    const encrypt = require('./tools/encrypt');
+    encrypt.clean(this.opts());
+  });
+
+/**
+ * icon
+ */
+program
+  .command('icon')
+  .description('Generate logo')
+  .action(function() {
+    const iconGen = require('./tools/iconGen');
+    iconGen.run();
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "ee-bin",
+  "version": "1.0.0",
+  "description": "ee bin",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "bin": {
+    "ee-bin": "index.js"
+  },
+  "dependencies": {
+    "bytenode": "^1.3.6",
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "fs-extra": "^10.0.0",
+    "globby": "^10.0.0",
+    "is-type-of": "^1.2.1",
+    "javascript-obfuscator": "^4.0.2"
+  }
+}

package/tools/encrypt.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const fsPro = require('fs-extra');
+const is = require('is-type-of');
+const bytenode = require('bytenode');
+const crypto = require('crypto');
+const JavaScriptObfuscator = require('javascript-obfuscator');
+const globby = require('globby');
+const chalk = require('chalk');
+
+class Encrypt {
+  constructor(options = {}) {
+    // cli args
+    const outputFolder = options.out || './public';
+    const configFile = options.config || './electron/config/encrypt.js';
+
+    this.basePath = process.cwd();
+    this.encryptCodeDir = path.join(this.basePath, outputFolder);
+    this.config = this.loadConfig(configFile);
+    this.filesExt = this.config.fileExt || ['.js'];
+    this.type = this.config.type || 'confusion';
+    this.bOpt = this.config.bytecodeOptions || {};
+    this.cOpt = this.config.confusionOptions || {};
+    this.cleanFiles = this.config.cleanFiles || ['./public/electron'];
+    this.patterns = this.config.files || null;
+    this.specificFiles = [ 'electron/preload/bridge.js' ];
+
+    // 旧属性，将废弃
+    this.dirs = [];
+    const directory = this.config.directory || ['electron'];
+    for (let i = 0; i < directory.length; i++) {
+      let codeDirPath = path.join(this.basePath, directory[i]);
+      if (fs.existsSync(codeDirPath)) {
+        this.dirs.push(directory[i]);
+      }
+    }
+
+    this.codefiles = this._initCodeFiles();
+    //console.log('[ee-core] [encrypt] codefiles:', this.codefiles);
+    console.log('[ee-core] [encrypt] cleanFiles:', this.cleanFiles);
+  }
+
+  /**
+   * 初始化需要加密的文件列表
+   */
+  _initCodeFiles() {
+    if (!this.patterns) return;
+
+    const files = globby.sync(this.patterns, { cwd: this.basePath });
+    return files;
+  }
+
+  /**
+   * 备份代码
+   */
+  backup() {
+    // clean
+    this.cleanCode();
+
+    console.log('[ee-core] [encrypt] backup start');
+    if (this.patterns) {
+      this.codefiles.forEach((filepath) => {
+        let source = path.join(this.basePath, filepath);
+        if (fs.existsSync(source)) {
+          let target = path.join(this.encryptCodeDir, filepath);
+          fsPro.copySync(source, target);
+        }
+      })
+    } else {
+      // 旧的逻辑，将废弃
+      for (let i = 0; i < this.dirs.length; i++) {
+        // check code dir
+        let codeDirPath = path.join(this.basePath, this.dirs[i]);
+        if (!fs.existsSync(codeDirPath)) {
+          console.log('[ee-core] [encrypt] ERROR: backup %s is not exist', codeDirPath);
+          return
+        }
+  
+        // copy
+        let targetDir = path.join(this.encryptCodeDir, this.dirs[i]);
+        console.log('[ee-core] [encrypt] backup target Dir:', targetDir);
+        if (!fs.existsSync(targetDir)) {
+          this.mkdir(targetDir);
+          this.chmodPath(targetDir, '777');
+        }
+  
+        fsPro.copySync(codeDirPath, targetDir);
+      }
+    }
+
+    console.log('[ee-core] [encrypt] backup end');
+    return true;
+  }
+  
+  /**
+   * 清除加密代码
+   */
+  cleanCode() {
+    this.cleanFiles.forEach((file) => {
+      let tmpFile = path.join(this.basePath, file);
+      this.rmBackup(tmpFile);
+      console.log('[ee-core] [encrypt] clean up tmp files:', tmpFile);
+    })
+  }
+
+  /**
+   * 加密代码
+   */
+  encrypt() {
+    console.log('[ee-core] [encrypt] start ciphering');
+    if (this.patterns) {
+      for (const file of this.codefiles) {
+        const fullpath = path.join(this.encryptCodeDir, file);
+        if (!fs.statSync(fullpath).isFile()) continue;
+
+        // 特殊文件处理
+        if (this.specificFiles.includes(file)) {
+          this.generate(fullpath, 'confusion');
+          continue;
+        }
+
+        this.generate(fullpath);
+      }  
+    } else {
+      // 旧逻辑，将废弃
+      console.log('[ee-core] [encrypt] !!!!!! please use the new encryption method !!!!!!');
+      for (let i = 0; i < this.dirs.length; i++) {
+        let codeDirPath = path.join(this.encryptCodeDir, this.dirs[i]);
+        this.loop(codeDirPath);
+      }
+      console.log('[ee-core] [encrypt] !!!!!! please use the new encryption method !!!!!!');
+    }
+
+    console.log('[ee-core] [encrypt] end ciphering');
+  };
+
+  /**
+   * 递归
+   */
+  loop(dirPath) {
+    let files = [];
+    if (fs.existsSync(dirPath)) {
+      files = fs.readdirSync(dirPath);
+      files.forEach((file, index) => {
+        let curPath = dirPath + '/' + file;        
+        if (fs.statSync(curPath).isDirectory()) {
+          this.loop(curPath);
+        } else {
+          const extname = path.extname(curPath);
+          if (this.filesExt.indexOf(extname) !== -1) {
+            this.generate(curPath);
+          }
+        }
+      });
+    }
+  }
+
+  /**
+   * 生成文件
+   */  
+  generate(curPath, type) {
+    let encryptType = type ? type : this.type;
+
+    let tips = '[ee-core] [encrypt] file: ' + chalk.green(`${curPath}`) + ' ' + chalk.blue(`(${encryptType})`);
+    console.log(tips);
+
+    if (encryptType == 'bytecode') {
+      this.generateBytecodeFile(curPath);
+    } else if (encryptType == 'confusion') {
+      this.generateJSConfuseFile(curPath);
+    } else {
+      this.generateJSConfuseFile(curPath);
+      this.generateBytecodeFile(curPath);
+    }
+  }
+
+  /**
+   * 使用 javascript-obfuscator 生成压缩/混淆文件
+   */  
+  generateJSConfuseFile(file) {
+    let opt = Object.assign({
+      compact: true,
+      stringArray: true,
+      stringArrayThreshold: 1,
+    }, this.cOpt);
+    
+    let code = fs.readFileSync(file, "utf8");
+    let result = JavaScriptObfuscator.obfuscate(code, opt);
+    fs.writeFileSync(file, result.getObfuscatedCode(), "utf8"); 
+  }
+
+  /**
+   * 生成字节码文件
+   */
+  generateBytecodeFile(curPath) {
+    if (path.extname(curPath) !== '.js') {
+      return
+    }
+    //let jscFile = curPath.replace(/.js/g, '.jsc');
+    let jscFile = curPath + 'c';
+    let opt = Object.assign({
+      filename: curPath,
+      output: jscFile,
+      electron: true
+    }, this.bOpt);
+
+    bytenode.compileFile(opt);
+
+    //fs.writeFileSync(curPath, 'require("bytenode");module.exports = require("./'+path.basename(jscFile)+'");', 'utf8');
+
+	  fsPro.removeSync(curPath);
+  }
+
+  /**
+   * 移除备份
+   */
+  rmBackup(file) {
+    if (fs.existsSync(file)) {
+      fsPro.removeSync(file);
+    }
+    return;
+  }
+
+  /**
+   * 检查文件是否存在
+   */
+  fileExist(filePath) {
+    try {
+      return fs.statSync(filePath).isFile();
+    } catch (err) {
+      return false;
+    }
+  };
+
+  mkdir(dirpath, dirname) {
+    // 判断是否是第一次调用
+    if (typeof dirname === 'undefined') {
+      if (fs.existsSync(dirpath)) {
+        return;
+      }
+      this.mkdir(dirpath, path.dirname(dirpath));
+    } else {
+      // 判断第二个参数是否正常，避免调用时传入错误参数
+      if (dirname !== path.dirname(dirpath)) {
+        this.mkdir(dirpath);
+        return;
+      }
+      if (fs.existsSync(dirname)) {
+        fs.mkdirSync(dirpath);
+      } else {
+        this.mkdir(dirname, path.dirname(dirname));
+        fs.mkdirSync(dirpath);
+      }
+    }
+  };
+
+  chmodPath(path, mode) {
+    let files = [];
+    if (fs.existsSync(path)) {
+      files = fs.readdirSync(path);
+      files.forEach((file, index) => {
+        const curPath = path + '/' + file;
+        if (fs.statSync(curPath).isDirectory()) {
+          this.chmodPath(curPath, mode); // 递归删除文件夹
+        } else {
+          fs.chmodSync(curPath, mode);
+        }
+      });
+      fs.chmodSync(path, mode);
+    }
+  };
+
+  loadConfig(prop) {
+    const filepath = path.join(this.basePath, prop);
+    if (!fs.existsSync(filepath)) {
+      const errorTips = 'config file ' + chalk.blue(`${filepath}`) + ' does not exist !';
+      throw new Error(errorTips)
+    }
+    const obj = require(filepath);
+    if (!obj) return obj;
+
+    let ret = obj;
+    if (is.function(obj) && !is.class(obj)) {
+      ret = obj();
+    }
+
+    return ret || {};
+  };
+
+  md5(file) {
+    const buffer = fs.readFileSync(file);
+    const hash = crypto.createHash('md5');
+    hash.update(buffer, 'utf8');
+    const str = hash.digest('hex');
+    return str;
+  }
+}
+
+const run = (options = {}) => {
+  const e = new Encrypt(options);
+  if (!e.backup()) return;
+  e.encrypt();
+}
+
+const clean = (options = {}) => {
+  let files = options.dir !== undefined ? options.dir : ['./public/electron'];
+  files = is.string(files) ? [files] : files;
+
+  files.forEach((file) => {
+    const tmpFile = path.join(process.cwd(), file);
+    if (fs.existsSync(tmpFile)) {
+      fsPro.removeSync(tmpFile);
+      console.log('[ee-core] [encrypt] clean up tmp files:', tmpFile);
+    }
+  })
+}
+
+module.exports = {
+  run,
+  clean,
+};

package/tools/iconGen.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const fs = require("fs");
+const path = require("path");
+const icongen = require("icon-gen");
+
+class IconGen {
+  constructor() {
+    this._init();
+  }
+
+  /**
+   * _init
+   */
+  _init() {
+    // ---> 处理参数
+    const args = process.argv.splice(3);
+    let params = {
+      input: "/public/images/logo.png",
+      output: "/build/icons/",
+      size: "16,32,64,256,512",
+      clear: false,
+      imagesDir: "/public/images/",
+    };
+    try {
+      const len = args.length;
+      for (let i = 0; i < len; i++) {
+        const arg = args[i];
+        if (arg.match(/^-i/) || arg.match(/^-input/)) {
+          params["input"] = args[i + 1];
+          i++;
+          continue;
+        }
+        if (arg.match(/^-o/) || arg.match(/^-output/)) {
+          params["output"] = args[i + 1];
+          i++;
+          continue;
+        }
+        if (arg.match(/^-s/) || arg.match(/^-size/)) {
+          params["size"] = args[i + 1];
+          i++;
+          continue;
+        }
+        if (arg.match(/^-c/) || arg.match(/^-clear/)) {
+          params["clear"] = true;
+          continue;
+        }
+        if (arg.match(/^-img/) || arg.match(/^-images/)) {
+          params["imagesDir"] = args[i + 1];
+          i++;
+          continue;
+        }
+      }
+    } catch (e) {
+      console.error("[ee-core] [tools/iconGen] args: ", args);
+      console.error("[ee-core] [tools/iconGen] ERROR: ", e);
+      throw new Error("参数错误!!");
+    }
+    this.params = params;
+
+    // ---> 组装参数
+    console.log("[ee-core] [tools/iconGen] icon 当前路径: ", process.cwd());
+    this.input = path.join(process.cwd(), params.input);
+    this.output = path.join(process.cwd(), params.output);
+    this.imagesDir = path.join(process.cwd(), params.imagesDir);
+
+    const sizeList = params.size.split(",").map((item) => parseInt(item));
+    this.iconOptions = {
+      report: false,
+      ico: {
+        name: "icon",
+        sizes: [256],
+      },
+      favicon: {
+        name: "logo-",
+        pngSizes: sizeList,
+      },
+    };
+  }
+
+  /**
+   * 生成图标
+   */
+  generateIcons() {
+    console.log("[ee-core] [tools/iconGen] iconGen 开始处理生成logo图片");
+    if (!fs.existsSync(this.input)) {
+      console.error("[ee-core] [tools/iconGen] input: ", this.input);
+      throw new Error("输入的图片不存在或路径错误");
+    }
+    if (!fs.existsSync(this.output)) {
+      fs.mkdirSync(this.output, { recursive: true });
+    } else {
+      // 清空目录
+      this.params.clear && this.deleteGenFile(this.output);
+    }
+    if (!fs.existsSync(this.imagesDir)) {
+      fs.mkdirSync(this.imagesDir, { recursive: true });
+    }
+    icongen(this.input, this.output, this.iconOptions)
+      .then((results) => {
+        console.log("[ee-core] [tools/iconGen] iconGen 已生成下方图片资源");
+        console.log(results);
+        this._renameForEE(results);
+      })
+      .catch((err) => {
+        console.error(err);
+        throw new Error("[ee-core] [tools/iconGen] iconGen 生成失败!");
+      });
+  }
+
+  /**
+   * 删除生成的文件(.ico .png)
+   */  
+  deleteGenFile(dirPath) {
+    if (fs.existsSync(dirPath)) {
+      // 读取文件夹下的文件目录
+      const files = fs.readdirSync(dirPath);
+      files.forEach((file) => {
+        const curPath = path.join(dirPath, file);
+        // 判断是不是文件夹，如果是，继续递归
+        if (fs.lstatSync(curPath).isDirectory()) {
+          this.deleteGenFile(curPath);
+        } else {
+          // 删除文件
+          if ([".ico", ".png"].includes(path.extname(curPath))) {
+            fs.unlinkSync(curPath);
+          }
+        }
+      });
+    }
+  }
+
+  /**
+   * 为生成的资源重命名 (logo-32.png -> 32x32.png)
+   */    
+  _renameForEE(filesPath) {
+    console.log("[ee-core] [tools/iconGen] iconGen 开始重新命名logo图片资源");
+    try {
+      const len = filesPath.length;
+      for (let i = 0; i < len; i++) {
+        const filePath = filesPath[i];
+        const extname = path.extname(filePath);
+        if ([".png"].includes(extname)) {
+          const filename = path.basename(filePath, extname);
+          const basename = filename.split("-")[1];
+          const dirname = path.dirname(filePath);
+          // 处理 tray 图标 --> 复制到 public/images 目录下
+          if ("16" === basename) {
+            const newName = "tray" + extname;
+            fs.copyFileSync(filePath, path.join(this.imagesDir, newName));
+            console.log(`${filename}${extname} --> ${this.params.imagesDir}/${newName} 复制成功!`);
+            fs.unlinkSync(filePath);
+            continue;
+          }
+          // 处理 win 窗口图标 --> 复制到 public/images 目录下
+          if ("32" === basename) {
+            const newName = filename + extname;
+            fs.copyFileSync(filePath, path.join(this.imagesDir, newName));
+            console.log(`${filename}${extname} --> ${this.params.imagesDir}/${newName} 复制成功!`);
+          }
+          // 重命名 --> 32x32.png
+          const newName = basename + "x" + basename + extname;
+          const newPath = path.join(dirname, newName);
+          fs.renameSync(filePath, newPath);
+          console.log(`${filename}${extname} --> ${newName} 重命名成功!`);
+        }
+      }
+      console.log("[ee-core] [tools/iconGen] iconGen 资源处理完成!");
+    } catch (e) {
+      console.error("[ee-core] [tools/iconGen] ERROR: ", e);
+      throw new Error("重命名logo图片资源失败!!");
+    }
+  }
+}
+
+const run = () => {
+  const i = new IconGen();
+  i.generateIcons();
+}
+
+module.exports = {
+  run,
+};

package/tools/replaceDist.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const fsPro = require('fs-extra');
+const chalk = require('chalk');
+
+/**
+ * 资源替换
+ */
+
+ module.exports = {
+  
+  /**
+   * 执行
+   */  
+  run(options = {}) {
+    console.log('[ee-bin] [rd] Start moving resources');
+    const homeDir = process.cwd();
+
+    // argv
+    const distDir = options.distDir;
+    const sourceDir = path.join(homeDir, distDir);
+    const sourceIndexFile = path.join(sourceDir, 'index.html');
+    
+    if (!this._fileExist(sourceIndexFile)) {
+      console.info(sourceIndexFile);
+      const errorTips = chalk.bgRed('Error') + ' Frontend resource does not exist, please build !';
+      console.error(errorTips);
+      return
+    }
+    
+    // 清空历史资源 并 复制到ee资源目录
+    const eeResourceDir = path.join(homeDir, 'public', 'dist');
+    if (!fs.existsSync(eeResourceDir)) {
+      fs.mkdirSync(eeResourceDir, {recursive: true, mode: 0o777});
+    }
+    this._rmFolder(eeResourceDir);
+    console.log('[ee-bin] [rd] Clear history resources:', eeResourceDir);
+
+    fsPro.copySync(sourceDir, eeResourceDir);
+    console.log('[ee-bin] [rd] Copy a resource to:', eeResourceDir);
+    console.log('[ee-bin] [rd] End');
+  },
+
+  _fileExist(filePath) {
+    try {
+      return fs.statSync(filePath).isFile();
+    } catch (err) {
+      // const errorTips = chalk.bgRed('Error') + ' [ee-bin] [rd] ';
+      // console.error(errorTips, err);
+      return false;
+    }
+  },
+
+  /**
+   * 删除文件夹
+   */
+  _rmFolder(folder) {
+    const nodeVersion = (process.versions && process.versions.node) || null;
+    if (nodeVersion && this._compareVersion(nodeVersion, '14.14.0') == 1) {
+      fs.rmSync(folder, {recursive: true});
+    } else {
+      fs.rmdirSync(folder, {recursive: true});
+    }
+  },
+
+  /**
+   * 版本号比较
+   */
+  _compareVersion(v1, v2) {
+    v1 = v1.split('.')
+    v2 = v2.split('.')
+    const len = Math.max(v1.length, v2.length)
+
+    while (v1.length < len) {
+      v1.push('0')
+    }
+    while (v2.length < len) {
+      v2.push('0')
+    }
+    
+    for (let i = 0; i < len; i++) {
+      const num1 = parseInt(v1[i])
+      const num2 = parseInt(v2[i])
+
+      if (num1 > num2) {
+        return 1
+      } else if (num1 < num2) {
+        return -1
+      }
+    }
+
+    return 0
+  }
+}