ee-bin 2.0.0-beta.2 → 4.0.0-beta.1

package/config/bin_default.js

@@ -0,0 +1,112 @@
+/**
+ * ee-bin 配置
+ * 仅适用于开发环境
+ */
+module.exports = {
+  /**
+   * development serve ("frontend" "electron" )
+   * ee-bin dev
+   */
+  dev: {
+    frontend: {
+      directory: './frontend',
+      cmd: 'npm',
+      args: ['run', 'dev'],
+      protocol: 'http://',
+      hostname: 'localhost',
+      port: 8080,
+      indexPath: 'index.html',
+    },
+    electron: {
+      directory: './',
+      cmd: 'electron',
+      args: ['.', '--env=local'],
+      loadingPage: '/public/html/loading.html',
+    },
+  },
+
+  /**
+   * 构建
+   * ee-bin build
+   */
+  build: {
+    frontend: {
+      directory: './frontend',
+      cmd: 'npm',
+      args: ['run', 'build'],
+    },
+    electron: {
+      bundler: 'esbuild',
+      language: 'javascript',
+      javascript: {
+        entryPoints: ['./electron/**/*.js'],
+        platform: 'node',
+        bundle: false,
+        minify: false,
+        outdir: 'public/electron',
+        packages: 'external',
+        sourcemap:false,
+        sourcesContent: false
+      },
+      typescript: {
+        entryPoints: ['./electron/**/*.ts'],
+        tsconfig: './tsconfig.json',
+        platform: 'node',
+        format: 'cjs',
+        bundle: false,
+        minify: false,
+        outdir: 'public/electron',
+        packages: 'external',
+        sourcemap:false,
+        sourcesContent: false
+      }
+    }
+  },
+
+  /**
+   * 移动资源
+   * ee-bin move 
+   */
+  move: {
+    frontend_dist: {
+      src: './frontend/dist',
+      dest: './public/dist'
+    }
+  },  
+
+  /**
+   * 预发布模式（prod）
+   * ee-bin start
+   */
+  start: {
+    directory: './',
+    cmd: 'electron',
+    args: ['.', '--env=prod']
+  },
+
+  /**
+   * 加密
+   */  
+  encrypt: {
+    type: 'none',
+    files: [
+      './public/electron/**/*.(js|json)',
+    ],
+    fileExt: ['.js'],
+    cleanFiles: ['./public/electron'],
+    specificFiles: ['./public/electron/preload/bridge.js'],
+    encryptDir: './',
+    confusionOptions: {
+      compact: true,      
+      stringArray: true,
+      stringArrayEncoding: ['none'],
+      deadCodeInjection: false,
+    }
+  },
+
+  /**
+   * 执行自定义命令
+   * ee-bin exec
+   */
+  exec: {},  
+};

package/index.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { move } = require('./tools/move');
+const { encrypt, cleanEncrypt } = require('./tools/encrypt');
+const { serveProcess } = require('./tools/serve');
+const { incrUpdater } = require('./tools/incrUpdater');
+
+/**
+ * dev
+ */
+program
+  .command('dev')
+  .description('create frontend-serve and electron-serve')
+  .option('--config <folder>', 'config file')
+  .option('--serve <mode>', 'serve mode')
+  .action(function() {
+    serveProcess.dev(this.opts());
+  });
+
+/**
+ * build
+ */
+program
+  .command('build')
+  .description('building multiple resources')
+  .option('--config <folder>', 'config file')
+  .option('--cmds <flag>', 'custom commands')
+  .action(function() {
+    serveProcess.build(this.opts());
+  });
+
+/**
+ * start
+ */
+program
+  .command('start')
+  .description('preview effect')
+  .option('--config <folder>', 'config file')
+  .action(function() {
+    serveProcess.start(this.opts());
+  });
+
+/**
+ * exec
+ */
+program
+  .command('exec')
+  .description('create frontend-serve and electron-serve')
+  .option('--config <folder>', 'config file')
+  .option('--cmds <flag>', 'custom commands')
+  .action(function() {
+    serveProcess.exec(this.opts());
+  });
+
+/**
+ * move - Moves resources
+ */
+program
+  .command('move')
+  .description('Move multip resources')
+  .option('--config <folder>', 'config file')
+  .option('--flag <flag>', 'Custom flag')
+  .action(function() {
+    move(this.opts());
+  });
+
+/**
+ * encrypt - Code encryption
+ */
+program
+  .command('encrypt')
+  .description('Code encryption')
+  .option('--config <folder>', 'config file')
+  .option('--out <folder>', 'output directory')
+  .action(function() {
+    encrypt(this.opts());
+  });
+
+/**
+ * clean - Clear the encrypted code
+ */
+program
+  .command('clean')
+  .description('Clear the encrypted code')
+  .option('-d, --dir <folder>', 'clean directory')
+  .action(function() {
+    cleanEncrypt(this.opts());
+  });
+
+/**
+ * icon
+ */
+program
+  .command('icon')
+  .description('Generate logo')
+  .option('-i, --input <file>', 'image file default /public/images/logo.png')
+  .option('-o, --output <folder>', 'output directory default /build/icons/')
+  .action(function() {
+    const iconGen = require('./tools/iconGen');
+    iconGen.run();
+  });
+
+/**
+ * updater
+ */
+program
+  .command('updater')
+  .description('updater commands')
+  .option('--config <folder>', 'config file')
+  .option('--asar-file <file>', 'asar file path')
+  .option('--platform <flag>', 'platform')
+  .action(function() {
+    incrUpdater.run(this.opts());
+  });
+
+program.parse();

package/lib/extend.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const hasOwn = Object.prototype.hasOwnProperty;
+const toStr = Object.prototype.toString;
+
+function isPlainObject(obj) {
+  if (!obj || toStr.call(obj) !== '[object Object]') {
+    return false;
+  }
+
+  var hasOwnConstructor = hasOwn.call(obj, 'constructor');
+  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+  // Not own constructor property must be Object
+  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+    return false;
+  }
+
+  // Own properties are enumerated firstly, so to speed up,
+  // if last one is own, then all properties are own.
+  var key;
+  for (key in obj) { /**/ }
+
+  return typeof key === 'undefined' || hasOwn.call(obj, key);
+};
+
+function extend() {
+  var options, name, src, copy, clone;
+  var target = arguments[0];
+  var i = 1;
+  var length = arguments.length;
+  var deep = false;
+
+  // Handle a deep copy situation
+  if (typeof target === 'boolean') {
+    deep = target;
+    target = arguments[1] || {};
+    // skip the boolean and the target
+    i = 2;
+  } else if ((typeof target !== 'object' && typeof target !== 'function') || target == null) {
+    target = {};
+  }
+
+  for (; i < length; ++i) {
+    options = arguments[i];
+    // Only deal with non-null/undefined values
+    if (options == null) continue;
+
+    // Extend the base object
+    for (name in options) {
+      if (name === '__proto__') continue;
+
+      src = target[name];
+      copy = options[name];
+
+      // Prevent never-ending loop
+      if (target === copy) continue;
+
+      // Recurse if we're merging plain objects
+      if (deep && copy && isPlainObject(copy)) {
+        clone = src && isPlainObject(src) ? src : {};
+        // Never move original objects, clone them
+        target[name] = extend(deep, clone, copy);
+
+      // Don't bring in undefined values
+      } else if (typeof copy !== 'undefined') {
+        target[name] = copy;
+      }
+    }
+  }
+
+  // Return the modified object
+  return target;
+};
+
+module.exports = {
+  extend,
+  isPlainObject,
+};

package/lib/{utils.cjs → utils.js}

@@ -1,5 +1,6 @@
 'use strict';
 
+const debug = require('debug')('ee-bin:lib:utils');
 const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
@@ -7,22 +8,26 @@ const is = require('is-type-of');
 const { loadTsConfig } = require('config-file-ts');
 const JsonLib = require('json5');
 const mkdirp = require('mkdirp');
+const OS = require('os');
+const defaultConfig = require('../config/bin_default');
+const { extend } = require('./extend');
 
 const _basePath = process.cwd();
+const userBin = './cmd/bin.js';
 
-function checkConfig(prop) {
-  const filepath = path.join(_basePath, prop);
-  if (fs.existsSync(filepath)) {
-    return true;
-  }
+function loadConfig(binFile) {
+  const binPath = binFile ? binFile : userBin;
+  const userConfig = loadFile(binPath);
+  const result = extend(true, defaultConfig, userConfig);
+  debug('[loadConfig] bin:%j', result)
 
-  return false;
-}
+  return result
+};
 
-function loadConfig(prop) {
-  const configFile = path.join(_basePath, prop);
+function loadFile(filepath) {
+  const configFile = path.join(_basePath, filepath);
   if (!fs.existsSync(configFile)) {
-    const errorTips = 'config file ' + chalk.blue(`${configFile}`) + ' does not exist !';
+    const errorTips = 'file ' + chalk.blue(`${configFile}`) + ' does not exist !';
     throw new Error(errorTips)
   }
 
@@ -45,24 +50,6 @@ function loadConfig(prop) {
   return result || {}
 };
 
-function loadEncryptConfig() {
-  const configFile = './electron/config/encrypt.js';
-  const filepath = path.join(_basePath, configFile);
-  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 || {};
-};
-
 /**
  * get electron program
  */
@@ -108,10 +95,30 @@ function compareVersion(v1, v2) {
   return 0
 }
 
-function isWindows(prop) {
+function isWindows() {
   return process.platform === 'win32'
 }
 
+function isOSX() {
+  return process.platform === 'darwin'
+}
+
+function isMacOS() {
+  return isOSX()
+}
+
+function isLinux() {
+  return process.platform === 'linux'
+}
+
+function isx86() {
+  return process.arch === 'ia32'
+}
+
+function isx64() {
+  return process.arch === 'x64'
+}
+
 /**
  * Delete a file or folder
  */
@@ -133,9 +140,7 @@ function rm(name) {
  * 获取项目根目录package.json
  */
 function getPackage () {
-  const homeDir = process.cwd();
-  const content = readJsonSync(path.join(homeDir, 'package.json'));
-  
+  const content = readJsonSync(path.join(_basePath, 'package.json'));
   return content;
 }
 
@@ -160,13 +165,43 @@ function writeJsonSync (filepath, str, options) {
   fs.writeFileSync(filepath, str);
 };
 
+function getPlatform(delimiter = "_", isDiffArch = false) {
+  let os = "";
+  if (isWindows()) {
+    os = "windows";
+    if (isDiffArch) {
+      const arch = isx64() ? "64" : "32";
+      os += delimiter + arch;
+    }
+  } else if (isMacOS()) {
+    let isAppleSilicon = false;
+    const cpus = OS.cpus();
+    for (let cpu of cpus) {
+      if (cpu.model.includes('Apple')) {
+        isAppleSilicon = true;
+        break;
+      }
+    }
+    const core = isAppleSilicon? "apple" : "intel";
+    os = "macos" + delimiter + core;
+  } else if (isLinux()) {
+    os = "linux";
+  }
+
+  return os;
+}
+
 module.exports = {
   loadConfig,
-  checkConfig,
-  loadEncryptConfig,
   getElectronProgram,
   compareVersion,
   isWindows,
+  isOSX,
+  isMacOS,
+  isLinux,
+  isx86,
+  isx64,
+  getPlatform,
   rm,
   getPackage,
   readJsonSync,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ee-bin",
-  "version": "2.0.0-beta.2",
+  "version": "4.0.0-beta.1",
   "description": "ee bin",
   "main": "index.js",
   "scripts": {
@@ -9,20 +9,22 @@
   "author": "",
   "license": "ISC",
   "bin": {
-    "ee-bin": "index.cjs"
+    "ee-bin": "index.js"
   },
   "dependencies": {
+    "adm-zip": "^0.4.11",
     "bytenode": "^1.3.6",
     "chalk": "^4.1.2",
     "commander": "^11.0.0",
     "config-file-ts": "^0.2.8-rc1",
     "cross-spawn": "^7.0.3",
+    "debug": "^4.4.0",
+    "esbuild": "0.24.2",
     "fs-extra": "^10.0.0",
     "globby": "^10.0.0",
     "is-type-of": "^1.2.1",
     "javascript-obfuscator": "^4.0.2",
-    "mkdirp": "^2.1.3",
-    "adm-zip": "^0.4.11",
-    "json5": "^2.2.3"
+    "json5": "^2.2.3",
+    "mkdirp": "^2.1.3"
   }
 }

package/tools/encrypt.js

@@ -0,0 +1,197 @@
+'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 JavaScriptObfuscator = require('javascript-obfuscator');
+const globby = require('globby');
+const chalk = require('chalk');
+const { loadConfig } = require('../lib/utils');
+
+const EncryptTypes = ['bytecode', 'confusion', 'strict'];
+
+class Encrypt {
+  constructor(options = {}) {
+    // cli args
+    const { config, out } = options;
+    this.basePath = process.cwd();
+    
+    const cfg = loadConfig(config);
+    this.config = cfg.encrypt;
+    const outputFolder = out || this.config.encryptDir;
+    this.encryptDir = path.join(this.basePath, outputFolder);
+    this.filesExt = this.config.fileExt;
+    this.type = this.config.type;
+    this.bOpt = this.config.bytecodeOptions;
+    this.cOpt = this.config.confusionOptions;
+    this.cleanFiles = this.config.cleanFiles;
+    this.patterns = this.config.files || null;
+    this.specFiles = this.config.specificFiles;
+
+    this.codefiles = this._initCodeFiles();
+  }
+
+  /**
+   * 初始化需要加密的文件列表
+   */
+  _initCodeFiles() {
+    if (!this.patterns) return;
+
+    const files = globby.sync(this.patterns, { cwd: this.basePath });
+    return files;
+  }
+
+  /**
+   * 备份代码
+   */
+  backup() {
+    // clean
+    this.cleanCode();
+
+    console.log(chalk.blue('[ee-bin] [encrypt] ') + 'backup start');
+    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);
+      }
+    })
+
+    console.log(chalk.blue('[ee-bin] [encrypt] ') + 'backup end');
+    return true;
+  }
+  
+  /**
+   * 清除加密代码
+   */
+  cleanCode() {
+    this.cleanFiles.forEach((file) => {
+      let tmpFile = path.join(this.basePath, file);
+      fsPro.removeSync(tmpFile);
+      console.log(chalk.blue('[ee-bin] [encrypt] ') + 'clean up tmp files:' + chalk.magenta(`${tmpFile}`));
+    })
+  }
+
+  /**
+   * 加密代码
+   */
+  encrypt() {
+    console.log(chalk.blue('[ee-bin] [encrypt] ') + 'start ciphering');
+    console.log(this.codefiles);
+    for (const file of this.codefiles) {
+      const fullpath = path.join(this.encryptCodeDir, file);
+      if (!fs.statSync(fullpath).isFile()) continue;
+
+      // 特殊文件处理
+      if (this.specFiles.includes(file)) {
+        this.generate(fullpath, 'confusion');
+        continue;
+      }
+
+      this.generate(fullpath);
+    } 
+    console.log(chalk.blue('[ee-bin] [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 = chalk.blue('[ee-bin] [encrypt] ') + 'file: ' + chalk.green(`${curPath}`) + ' ' + chalk.cyan(`(${encryptType})`);
+    console.log(tips);
+    if (encryptType == 'strict') {
+      this.generateJSConfuseFile(curPath);
+      this.generateBytecodeFile(curPath);
+    } else if (encryptType == 'bytecode') {
+      this.generateBytecodeFile(curPath);
+    } else if (encryptType == 'confusion') {
+      this.generateJSConfuseFile(curPath);
+    } else {
+      // none
+    }
+  }
+
+  /**
+   * 使用 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);
+	  fsPro.removeSync(curPath);
+  }
+}
+
+function encrypt(options = {}) {
+  const enc = new Encrypt(options);
+  if (EncryptTypes.indexOf(enc.type) == -1) return;
+  //if (!enc.backup()) return;
+  enc.encrypt();
+}
+
+function cleanEncrypt(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(chalk.blue('[ee-bin] [encrypt] ') + 'clean up tmp files: ' + chalk.magenta(`${tmpFile}`));
+    }
+  })
+}
+
+module.exports = {
+  encrypt,
+  cleanEncrypt,
+};