react-native-update-cli 1.27.0

README.md

@@ -0,0 +1 @@
+# react-native-update-cli

cli.json

@@ -0,0 +1,217 @@
+{
+  "useCommand": true,
+  "defaultCommand": "help",
+  "commands": {
+    "help": {},
+
+    "login": {},
+    "logout": {},
+    "me": {},
+
+    "createApp": {
+      "options": {
+        "name": {
+          "hasValue": true
+        },
+        "platform": {
+          "hasValue": true
+        }
+      }
+    },
+    "apps": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        }
+      }
+    },
+    "deleteApp": {},
+    "selectApp": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        }
+      }
+    },
+
+    "uploadIpa": {},
+    "uploadApk": {},
+    "parseIpa": {},
+    "parseApk": {},
+    "packages": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        }
+      }
+    },
+
+    "publish": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        },
+        "name": {
+          "hasValue": true
+        },
+        "description": {
+          "hasValue": true
+        },
+        "metaInfo": {
+          "hasValue": true
+        }
+      }
+    },
+    "versions": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        }
+      }
+    },
+
+    "update": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        },
+        "versionId": {
+          "hasValue": true
+        },
+        "packageId": {
+          "hasValue": true
+        },
+
+        "packageVersion": {
+          "hasValue": true
+        },
+        "minPackageVersion": {
+          "hasValue": true
+        },
+        "maxPackageVersion": {
+          "hasValue": true
+        }
+      }
+    },
+
+    "updateVersionInfo": {
+      "options": {
+        "platform": {
+          "hasValue": true
+        },
+        "versionId": {
+          "hasValue": true
+        },
+        "name": {
+          "default": false,
+          "hasValue": true
+        },
+        "description": {
+          "default": false,
+          "hasValue": true
+        },
+        "metaInfo": {
+          "default": false,
+          "hasValue": true
+        }
+      }
+    },
+
+    "build": {
+      "description": "Bundle javascript and copy assets."
+    },
+    "bundle": {
+      "description": "Bundle javascript code only.",
+      "options": {
+        "dev": {
+          "default": "false",
+          "hasValue": true
+        },
+        "platform": {
+          "hasValue": true
+        },
+        "bundleName": {
+          "default": "index.bundlejs",
+          "hasValue": true
+        },
+        "entryFile": {
+          "default": "index.js",
+          "hasValue": true
+        },
+        "intermediaDir": {
+          "default": ".pushy/intermedia/${platform}",
+          "hasValue": true
+        },
+        "output": {
+          "default": ".pushy/output/${platform}.${time}.ppk",
+          "hasValue": true
+        },
+        "sourcemap": {
+          "default": false
+        }
+      }
+    },
+    "release": {
+      "description": "Push builded file to server."
+    },
+    "diff": {
+      "description": "Create diff patch",
+      "options": {
+        "output": {
+          "default": ".pushy/output/diff",
+          "hasValue": true
+        }
+      }
+    },
+    "diffFromApk": {
+      "description": "Create diff patch from a Android package(.apk)",
+      "options": {
+        "output": {
+          "default": ".pushy/output/diff-${time}.apk-patch",
+          "hasValue": true
+        }
+      }
+    },
+    "diffFromIpa": {
+      "description": "Create diff patch from a iOS package(.ipa)",
+      "options": {
+        "output": {
+          "default": ".pushy/output/diff-${time}.ipa-patch",
+          "hasValue": true
+        }
+      }
+    },
+    "hdiff": {
+      "description": "Create hdiff patch",
+      "options": {
+        "output": {
+          "default": ".pushy/output/hdiff",
+          "hasValue": true
+        }
+      }
+    },
+    "hdiffFromApk": {
+      "description": "Create hdiff patch from a Android package(.apk)",
+      "options": {
+        "output": {
+          "default": ".pushy/output/hdiff-${time}.apk-patch",
+          "hasValue": true
+        }
+      }
+    },
+    "hdiffFromIpa": {
+      "description": "Create hdiff patch from a iOS package(.ipa)",
+      "options": {
+        "output": {
+          "default": ".pushy/output/hdiff-${time}.ipa-patch",
+          "hasValue": true
+        }
+      }
+    }
+  },
+  "globalOptions": {
+    "no-interactive": {
+      "default": false
+    }
+  }
+}

index.js

@@ -0,0 +1,4 @@
+/**
+ * Created by tdzl2003 on 2/22/16.
+ */
+module.exports = require('./lib');

lib/api.js

@@ -0,0 +1,204 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.doDelete = exports.put = exports.post = exports.get = exports.closeSession = exports.saveSession = exports.loadSession = exports.replaceSession = exports.getSession = undefined;
+exports.uploadFile = uploadFile;
+
+var _nodeFetch = require('node-fetch');
+
+var _nodeFetch2 = _interopRequireDefault(_nodeFetch);
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _request = require('request');
+
+var _request2 = _interopRequireDefault(_request);
+
+var _progress = require('progress');
+
+var _progress2 = _interopRequireDefault(_progress);
+
+var _package = require('../package.json');
+
+var _package2 = _interopRequireDefault(_package);
+
+var _tcpPing = require('tcp-ping');
+
+var _tcpPing2 = _interopRequireDefault(_tcpPing);
+
+var _util = require('util');
+
+var _util2 = _interopRequireDefault(_util);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _filesizeParser = require('filesize-parser');
+
+var _filesizeParser2 = _interopRequireDefault(_filesizeParser);
+
+var _utils = require('./utils');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const defaultEndpoint = 'https://update.reactnative.cn/api';
+let host = process.env.PUSHY_REGISTRY || defaultEndpoint;
+
+
+const tcpPing = _util2.default.promisify(_tcpPing2.default.ping);
+
+let session = undefined;
+let savedSession = undefined;
+
+const userAgent = `react-native-update-cli/${_package2.default.version}`;
+
+const getSession = exports.getSession = function () {
+  return session;
+};
+
+const replaceSession = exports.replaceSession = function (newSession) {
+  session = newSession;
+};
+
+const loadSession = exports.loadSession = async function () {
+  if (_fs2.default.existsSync('.update')) {
+    try {
+      replaceSession(JSON.parse(_fs2.default.readFileSync('.update', 'utf8')));
+      savedSession = session;
+    } catch (e) {
+      console.error('Failed to parse file `.update`. Try to remove it manually.');
+      throw e;
+    }
+  }
+};
+
+const saveSession = exports.saveSession = function () {
+  // Only save on change.
+  if (session !== savedSession) {
+    const current = session;
+    const data = JSON.stringify(current, null, 4);
+    _fs2.default.writeFileSync('.update', data, 'utf8');
+    savedSession = current;
+  }
+};
+
+const closeSession = exports.closeSession = function () {
+  if (_fs2.default.existsSync('.update')) {
+    _fs2.default.unlinkSync('.update');
+    savedSession = undefined;
+  }
+  session = undefined;
+  host = process.env.PUSHY_REGISTRY || defaultEndpoint;
+};
+
+async function query(url, options) {
+  const resp = await (0, _nodeFetch2.default)(url, options);
+  const text = await resp.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Server error: ${text}`);
+  }
+
+  if (resp.status !== 200) {
+    throw Object.assign(new Error(json.message || json.error), {
+      status: resp.status
+    });
+  }
+  return json;
+}
+
+function queryWithoutBody(method) {
+  return function (api) {
+    return query(host + api, {
+      method,
+      headers: {
+        'User-Agent': userAgent,
+        'X-AccessToken': session ? session.token : ''
+      }
+    });
+  };
+}
+
+function queryWithBody(method) {
+  return function (api, body) {
+    return query(host + api, {
+      method,
+      headers: {
+        'User-Agent': userAgent,
+        'Content-Type': 'application/json',
+        'X-AccessToken': session ? session.token : ''
+      },
+      body: JSON.stringify(body)
+    });
+  };
+}
+
+const get = exports.get = queryWithoutBody('GET');
+const post = exports.post = queryWithBody('POST');
+const put = exports.put = queryWithBody('PUT');
+const doDelete = exports.doDelete = queryWithBody('DELETE');
+
+async function uploadFile(fn, key) {
+  const { url, backupUrl, formData, maxSize } = await post('/upload', {
+    ext: _path2.default.extname(fn)
+  });
+  let realUrl = url;
+
+  if (backupUrl) {
+    if (global.USE_ACC_OSS) {
+      realUrl = backupUrl;
+    } else {
+      const pingResult = await tcpPing({
+        address: url.replace('https://', ''),
+        attempts: 4,
+        timeout: 1000
+      });
+      // console.log({pingResult});
+      if (isNaN(pingResult.avg) || pingResult.avg > 150) {
+        realUrl = backupUrl;
+      }
+    }
+    // console.log({realUrl});
+  }
+
+  const fileSize = _fs2.default.statSync(fn).size;
+  if (maxSize && fileSize > (0, _filesizeParser2.default)(maxSize)) {
+    throw new Error(`此文件大小${(fileSize / 1048576).toFixed(1)}m, 超出当前额度${maxSize}。您可以考虑升级付费业务以提升此额度。详情请访问: ${_utils.pricingPageUrl}`);
+  }
+
+  const bar = new _progress2.default('  上传中 [:bar] :percent :etas', {
+    complete: '=',
+    incomplete: ' ',
+    total: fileSize
+  });
+
+  const info = await new Promise((resolve, reject) => {
+    if (key) {
+      formData.key = key;
+    }
+    formData.file = _fs2.default.createReadStream(fn);
+
+    formData.file.on('data', function (data) {
+      bar.tick(data.length);
+    });
+    _request2.default.post(realUrl, {
+      formData
+    }, (err, resp, body) => {
+      if (err) {
+        return reject(err);
+      }
+      if (resp.statusCode > 299) {
+        return reject(Object.assign(new Error(body), { status: resp.statusCode }));
+      }
+      resolve({ hash: formData.key });
+    });
+  });
+  return info;
+}

lib/app.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commands = undefined;
+exports.checkPlatform = checkPlatform;
+exports.getSelectedApp = getSelectedApp;
+exports.listApp = listApp;
+exports.chooseApp = chooseApp;
+
+var _utils = require('./utils');
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _ttyTable = require('tty-table');
+
+var _ttyTable2 = _interopRequireDefault(_ttyTable);
+
+var _api = require('./api');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const validPlatforms = {
+  ios: 1,
+  android: 1
+};
+
+function checkPlatform(platform) {
+  if (!validPlatforms[platform]) {
+    throw new Error(`无法识别的平台 '${platform}'`);
+  }
+  return platform;
+}
+
+function getSelectedApp(platform) {
+  checkPlatform(platform);
+
+  if (!_fs2.default.existsSync('update.json')) {
+    throw new Error(`App not selected. run 'pushy selectApp --platform ${platform}' first!`);
+  }
+  const updateInfo = JSON.parse(_fs2.default.readFileSync('update.json', 'utf8'));
+  if (!updateInfo[platform]) {
+    throw new Error(`App not selected. run 'pushy selectApp --platform ${platform}' first!`);
+  }
+  return updateInfo[platform];
+}
+
+async function listApp(platform) {
+  const { data } = await (0, _api.get)('/app/list');
+  const list = platform ? data.filter(v => v.platform === platform) : data;
+
+  const header = [{ value: '应用 id' }, { value: '应用名称' }, { value: '平台' }];
+  const rows = [];
+  for (const app of list) {
+    rows.push([app.id, app.name, app.platform]);
+  }
+
+  console.log((0, _ttyTable2.default)(header, rows).render());
+
+  if (platform) {
+    console.log(`\共 ${list.length} ${platform} 个应用`);
+  } else {
+    console.log(`\共 ${list.length} 个应用`);
+  }
+  return list;
+}
+
+async function chooseApp(platform) {
+  const list = await listApp(platform);
+
+  while (true) {
+    const id = await (0, _utils.question)('输入应用 id:');
+    const app = list.find(v => v.id === (id | 0));
+    if (app) {
+      return app;
+    }
+  }
+}
+
+const commands = exports.commands = {
+  createApp: async function ({ options }) {
+    const name = options.name || (await (0, _utils.question)('应用名称:'));
+    const { downloadUrl } = options;
+    const platform = checkPlatform(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { id } = await (0, _api.post)('/app/create', { name, platform });
+    console.log(`已成功创建应用（id: ${id}）`);
+    await this.selectApp({
+      args: [id],
+      options: { platform, downloadUrl }
+    });
+  },
+  deleteApp: async function ({ args, options }) {
+    const { platform } = options;
+    const id = args[0] || chooseApp(platform);
+    if (!id) {
+      console.log('已取消');
+    }
+    await (0, _api.doDelete)(`/app/${id}`);
+    console.log('操作成功');
+  },
+  apps: async function ({ options }) {
+    const { platform } = options;
+    listApp(platform);
+  },
+  selectApp: async function ({ args, options }) {
+    const platform = checkPlatform(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const id = args[0] ? parseInt(args[0]) : (await chooseApp(platform)).id;
+
+    let updateInfo = {};
+    if (_fs2.default.existsSync('update.json')) {
+      try {
+        updateInfo = JSON.parse(_fs2.default.readFileSync('update.json', 'utf8'));
+      } catch (e) {
+        console.error('Failed to parse file `update.json`. Try to remove it manually.');
+        throw e;
+      }
+    }
+    const { appKey } = await (0, _api.get)(`/app/${id}`);
+    updateInfo[platform] = {
+      appId: id,
+      appKey
+    };
+    _fs2.default.writeFileSync('update.json', JSON.stringify(updateInfo, null, 4), 'utf8');
+  }
+};

lib/bundle.js

@@ -0,0 +1,597 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commands = undefined;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _utils = require('./utils');
+
+var _fsExtra = require('fs-extra');
+
+var fs = _interopRequireWildcard(_fsExtra);
+
+var _yazl = require('yazl');
+
+var _yauzl = require('yauzl');
+
+var _app = require('./app');
+
+var _child_process = require('child_process');
+
+var _os = require('os');
+
+var _os2 = _interopRequireDefault(_os);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const g2js = require('gradle-to-js/lib/parser');
+
+const properties = require('properties');
+
+let bsdiff, hdiff, diff;
+try {
+  bsdiff = require('node-bsdiff').diff;
+} catch (e) {}
+
+try {
+  hdiff = require('node-hdiffpatch').diff;
+} catch (e) {}
+
+async function runReactNativeBundleCommand(bundleName, development, entryFile, outputFolder, platform, sourcemapOutput, config) {
+  let gradleConfig = {};
+  if (platform === 'android') {
+    gradleConfig = await checkGradleConfig();
+    if (gradleConfig.crunchPngs !== false) {
+      console.warn('android的crunchPngs选项似乎尚未禁用（如已禁用则请忽略此提示），这可能导致热更包体积异常增大，具体请参考 https://pushy.reactnative.cn/docs/getting-started.html#%E7%A6%81%E7%94%A8-android-%E7%9A%84-crunch-%E4%BC%98%E5%8C%96 \n');
+    }
+  }
+
+  let reactNativeBundleArgs = [];
+
+  let envArgs = process.env.PUSHY_ENV_ARGS;
+
+  if (envArgs) {
+    Array.prototype.push.apply(reactNativeBundleArgs, envArgs.trim().split(/\s+/));
+  }
+
+  fs.emptyDirSync(outputFolder);
+
+  let cliPath = require.resolve('react-native/local-cli/cli.js', {
+    paths: [process.cwd()]
+  });
+  try {
+    require.resolve('expo-router', {
+      paths: [process.cwd()]
+    });
+
+    console.log(`expo-router detected, will use @expo/cli to bundle.\n`);
+    // if using expo-router, use expo-cli
+    cliPath = require.resolve('@expo/cli', {
+      paths: [process.cwd()]
+    });
+  } catch (e) {}
+  const bundleCommand = cliPath.includes('@expo/cli') ? 'export:embed' : 'bundle';
+
+  Array.prototype.push.apply(reactNativeBundleArgs, [cliPath, bundleCommand, '--assets-dest', outputFolder, '--bundle-output', _path2.default.join(outputFolder, bundleName), '--dev', development, '--entry-file', entryFile, '--platform', platform, '--reset-cache']);
+
+  if (sourcemapOutput) {
+    reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
+  }
+
+  if (config) {
+    reactNativeBundleArgs.push('--config', config);
+  }
+
+  const reactNativeBundleProcess = (0, _child_process.spawn)('node', reactNativeBundleArgs);
+  console.log(`Running bundle command: node ${reactNativeBundleArgs.join(' ')}`);
+
+  return new Promise((resolve, reject) => {
+    reactNativeBundleProcess.stdout.on('data', data => {
+      console.log(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.stderr.on('data', data => {
+      console.error(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.on('close', async exitCode => {
+      if (exitCode) {
+        reject(new Error(`"react-native bundle" command exited with code ${exitCode}.`));
+      } else {
+        let hermesEnabled = false;
+
+        if (platform === 'android') {
+          const gradlePropeties = await new Promise(resolve => {
+            properties.parse('./android/gradle.properties', { path: true }, function (error, props) {
+              if (error) {
+                console.error(error);
+                resolve(null);
+              }
+
+              resolve(props);
+            });
+          });
+          hermesEnabled = gradlePropeties.hermesEnabled;
+
+          if (typeof hermesEnabled !== 'boolean') hermesEnabled = gradleConfig.enableHermes;
+        } else if (platform === 'ios' && fs.existsSync('ios/Pods/hermes-engine')) {
+          hermesEnabled = true;
+        }
+        if (hermesEnabled) {
+          await compileHermesByteCode(bundleName, outputFolder, sourcemapOutput);
+        }
+        resolve(null);
+      }
+    });
+  });
+}
+
+function getHermesOSBin() {
+  if (_os2.default.platform() === 'win32') return 'win64-bin';
+  if (_os2.default.platform() === 'darwin') return 'osx-bin';
+  if (_os2.default.platform() === 'linux') return 'linux64-bin';
+}
+
+async function checkGradleConfig() {
+  let enableHermes = false;
+  let crunchPngs;
+  try {
+    const gradleConfig = await g2js.parseFile('android/app/build.gradle');
+    const projectConfig = gradleConfig['project.ext.react'];
+    for (const packagerConfig of projectConfig) {
+      if (packagerConfig.includes('enableHermes') && packagerConfig.includes('true')) {
+        enableHermes = true;
+        break;
+      }
+    }
+    crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
+  } catch (e) {}
+  return {
+    enableHermes,
+    crunchPngs
+  };
+}
+
+async function compileHermesByteCode(bundleName, outputFolder, sourcemapOutput) {
+  console.log(`Hermes enabled, now compiling to hermes bytecode:\n`);
+  // >= rn 0.69
+  const rnDir = _path2.default.dirname(require.resolve('react-native', {
+    paths: [process.cwd()]
+  }));
+  let hermesPath = _path2.default.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
+
+  // < rn 0.69
+  if (!fs.existsSync(hermesPath)) {
+    hermesPath = `node_modules/hermes-engine/${getHermesOSBin()}`;
+  }
+
+  const hermesCommand = `${hermesPath}/hermesc`;
+
+  const args = ['-emit-binary', '-out', _path2.default.join(outputFolder, bundleName), _path2.default.join(outputFolder, bundleName), '-O'];
+  if (sourcemapOutput) {
+    args.push('-output-source-map');
+  }
+  console.log('Running hermesc: ' + hermesCommand + ' ' + args.join(' ') + '\n');
+  (0, _child_process.spawnSync)(hermesCommand, args, {
+    stdio: 'ignore'
+  });
+}
+
+async function pack(dir, output) {
+  console.log('Packing');
+  fs.ensureDirSync(_path2.default.dirname(output));
+  await new Promise((resolve, reject) => {
+    const zipfile = new _yazl.ZipFile();
+
+    function addDirectory(root, rel) {
+      if (rel) {
+        zipfile.addEmptyDirectory(rel);
+      }
+      const childs = fs.readdirSync(root);
+      for (const name of childs) {
+        if (name === '.' || name === '..' || name === 'index.bundlejs.map') {
+          continue;
+        }
+        const fullPath = _path2.default.join(root, name);
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          //console.log('adding: ' + rel+name);
+          zipfile.addFile(fullPath, rel + name);
+        } else if (stat.isDirectory()) {
+          //console.log('adding: ' + rel+name+'/');
+          addDirectory(fullPath, rel + name + '/');
+        }
+      }
+    }
+
+    addDirectory(dir, '');
+
+    zipfile.outputStream.on('error', err => reject(err));
+    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', function () {
+      resolve();
+    });
+    zipfile.end();
+  });
+  console.log('ppk热更包已生成并保存到: ' + output);
+}
+
+function readEntire(entry, zipFile) {
+  const buffers = [];
+  return new Promise((resolve, reject) => {
+    zipFile.openReadStream(entry, (err, stream) => {
+      stream.pipe({
+        write(chunk) {
+          buffers.push(chunk);
+        },
+        end() {
+          resolve(Buffer.concat(buffers));
+        },
+        prependListener() {},
+        on() {},
+        once() {},
+        emit() {}
+      });
+    });
+  });
+}
+
+function basename(fn) {
+  const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
+  return m && m[1];
+}
+
+async function diffFromPPK(origin, next, output) {
+  fs.ensureDirSync(_path2.default.dirname(output));
+
+  const originEntries = {};
+  const originMap = {};
+
+  let originSource;
+
+  await enumZipEntries(origin, (entry, zipFile) => {
+    originEntries[entry.fileName] = entry;
+    if (!/\/$/.test(entry.fileName)) {
+      // isFile
+      originMap[entry.crc32] = entry.fileName;
+
+      if (entry.fileName === 'index.bundlejs') {
+        // This is source.
+        return readEntire(entry, zipFile).then(v => originSource = v);
+      }
+    }
+  });
+
+  if (!originSource) {
+    throw new Error(`Bundle file not found! Please use default bundle file name and path.`);
+  }
+
+  const copies = {};
+
+  const zipfile = new _yazl.ZipFile();
+
+  const writePromise = new Promise((resolve, reject) => {
+    zipfile.outputStream.on('error', err => {
+      throw err;
+    });
+    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', function () {
+      resolve();
+    });
+  });
+
+  const addedEntry = {};
+
+  function addEntry(fn) {
+    //console.log(fn);
+    if (!fn || addedEntry[fn]) {
+      return;
+    }
+    const base = basename(fn);
+    if (base) {
+      addEntry(base);
+    }
+    zipfile.addEmptyDirectory(fn);
+  }
+
+  const newEntries = {};
+
+  await enumZipEntries(next, (entry, nextZipfile) => {
+    newEntries[entry.fileName] = entry;
+
+    if (/\/$/.test(entry.fileName)) {
+      // Directory
+      if (!originEntries[entry.fileName]) {
+        addEntry(entry.fileName);
+      }
+    } else if (entry.fileName === 'index.bundlejs') {
+      //console.log('Found bundle');
+      return readEntire(entry, nextZipfile).then(newSource => {
+        //console.log('Begin diff');
+        zipfile.addBuffer(diff(originSource, newSource), 'index.bundlejs.patch');
+        //console.log('End diff');
+      });
+    } else {
+      // If same file.
+      const originEntry = originEntries[entry.fileName];
+      if (originEntry && originEntry.crc32 === entry.crc32) {
+        // ignore
+        return;
+      }
+
+      // If moved from other place
+      if (originMap[entry.crc32]) {
+        const base = basename(entry.fileName);
+        if (!originEntries[base]) {
+          addEntry(base);
+        }
+        copies[entry.fileName] = originMap[entry.crc32];
+        return;
+      }
+
+      // New file.
+      addEntry(basename(entry.fileName));
+
+      return new Promise((resolve, reject) => {
+        nextZipfile.openReadStream(entry, function (err, readStream) {
+          if (err) {
+            return reject(err);
+          }
+          zipfile.addReadStream(readStream, entry.fileName);
+          readStream.on('end', () => {
+            //console.log('add finished');
+            resolve();
+          });
+        });
+      });
+    }
+  });
+
+  const deletes = {};
+
+  for (let k in originEntries) {
+    if (!newEntries[k]) {
+      console.log('Delete ' + k);
+      deletes[k] = 1;
+    }
+  }
+
+  //console.log({copies, deletes});
+  zipfile.addBuffer(Buffer.from(JSON.stringify({ copies, deletes })), '__diff.json');
+  zipfile.end();
+  await writePromise;
+}
+
+async function diffFromPackage(origin, next, output, originBundleName, transformPackagePath = v => v) {
+  fs.ensureDirSync(_path2.default.dirname(output));
+
+  const originEntries = {};
+  const originMap = {};
+
+  let originSource;
+
+  await enumZipEntries(origin, (entry, zipFile) => {
+    if (!/\/$/.test(entry.fileName)) {
+      const fn = transformPackagePath(entry.fileName);
+      if (!fn) {
+        return;
+      }
+
+      //console.log(fn);
+      // isFile
+      originEntries[fn] = entry.crc32;
+      originMap[entry.crc32] = fn;
+
+      if (fn === originBundleName) {
+        // This is source.
+        return readEntire(entry, zipFile).then(v => originSource = v);
+      }
+    }
+  });
+
+  if (!originSource) {
+    throw new Error(`Bundle file not found! Please use default bundle file name and path.`);
+  }
+
+  const copies = {};
+
+  const zipfile = new _yazl.ZipFile();
+
+  const writePromise = new Promise((resolve, reject) => {
+    zipfile.outputStream.on('error', err => {
+      throw err;
+    });
+    zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', function () {
+      resolve();
+    });
+  });
+
+  await enumZipEntries(next, (entry, nextZipfile) => {
+    if (/\/$/.test(entry.fileName)) {
+      // Directory
+      zipfile.addEmptyDirectory(entry.fileName);
+    } else if (entry.fileName === 'index.bundlejs') {
+      //console.log('Found bundle');
+      return readEntire(entry, nextZipfile).then(newSource => {
+        //console.log('Begin diff');
+        zipfile.addBuffer(diff(originSource, newSource), 'index.bundlejs.patch');
+        //console.log('End diff');
+      });
+    } else {
+      // If same file.
+      if (originEntries[entry.fileName] === entry.crc32) {
+        copies[entry.fileName] = '';
+        return;
+      }
+      // If moved from other place
+      if (originMap[entry.crc32]) {
+        copies[entry.fileName] = originMap[entry.crc32];
+        return;
+      }
+
+      return new Promise((resolve, reject) => {
+        nextZipfile.openReadStream(entry, function (err, readStream) {
+          if (err) {
+            return reject(err);
+          }
+          zipfile.addReadStream(readStream, entry.fileName);
+          readStream.on('end', () => {
+            //console.log('add finished');
+            resolve();
+          });
+        });
+      });
+    }
+  });
+
+  zipfile.addBuffer(Buffer.from(JSON.stringify({ copies })), '__diff.json');
+  zipfile.end();
+  await writePromise;
+}
+
+function enumZipEntries(zipFn, callback) {
+  return new Promise((resolve, reject) => {
+    (0, _yauzl.open)(zipFn, { lazyEntries: true }, (err, zipfile) => {
+      if (err) {
+        return reject(err);
+      }
+      zipfile.on('end', resolve);
+      zipfile.on('error', reject);
+      zipfile.on('entry', entry => {
+        const result = callback(entry, zipfile);
+        if (result && typeof result.then === 'function') {
+          result.then(() => zipfile.readEntry());
+        } else {
+          zipfile.readEntry();
+        }
+      });
+      zipfile.readEntry();
+    });
+  });
+}
+
+function diffArgsCheck(args, options, diffFn) {
+  const [origin, next] = args;
+
+  if (!origin || !next) {
+    console.error(`Usage: pushy ${diffFn} <origin> <next>`);
+    process.exit(1);
+  }
+
+  if (diffFn.startsWith('hdiff')) {
+    if (!hdiff) {
+      console.error(`This function needs "node-hdiffpatch". 
+        Please run "npm i node-hdiffpatch" to install`);
+      process.exit(1);
+    }
+    diff = hdiff;
+  } else {
+    if (!bsdiff) {
+      console.error(`This function needs "node-bsdiff". 
+        Please run "npm i node-bsdiff" to install`);
+      process.exit(1);
+    }
+    diff = bsdiff;
+  }
+  const { output } = options;
+
+  return {
+    origin,
+    next,
+    realOutput: output.replace(/\$\{time\}/g, '' + Date.now())
+  };
+}
+
+const commands = exports.commands = {
+  bundle: async function ({ options }) {
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+
+    let { bundleName, entryFile, intermediaDir, output, dev, sourcemap } = (0, _utils.translateOptions)(_extends({}, options, {
+      platform
+    }));
+
+    const sourcemapOutput = _path2.default.join(intermediaDir, bundleName + '.map');
+
+    const realOutput = output.replace(/\$\{time\}/g, '' + Date.now());
+
+    if (!platform) {
+      throw new Error('Platform must be specified.');
+    }
+
+    const { version, major, minor } = (0, _utils.getRNVersion)();
+
+    console.log('Bundling with react-native: ', version);
+    (0, _utils.printVersionCommand)();
+
+    await runReactNativeBundleCommand(bundleName, dev, entryFile, intermediaDir, platform, sourcemap ? sourcemapOutput : '');
+
+    await pack(_path2.default.resolve(intermediaDir), realOutput);
+
+    const v = await (0, _utils.question)('是否现在上传此热更包?(Y/N)');
+    if (v.toLowerCase() === 'y') {
+      await this.publish({
+        args: [realOutput],
+        options: {
+          platform
+        }
+      });
+    }
+  },
+
+  async diff({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'diff');
+
+    await diffFromPPK(origin, next, realOutput, 'index.bundlejs');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiff({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiff');
+
+    await diffFromPPK(origin, next, realOutput, 'index.bundlejs');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async diffFromApk({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApk');
+
+    await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiffFromApk({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApk');
+
+    await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async diffFromIpa({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromIpa');
+
+    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', v => {
+      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+      return m && m[1];
+    });
+
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiffFromIpa({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromIpa');
+
+    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', v => {
+      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+      return m && m[1];
+    });
+
+    console.log(`${realOutput} generated.`);
+  }
+};

lib/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+'use strict';
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _api = require('./api');
+
+var _updateNotifier = require('update-notifier');
+
+var _updateNotifier2 = _interopRequireDefault(_updateNotifier);
+
+var _index = require('./utils/index.js');
+
+var _package = require('../package.json');
+
+var _package2 = _interopRequireDefault(_package);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+(0, _updateNotifier2.default)({ pkg: _package2.default }).notify({ isGlobal: true });
+
+function printUsage({ args }) {
+  // const commandName = args[0];
+  // TODO: print usage of commandName, or print global usage.
+
+  console.log('Usage is under development now.');
+  console.log('Visit `https://github.com/reactnativecn/react-native-pushy` for early document.');
+  process.exit(1);
+}
+
+const commands = _extends({}, require('./user').commands, require('./bundle').commands, require('./app').commands, require('./package').commands, require('./versions').commands, {
+  help: printUsage
+});
+
+function run() {
+  if (process.argv.indexOf('-v') >= 0 || process.argv[2] === 'version') {
+    (0, _index.printVersionCommand)();
+    process.exit();
+  }
+
+  const argv = require('cli-arguments').parse(require('../cli.json'));
+  global.NO_INTERACTIVE = argv.options['no-interactive'];
+  global.USE_ACC_OSS = argv.options['acc'];
+
+  (0, _api.loadSession)().then(() => commands[argv.command](argv)).catch(err => {
+    if (err.status === 401) {
+      console.log('尚未登录。\n请在项目目录中运行`pushy login`命令来登录');
+      return;
+    }
+    console.error(err.stack);
+    process.exit(-1);
+  });
+}
+
+run();

lib/package.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commands = undefined;
+exports.listPackage = listPackage;
+exports.choosePackage = choosePackage;
+
+var _api = require('./api');
+
+var _utils = require('./utils');
+
+var _app = require('./app');
+
+var _ttyTable = require('tty-table');
+
+var _ttyTable2 = _interopRequireDefault(_ttyTable);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function listPackage(appId) {
+  const { data } = await (0, _api.get)(`/app/${appId}/package/list?limit=1000`);
+
+  const header = [{ value: '原生包 Id' }, { value: '原生版本' }];
+  const rows = [];
+  for (const pkg of data) {
+    const { version } = pkg;
+    let versionInfo = '';
+    if (version) {
+      versionInfo = `, 已绑定：${version.name} (${version.id})`;
+    } else {
+      // versionInfo = ' (newest)';
+    }
+    let output = pkg.name;
+    if (pkg.status === 'paused') {
+      output += '(已暂停)';
+    }
+    if (pkg.status === 'expired') {
+      output += '(已过期)';
+    }
+    output += versionInfo;
+    rows.push([pkg.id, output]);
+  }
+
+  console.log((0, _ttyTable2.default)(header, rows).render());
+  console.log(`\n共 ${data.length} 个包`);
+  return data;
+}
+
+async function choosePackage(appId) {
+  const list = await listPackage(appId);
+
+  while (true) {
+    const id = await (0, _utils.question)('输入原生包 id:');
+    const app = list.find(v => v.id === (id | 0));
+    if (app) {
+      return app;
+    }
+  }
+}
+
+const commands = exports.commands = {
+  uploadIpa: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.ipa')) {
+      throw new Error('使用方法: pushy uploadIpa ipa后缀文件');
+    }
+    const {
+      versionName,
+      buildTime,
+      appId: appIdInPkg,
+      appKey: appKeyInPkg
+    } = await (0, _utils.getIpaInfo)(fn);
+    const { appId, appKey } = await (0, _app.getSelectedApp)('ios');
+
+    if (appIdInPkg && appIdInPkg != appId) {
+      throw new Error(`appId不匹配！当前ipa: ${appIdInPkg}, 当前update.json: ${appId}`);
+    }
+
+    if (appKeyInPkg && appKeyInPkg !== appKey) {
+      throw new Error(`appKey不匹配！当前ipa: ${appKeyInPkg}, 当前update.json: ${appKey}`);
+    }
+
+    const { hash } = await (0, _api.uploadFile)(fn);
+
+    const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
+      name: versionName,
+      hash,
+      buildTime
+    });
+    (0, _utils.saveToLocal)(fn, `${appId}/package/${id}.ipa`);
+    console.log(`已成功上传ipa原生包（id: ${id}, version: ${versionName}, buildTime: ${buildTime}）`);
+  },
+  uploadApk: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.apk')) {
+      throw new Error('使用方法: pushy uploadApk apk后缀文件');
+    }
+    const {
+      versionName,
+      buildTime,
+      appId: appIdInPkg,
+      appKey: appKeyInPkg
+    } = await (0, _utils.getApkInfo)(fn);
+    const { appId, appKey } = await (0, _app.getSelectedApp)('android');
+
+    if (appIdInPkg && appIdInPkg != appId) {
+      throw new Error(`appId不匹配！当前apk: ${appIdInPkg}, 当前update.json: ${appId}`);
+    }
+
+    if (appKeyInPkg && appKeyInPkg !== appKey) {
+      throw new Error(`appKey不匹配！当前apk: ${appKeyInPkg}, 当前update.json: ${appKey}`);
+    }
+
+    const { hash } = await (0, _api.uploadFile)(fn);
+
+    const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
+      name: versionName,
+      hash,
+      buildTime
+    });
+    (0, _utils.saveToLocal)(fn, `${appId}/package/${id}.apk`);
+    console.log(`已成功上传apk原生包（id: ${id}, version: ${versionName}, buildTime: ${buildTime}）`);
+  },
+  parseIpa: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.ipa')) {
+      throw new Error('使用方法: pushy parseIpa ipa后缀文件');
+    }
+    console.log((await (0, _utils.getIpaInfo)(fn)));
+  },
+  parseApk: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.apk')) {
+      throw new Error('使用方法: pushy parseApk apk后缀文件');
+    }
+    console.log((await (0, _utils.getApkInfo)(fn)));
+  },
+  packages: async function ({ options }) {
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { appId } = await (0, _app.getSelectedApp)(platform);
+    await listPackage(appId);
+  }
+};

lib/user.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commands = undefined;
+
+var _utils = require('./utils');
+
+var _api = require('./api');
+
+var _crypto = require('crypto');
+
+var _crypto2 = _interopRequireDefault(_crypto);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function md5(str) {
+  return _crypto2.default.createHash('md5').update(str).digest('hex');
+}
+
+const commands = exports.commands = {
+  login: async function ({ args }) {
+    const email = args[0] || (await (0, _utils.question)('email:'));
+    const pwd = args[1] || (await (0, _utils.question)('password:', true));
+    const { token, info } = await (0, _api.post)('/user/login', {
+      email,
+      pwd: md5(pwd)
+    });
+    (0, _api.replaceSession)({ token });
+    await (0, _api.saveSession)();
+    console.log(`欢迎使用 pushy 热更新服务， ${info.name}.`);
+  },
+  logout: async function () {
+    await (0, _api.closeSession)();
+    console.log('已退出登录');
+  },
+  me: async function () {
+    const me = await (0, _api.get)('/user/me');
+    for (const k in me) {
+      if (k !== 'ok') {
+        console.log(`${k}: ${me[k]}`);
+      }
+    }
+  }
+};

lib/utils/app-info-parser/apk.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const Zip = require('./zip');
+const { mapInfoResource, findApkIconPath, getBase64FromBuffer } = require('./utils');
+const ManifestName = /^androidmanifest\.xml$/;
+const ResourceName = /^resources\.arsc$/;
+
+const ManifestXmlParser = require('./xml-parser/manifest');
+const ResourceFinder = require('./resource-finder');
+
+class ApkParser extends Zip {
+  /**
+   * parser for parsing .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    super(file);
+    if (!(this instanceof ApkParser)) {
+      return new ApkParser(file);
+    }
+  }
+  parse() {
+    return new Promise((resolve, reject) => {
+      this.getEntries([ManifestName, ResourceName]).then(buffers => {
+        if (!buffers[ManifestName]) {
+          throw new Error('AndroidManifest.xml can\'t be found.');
+        }
+        let apkInfo = this._parseManifest(buffers[ManifestName]);
+        let resourceMap;
+        if (!buffers[ResourceName]) {
+          resolve(apkInfo);
+        } else {
+          // parse resourceMap
+          resourceMap = this._parseResourceMap(buffers[ResourceName]);
+          // update apkInfo with resourceMap
+          apkInfo = mapInfoResource(apkInfo, resourceMap);
+
+          // find icon path and parse icon
+          const iconPath = findApkIconPath(apkInfo);
+          if (iconPath) {
+            this.getEntry(iconPath).then(iconBuffer => {
+              apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null;
+              resolve(apkInfo);
+            }).catch(e => {
+              apkInfo.icon = null;
+              resolve(apkInfo);
+              console.warn('[Warning] failed to parse icon: ', e);
+            });
+          } else {
+            apkInfo.icon = null;
+            resolve(apkInfo);
+          }
+        }
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  _parseManifest(buffer) {
+    try {
+      const parser = new ManifestXmlParser(buffer, {
+        ignore: ['application.activity', 'application.service', 'application.receiver', 'application.provider', 'permission-group']
+      });
+      return parser.parse();
+    } catch (e) {
+      throw new Error('Parse AndroidManifest.xml error: ', e);
+    }
+  }
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  _parseResourceMap(buffer) {
+    try {
+      return new ResourceFinder().processResourceTable(buffer);
+    } catch (e) {
+      throw new Error('Parser resources.arsc error: ' + e);
+    }
+  }
+}
+
+module.exports = ApkParser;

lib/utils/app-info-parser/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const ApkParser = require('./apk');
+const IpaParser = require('./ipa');
+const supportFileTypes = ['ipa', 'apk'];
+
+class AppInfoParser {
+  /**
+   * parser for parsing .ipa or .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    if (!file) {
+      throw new Error('Param miss: file(file\'s path in Node, instance of File or Blob in browser).');
+    }
+    const splits = (file.name || file).split('.');
+    const fileType = splits[splits.length - 1].toLowerCase();
+    if (!supportFileTypes.includes(fileType)) {
+      throw new Error('Unsupported file type, only support .ipa or .apk file.');
+    }
+    this.file = file;
+
+    switch (fileType) {
+      case 'ipa':
+        this.parser = new IpaParser(this.file);
+        break;
+      case 'apk':
+        this.parser = new ApkParser(this.file);
+        break;
+    }
+  }
+  parse() {
+    return this.parser.parse();
+  }
+}
+
+module.exports = AppInfoParser;

lib/utils/app-info-parser/ipa.js

@@ -0,0 +1,96 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+const parsePlist = require('plist').parse;
+const parseBplist = require('bplist-parser').parseBuffer;
+const cgbiToPng = require('cgbi-to-png');
+
+const Zip = require('./zip');
+const { findIpaIconPath, getBase64FromBuffer, isBrowser } = require('./utils');
+
+const PlistName = new RegExp('payload/[^/]+?.app/info.plist$', 'i');
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
+
+class IpaParser extends Zip {
+  /**
+   * parser for parsing .ipa file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    super(file);
+    if (!(this instanceof IpaParser)) {
+      return new IpaParser(file);
+    }
+  }
+  parse() {
+    return new Promise((resolve, reject) => {
+      this.getEntries([PlistName, ProvisionName]).then(buffers => {
+        if (!buffers[PlistName]) {
+          throw new Error('Info.plist can\'t be found.');
+        }
+        const plistInfo = this._parsePlist(buffers[PlistName]);
+        // parse mobile provision
+        const provisionInfo = this._parseProvision(buffers[ProvisionName]);
+        plistInfo.mobileProvision = provisionInfo;
+
+        // find icon path and parse icon
+        const iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase());
+        this.getEntry(iconRegex).then(iconBuffer => {
+          try {
+            // In general, the ipa file's icon has been specially processed, should be converted
+            plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null;
+          } catch (err) {
+            if (isBrowser()) {
+              // Normal conversion in other cases
+              plistInfo.icon = iconBuffer ? getBase64FromBuffer(window.btoa(String.fromCharCode.apply(String, _toConsumableArray(iconBuffer)))) : null;
+            } else {
+              plistInfo.icon = null;
+              console.warn('[Warning] failed to parse icon: ', err);
+            }
+          }
+          resolve(plistInfo);
+        }).catch(e => {
+          reject(e);
+        });
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  /**
+   * Parse plist
+   * @param {Buffer} buffer // plist file's buffer
+   */
+  _parsePlist(buffer) {
+    let result;
+    const bufferType = buffer[0];
+    if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+      result = parsePlist(buffer.toString());
+    } else if (bufferType === 98) {
+      result = parseBplist(buffer)[0];
+    } else {
+      throw new Error('Unknown plist buffer type.');
+    }
+    return result;
+  }
+  /**
+   * parse provision
+   * @param {Buffer} buffer // provision file's buffer
+   */
+  _parseProvision(buffer) {
+    let info = {};
+    if (buffer) {
+      let content = buffer.toString('utf-8');
+      const firstIndex = content.indexOf('<?xml');
+      const endIndex = content.indexOf('</plist>');
+      content = content.slice(firstIndex, endIndex + 8);
+      if (content) {
+        info = parsePlist(content);
+      }
+    }
+    return info;
+  }
+}
+
+module.exports = IpaParser;

lib/utils/app-info-parser/resource-finder.js

@@ -0,0 +1,486 @@
+"use strict";
+
+/**
+ * Code translated from a C# project https://github.com/hylander0/Iteedee.ApkReader/blob/master/Iteedee.ApkReader/ApkResourceFinder.cs
+ *
+ * Decode binary file `resources.arsc` from a .apk file to a JavaScript Object.
+ */
+
+var ByteBuffer = require("bytebuffer");
+
+var DEBUG = false;
+
+var RES_STRING_POOL_TYPE = 0x0001;
+var RES_TABLE_TYPE = 0x0002;
+var RES_TABLE_PACKAGE_TYPE = 0x0200;
+var RES_TABLE_TYPE_TYPE = 0x0201;
+var RES_TABLE_TYPE_SPEC_TYPE = 0x0202;
+
+// The 'data' holds a ResTable_ref, a reference to another resource
+// table entry.
+var TYPE_REFERENCE = 0x01;
+// The 'data' holds an index into the containing resource table's
+// global value string pool.
+var TYPE_STRING = 0x03;
+
+function ResourceFinder() {
+  this.valueStringPool = null;
+  this.typeStringPool = null;
+  this.keyStringPool = null;
+
+  this.package_id = 0;
+
+  this.responseMap = {};
+  this.entryMap = {};
+}
+
+/**
+ * Same to C# BinaryReader.readBytes
+ *
+ * @param bb ByteBuffer
+ * @param len length
+ * @returns {Buffer}
+ */
+ResourceFinder.readBytes = function (bb, len) {
+  var uint8Array = new Uint8Array(len);
+  for (var i = 0; i < len; i++) {
+    uint8Array[i] = bb.readUint8();
+  }
+
+  return ByteBuffer.wrap(uint8Array, "binary", true);
+};
+
+//
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Map<String, Set<String>>}
+ */
+ResourceFinder.prototype.processResourceTable = function (resourceBuffer) {
+  const bb = ByteBuffer.wrap(resourceBuffer, "binary", true);
+
+  // Resource table structure
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      packageCount = bb.readInt(),
+      buffer,
+      bb2;
+  if (type != RES_TABLE_TYPE) {
+    throw new Error("No RES_TABLE_TYPE found!");
+  }
+  if (size != bb.limit) {
+    throw new Error("The buffer size not matches to the resource table size.");
+  }
+  bb.offset = headerSize;
+
+  var realStringPoolCount = 0,
+      realPackageCount = 0;
+
+  while (true) {
+    var pos, t, hs, s;
+    try {
+      pos = bb.offset;
+      t = bb.readShort();
+      hs = bb.readShort();
+      s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+    if (t == RES_STRING_POOL_TYPE) {
+      // Process the string pool
+      if (realStringPoolCount == 0) {
+        // Only the first string pool is processed.
+        if (DEBUG) {
+          console.log("Processing the string pool ...");
+        }
+
+        buffer = new ByteBuffer(s);
+        bb.offset = pos;
+        bb.prependTo(buffer);
+
+        bb2 = ByteBuffer.wrap(buffer, "binary", true);
+
+        bb2.LE();
+        this.valueStringPool = this.processStringPool(bb2);
+      }
+      realStringPoolCount++;
+    } else if (t == RES_TABLE_PACKAGE_TYPE) {
+      // Process the package
+      if (DEBUG) {
+        console.log("Processing the package " + realPackageCount + " ...");
+      }
+
+      buffer = new ByteBuffer(s);
+      bb.offset = pos;
+      bb.prependTo(buffer);
+
+      bb2 = ByteBuffer.wrap(buffer, "binary", true);
+      bb2.LE();
+      this.processPackage(bb2);
+
+      realPackageCount++;
+    } else {
+      throw new Error("Unsupported type");
+    }
+    bb.offset = pos + s;
+    if (!bb.remaining()) break;
+  }
+
+  if (realStringPoolCount != 1) {
+    throw new Error("More than 1 string pool found!");
+  }
+  if (realPackageCount != packageCount) {
+    throw new Error("Real package count not equals the declared count.");
+  }
+
+  return this.responseMap;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processPackage = function (bb) {
+  // Package structure
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readInt();
+
+  this.package_id = id;
+
+  for (var i = 0; i < 256; ++i) {
+    bb.readUint8();
+  }
+
+  var typeStrings = bb.readInt(),
+      lastPublicType = bb.readInt(),
+      keyStrings = bb.readInt(),
+      lastPublicKey = bb.readInt();
+
+  if (typeStrings != headerSize) {
+    throw new Error("TypeStrings must immediately following the package structure header.");
+  }
+
+  if (DEBUG) {
+    console.log("Type strings:");
+  }
+
+  var lastPosition = bb.offset;
+  bb.offset = typeStrings;
+  var bbTypeStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.typeStringPool = this.processStringPool(bbTypeStrings);
+
+  // Key strings
+  if (DEBUG) {
+    console.log("Key strings:");
+  }
+
+  bb.offset = keyStrings;
+  var key_type = bb.readShort(),
+      key_headerSize = bb.readShort(),
+      key_size = bb.readInt();
+
+  lastPosition = bb.offset;
+  bb.offset = keyStrings;
+  var bbKeyStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.keyStringPool = this.processStringPool(bbKeyStrings);
+
+  // Iterate through all chunks
+  var typeSpecCount = 0;
+  var typeCount = 0;
+
+  bb.offset = keyStrings + key_size;
+
+  var bb2;
+
+  while (true) {
+    var pos = bb.offset;
+    try {
+      var t = bb.readShort();
+      var hs = bb.readShort();
+      var s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+
+    if (t == RES_TABLE_TYPE_SPEC_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processTypeSpec(bb2);
+
+      typeSpecCount++;
+    } else if (t == RES_TABLE_TYPE_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processType(bb2);
+
+      typeCount++;
+    }
+
+    if (s == 0) {
+      break;
+    }
+
+    bb.offset = pos + s;
+
+    if (!bb.remaining()) {
+      break;
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processType = function (bb) {
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readByte(),
+      res0 = bb.readByte(),
+      res1 = bb.readShort(),
+      entryCount = bb.readInt(),
+      entriesStart = bb.readInt();
+
+  var refKeys = {};
+
+  var config_size = bb.readInt();
+
+  // Skip the config data
+  bb.offset = headerSize;
+
+  if (headerSize + entryCount * 4 != entriesStart) {
+    throw new Error("HeaderSize, entryCount and entriesStart are not valid.");
+  }
+
+  // Start to get entry indices
+  var entryIndices = new Array(entryCount);
+  for (var i = 0; i < entryCount; ++i) {
+    entryIndices[i] = bb.readInt();
+  }
+
+  // Get entries
+  for (var i = 0; i < entryCount; ++i) {
+    if (entryIndices[i] == -1) continue;
+
+    var resource_id = this.package_id << 24 | id << 16 | i;
+
+    var pos = bb.offset,
+        entry_size,
+        entry_flag,
+        entry_key,
+        value_size,
+        value_res0,
+        value_dataType,
+        value_data;
+    try {
+      entry_size = bb.readShort();
+      entry_flag = bb.readShort();
+      entry_key = bb.readInt();
+    } catch (e) {
+      break;
+    }
+
+    // Get the value (simple) or map (complex)
+
+    var FLAG_COMPLEX = 0x0001;
+    if ((entry_flag & FLAG_COMPLEX) == 0) {
+      // Simple case
+      value_size = bb.readShort();
+      value_res0 = bb.readByte();
+      value_dataType = bb.readByte();
+      value_data = bb.readInt();
+
+      var idStr = Number(resource_id).toString(16);
+      var keyStr = this.keyStringPool[entry_key];
+
+      var data = null;
+
+      if (DEBUG) {
+        console.log("Entry 0x" + idStr + ", key: " + keyStr + ", simple value type: ");
+      }
+
+      var key = parseInt(idStr, 16);
+
+      var entryArr = this.entryMap[key];
+      if (entryArr == null) {
+        entryArr = [];
+      }
+      entryArr.push(keyStr);
+
+      this.entryMap[key] = entryArr;
+
+      if (value_dataType == TYPE_STRING) {
+        data = this.valueStringPool[value_data];
+
+        if (DEBUG) {
+          console.log(", data: " + this.valueStringPool[value_data] + "");
+        }
+      } else if (value_dataType == TYPE_REFERENCE) {
+        var hexIndex = Number(value_data).toString(16);
+
+        refKeys[idStr] = value_data;
+      } else {
+        data = "" + value_data;
+        if (DEBUG) {
+          console.log(", data: " + value_data + "");
+        }
+      }
+
+      this.putIntoMap("@" + idStr, data);
+    } else {
+      // Complex case
+      var entry_parent = bb.readInt();
+      var entry_count = bb.readInt();
+
+      for (var j = 0; j < entry_count; ++j) {
+        var ref_name = bb.readInt();
+        value_size = bb.readShort();
+        value_res0 = bb.readByte();
+        value_dataType = bb.readByte();
+        value_data = bb.readInt();
+      }
+
+      if (DEBUG) {
+        console.log("Entry 0x" + Number(resource_id).toString(16) + ", key: " + this.keyStringPool[entry_key] + ", complex value, not printed.");
+      }
+    }
+  }
+
+  for (var refK in refKeys) {
+    var values = this.responseMap["@" + Number(refKeys[refK]).toString(16).toUpperCase()];
+    if (values != null && Object.keys(values).length < 1000) {
+      for (var value in values) {
+        this.putIntoMap("@" + refK, values[value]);
+      }
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Array}
+ */
+ResourceFinder.prototype.processStringPool = function (bb) {
+  // String pool structure
+  //
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      stringCount = bb.readInt(),
+      styleCount = bb.readInt(),
+      flags = bb.readInt(),
+      stringsStart = bb.readInt(),
+      stylesStart = bb.readInt(),
+      u16len,
+      buffer;
+
+  var isUTF_8 = (flags & 256) != 0;
+
+  var offsets = new Array(stringCount);
+  for (var i = 0; i < stringCount; ++i) {
+    offsets[i] = bb.readInt();
+  }
+
+  var strings = new Array(stringCount);
+
+  for (var i = 0; i < stringCount; ++i) {
+    var pos = stringsStart + offsets[i];
+    bb.offset = pos;
+
+    strings[i] = "";
+
+    if (isUTF_8) {
+      u16len = bb.readUint8();
+
+      if ((u16len & 0x80) != 0) {
+        u16len = ((u16len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      var u8len = bb.readUint8();
+      if ((u8len & 0x80) != 0) {
+        u8len = ((u8len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      if (u8len > 0) {
+        buffer = ResourceFinder.readBytes(bb, u8len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      } else {
+        strings[i] = "";
+      }
+    } else {
+      u16len = bb.readUint16();
+      if ((u16len & 0x8000) != 0) {
+        // larger than 32768
+        u16len = ((u16len & 0x7fff) << 16) + bb.readUint16();
+      }
+
+      if (u16len > 0) {
+        var len = u16len * 2;
+        buffer = ResourceFinder.readBytes(bb, len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      }
+    }
+
+    if (DEBUG) {
+      console.log("Parsed value: {0}", strings[i]);
+    }
+  }
+
+  return strings;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processTypeSpec = function (bb) {
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readByte(),
+      res0 = bb.readByte(),
+      res1 = bb.readShort(),
+      entryCount = bb.readInt();
+
+  if (DEBUG) {
+    console.log("Processing type spec " + this.typeStringPool[id - 1] + "...");
+  }
+
+  var flags = new Array(entryCount);
+
+  for (var i = 0; i < entryCount; ++i) {
+    flags[i] = bb.readInt();
+  }
+};
+
+ResourceFinder.prototype.putIntoMap = function (resId, value) {
+  if (this.responseMap[resId.toUpperCase()] == null) {
+    this.responseMap[resId.toUpperCase()] = [];
+  }
+  if (value) {
+    this.responseMap[resId.toUpperCase()].push(value);
+  }
+};
+
+module.exports = ResourceFinder;

lib/utils/app-info-parser/utils.js

@@ -0,0 +1,158 @@
+'use strict';
+
+function objectType(o) {
+  return Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
+}
+
+function isArray(o) {
+  return objectType(o) === 'array';
+}
+
+function isObject(o) {
+  return objectType(o) === 'object';
+}
+
+function isPrimitive(o) {
+  return o === null || ['boolean', 'number', 'string', 'undefined'].includes(objectType(o));
+}
+
+function isBrowser() {
+  return typeof process === 'undefined' || Object.prototype.toString.call(process) !== '[object process]';
+}
+
+/**
+ * map file place with resourceMap
+ * @param {Object} apkInfo // json info parsed from .apk file
+ * @param {Object} resourceMap // resourceMap
+ */
+function mapInfoResource(apkInfo, resourceMap) {
+  iteratorObj(apkInfo);
+  return apkInfo;
+  function iteratorObj(obj) {
+    for (var i in obj) {
+      if (isArray(obj[i])) {
+        iteratorArray(obj[i]);
+      } else if (isObject(obj[i])) {
+        iteratorObj(obj[i]);
+      } else if (isPrimitive(obj[i])) {
+        if (isResources(obj[i])) {
+          obj[i] = resourceMap[transKeyToMatchResourceMap(obj[i])];
+        }
+      }
+    }
+  }
+
+  function iteratorArray(array) {
+    const l = array.length;
+    for (let i = 0; i < l; i++) {
+      if (isArray(array[i])) {
+        iteratorArray(array[i]);
+      } else if (isObject(array[i])) {
+        iteratorObj(array[i]);
+      } else if (isPrimitive(array[i])) {
+        if (isResources(array[i])) {
+          array[i] = resourceMap[transKeyToMatchResourceMap(array[i])];
+        }
+      }
+    }
+  }
+
+  function isResources(attrValue) {
+    if (!attrValue) return false;
+    if (typeof attrValue !== 'string') {
+      attrValue = attrValue.toString();
+    }
+    return attrValue.indexOf('resourceId:') === 0;
+  }
+
+  function transKeyToMatchResourceMap(resourceId) {
+    return '@' + resourceId.replace('resourceId:0x', '').toUpperCase();
+  }
+}
+
+/**
+ * find .apk file's icon path from json info
+ * @param info // json info parsed from .apk file
+ */
+function findApkIconPath(info) {
+  if (!info.application.icon || !info.application.icon.splice) {
+    return '';
+  }
+  const rulesMap = {
+    mdpi: 48,
+    hdpi: 72,
+    xhdpi: 96,
+    xxdpi: 144,
+    xxxhdpi: 192
+  };
+  const resultMap = {};
+  const maxDpiIcon = { dpi: 120, icon: '' };
+
+  for (const i in rulesMap) {
+    info.application.icon.some(icon => {
+      if (icon && icon.indexOf(i) !== -1) {
+        resultMap['application-icon-' + rulesMap[i]] = icon;
+        return true;
+      }
+    });
+
+    // get the maximal size icon
+    if (resultMap['application-icon-' + rulesMap[i]] && rulesMap[i] >= maxDpiIcon.dpi) {
+      maxDpiIcon.dpi = rulesMap[i];
+      maxDpiIcon.icon = resultMap['application-icon-' + rulesMap[i]];
+    }
+  }
+
+  if (Object.keys(resultMap).length === 0 || !maxDpiIcon.icon) {
+    maxDpiIcon.dpi = 120;
+    maxDpiIcon.icon = info.application.icon[0] || '';
+    resultMap['applicataion-icon-120'] = maxDpiIcon.icon;
+  }
+  return maxDpiIcon.icon;
+}
+
+/**
+ * find .ipa file's icon path from json info
+ * @param info // json info parsed from .ipa file
+ */
+function findIpaIconPath(info) {
+  if (info.CFBundleIcons && info.CFBundleIcons.CFBundlePrimaryIcon && info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles && info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length) {
+    return info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles[info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length - 1];
+  } else if (info.CFBundleIconFiles && info.CFBundleIconFiles.length) {
+    return info.CFBundleIconFiles[info.CFBundleIconFiles.length - 1];
+  } else {
+    return '.app/Icon.png';
+  }
+}
+
+/**
+ * transform buffer to base64
+ * @param {Buffer} buffer
+ */
+function getBase64FromBuffer(buffer) {
+  return 'data:image/png;base64,' + buffer.toString('base64');
+}
+
+/**
+ * 去除unicode空字符
+ * @param {String} str
+ */
+function decodeNullUnicode(str) {
+  if (typeof str === 'string') {
+    // eslint-disable-next-line
+    str = str.replace(/\u0000/g, '');
+  }
+  return str;
+}
+
+module.exports = {
+  isArray,
+  isObject,
+  isPrimitive,
+  isBrowser,
+  mapInfoResource,
+  findApkIconPath,
+  findIpaIconPath,
+  getBase64FromBuffer,
+  decodeNullUnicode
+};

lib/utils/app-info-parser/xml-parser/binary.js

@@ -0,0 +1,671 @@
+'use strict';
+
+// From https://github.com/openstf/adbkit-apkreader
+const NodeType = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  CDATA_SECTION_NODE: 4
+};
+
+const ChunkType = {
+  NULL: 0x0000,
+  STRING_POOL: 0x0001,
+  TABLE: 0x0002,
+  XML: 0x0003,
+  XML_FIRST_CHUNK: 0x0100,
+  XML_START_NAMESPACE: 0x0100,
+  XML_END_NAMESPACE: 0x0101,
+  XML_START_ELEMENT: 0x0102,
+  XML_END_ELEMENT: 0x0103,
+  XML_CDATA: 0x0104,
+  XML_LAST_CHUNK: 0x017f,
+  XML_RESOURCE_MAP: 0x0180,
+  TABLE_PACKAGE: 0x0200,
+  TABLE_TYPE: 0x0201,
+  TABLE_TYPE_SPEC: 0x0202
+};
+
+const StringFlags = {
+  SORTED: 1 << 0,
+  UTF8: 1 << 8
+
+  // Taken from android.util.TypedValue
+};const TypedValue = {
+  COMPLEX_MANTISSA_MASK: 0x00ffffff,
+  COMPLEX_MANTISSA_SHIFT: 0x00000008,
+  COMPLEX_RADIX_0p23: 0x00000003,
+  COMPLEX_RADIX_16p7: 0x00000001,
+  COMPLEX_RADIX_23p0: 0x00000000,
+  COMPLEX_RADIX_8p15: 0x00000002,
+  COMPLEX_RADIX_MASK: 0x00000003,
+  COMPLEX_RADIX_SHIFT: 0x00000004,
+  COMPLEX_UNIT_DIP: 0x00000001,
+  COMPLEX_UNIT_FRACTION: 0x00000000,
+  COMPLEX_UNIT_FRACTION_PARENT: 0x00000001,
+  COMPLEX_UNIT_IN: 0x00000004,
+  COMPLEX_UNIT_MASK: 0x0000000f,
+  COMPLEX_UNIT_MM: 0x00000005,
+  COMPLEX_UNIT_PT: 0x00000003,
+  COMPLEX_UNIT_PX: 0x00000000,
+  COMPLEX_UNIT_SHIFT: 0x00000000,
+  COMPLEX_UNIT_SP: 0x00000002,
+  DENSITY_DEFAULT: 0x00000000,
+  DENSITY_NONE: 0x0000ffff,
+  TYPE_ATTRIBUTE: 0x00000002,
+  TYPE_DIMENSION: 0x00000005,
+  TYPE_FIRST_COLOR_INT: 0x0000001c,
+  TYPE_FIRST_INT: 0x00000010,
+  TYPE_FLOAT: 0x00000004,
+  TYPE_FRACTION: 0x00000006,
+  TYPE_INT_BOOLEAN: 0x00000012,
+  TYPE_INT_COLOR_ARGB4: 0x0000001e,
+  TYPE_INT_COLOR_ARGB8: 0x0000001c,
+  TYPE_INT_COLOR_RGB4: 0x0000001f,
+  TYPE_INT_COLOR_RGB8: 0x0000001d,
+  TYPE_INT_DEC: 0x00000010,
+  TYPE_INT_HEX: 0x00000011,
+  TYPE_LAST_COLOR_INT: 0x0000001f,
+  TYPE_LAST_INT: 0x0000001f,
+  TYPE_NULL: 0x00000000,
+  TYPE_REFERENCE: 0x00000001,
+  TYPE_STRING: 0x00000003
+};
+
+class BinaryXmlParser {
+  constructor(buffer, options = {}) {
+    this.buffer = buffer;
+    this.cursor = 0;
+    this.strings = [];
+    this.resources = [];
+    this.document = null;
+    this.parent = null;
+    this.stack = [];
+    this.debug = options.debug || false;
+  }
+
+  readU8() {
+    this.debug && console.group('readU8');
+    this.debug && console.debug('cursor:', this.cursor);
+    const val = this.buffer[this.cursor];
+    this.debug && console.debug('value:', val);
+    this.cursor += 1;
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readU16() {
+    this.debug && console.group('readU16');
+    this.debug && console.debug('cursor:', this.cursor);
+    const val = this.buffer.readUInt16LE(this.cursor);
+    this.debug && console.debug('value:', val);
+    this.cursor += 2;
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readS32() {
+    this.debug && console.group('readS32');
+    this.debug && console.debug('cursor:', this.cursor);
+    const val = this.buffer.readInt32LE(this.cursor);
+    this.debug && console.debug('value:', val);
+    this.cursor += 4;
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readU32() {
+    this.debug && console.group('readU32');
+    this.debug && console.debug('cursor:', this.cursor);
+    const val = this.buffer.readUInt32LE(this.cursor);
+    this.debug && console.debug('value:', val);
+    this.cursor += 4;
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readLength8() {
+    this.debug && console.group('readLength8');
+    let len = this.readU8();
+    if (len & 0x80) {
+      len = (len & 0x7f) << 8;
+      len += this.readU8();
+    }
+    this.debug && console.debug('length:', len);
+    this.debug && console.groupEnd();
+    return len;
+  }
+
+  readLength16() {
+    this.debug && console.group('readLength16');
+    let len = this.readU16();
+    if (len & 0x8000) {
+      len = (len & 0x7fff) << 16;
+      len += this.readU16();
+    }
+    this.debug && console.debug('length:', len);
+    this.debug && console.groupEnd();
+    return len;
+  }
+
+  readDimension() {
+    this.debug && console.group('readDimension');
+
+    const dimension = {
+      value: null,
+      unit: null,
+      rawUnit: null
+    };
+
+    const value = this.readU32();
+    const unit = dimension.value & 0xff;
+
+    dimension.value = value >> 8;
+    dimension.rawUnit = unit;
+
+    switch (unit) {
+      case TypedValue.COMPLEX_UNIT_MM:
+        dimension.unit = 'mm';
+        break;
+      case TypedValue.COMPLEX_UNIT_PX:
+        dimension.unit = 'px';
+        break;
+      case TypedValue.COMPLEX_UNIT_DIP:
+        dimension.unit = 'dp';
+        break;
+      case TypedValue.COMPLEX_UNIT_SP:
+        dimension.unit = 'sp';
+        break;
+      case TypedValue.COMPLEX_UNIT_PT:
+        dimension.unit = 'pt';
+        break;
+      case TypedValue.COMPLEX_UNIT_IN:
+        dimension.unit = 'in';
+        break;
+    }
+
+    this.debug && console.groupEnd();
+
+    return dimension;
+  }
+
+  readFraction() {
+    this.debug && console.group('readFraction');
+
+    const fraction = {
+      value: null,
+      type: null,
+      rawType: null
+    };
+
+    const value = this.readU32();
+    const type = value & 0xf;
+
+    fraction.value = this.convertIntToFloat(value >> 4);
+    fraction.rawType = type;
+
+    switch (type) {
+      case TypedValue.COMPLEX_UNIT_FRACTION:
+        fraction.type = '%';
+        break;
+      case TypedValue.COMPLEX_UNIT_FRACTION_PARENT:
+        fraction.type = '%p';
+        break;
+    }
+
+    this.debug && console.groupEnd();
+
+    return fraction;
+  }
+
+  readHex24() {
+    this.debug && console.group('readHex24');
+    var val = (this.readU32() & 0xffffff).toString(16);
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readHex32() {
+    this.debug && console.group('readHex32');
+    var val = this.readU32().toString(16);
+    this.debug && console.groupEnd();
+    return val;
+  }
+
+  readTypedValue() {
+    this.debug && console.group('readTypedValue');
+
+    const typedValue = {
+      value: null,
+      type: null,
+      rawType: null
+    };
+
+    const start = this.cursor;
+
+    let size = this.readU16();
+    /* const zero = */this.readU8();
+    const dataType = this.readU8();
+
+    // Yes, there has been a real world APK where the size is malformed.
+    if (size === 0) {
+      size = 8;
+    }
+
+    typedValue.rawType = dataType;
+
+    switch (dataType) {
+      case TypedValue.TYPE_INT_DEC:
+        typedValue.value = this.readS32();
+        typedValue.type = 'int_dec';
+        break;
+      case TypedValue.TYPE_INT_HEX:
+        typedValue.value = this.readS32();
+        typedValue.type = 'int_hex';
+        break;
+      case TypedValue.TYPE_STRING:
+        var ref = this.readS32();
+        typedValue.value = ref > 0 ? this.strings[ref] : '';
+        typedValue.type = 'string';
+        break;
+      case TypedValue.TYPE_REFERENCE:
+        var id = this.readU32();
+        typedValue.value = `resourceId:0x${id.toString(16)}`;
+        typedValue.type = 'reference';
+        break;
+      case TypedValue.TYPE_INT_BOOLEAN:
+        typedValue.value = this.readS32() !== 0;
+        typedValue.type = 'boolean';
+        break;
+      case TypedValue.TYPE_NULL:
+        this.readU32();
+        typedValue.value = null;
+        typedValue.type = 'null';
+        break;
+      case TypedValue.TYPE_INT_COLOR_RGB8:
+        typedValue.value = this.readHex24();
+        typedValue.type = 'rgb8';
+        break;
+      case TypedValue.TYPE_INT_COLOR_RGB4:
+        typedValue.value = this.readHex24();
+        typedValue.type = 'rgb4';
+        break;
+      case TypedValue.TYPE_INT_COLOR_ARGB8:
+        typedValue.value = this.readHex32();
+        typedValue.type = 'argb8';
+        break;
+      case TypedValue.TYPE_INT_COLOR_ARGB4:
+        typedValue.value = this.readHex32();
+        typedValue.type = 'argb4';
+        break;
+      case TypedValue.TYPE_DIMENSION:
+        typedValue.value = this.readDimension();
+        typedValue.type = 'dimension';
+        break;
+      case TypedValue.TYPE_FRACTION:
+        typedValue.value = this.readFraction();
+        typedValue.type = 'fraction';
+        break;
+      default:
+        {
+          const type = dataType.toString(16);
+          console.debug(`Not sure what to do with typed value of type 0x${type}, falling back to reading an uint32.`);
+          typedValue.value = this.readU32();
+          typedValue.type = 'unknown';
+        }
+    }
+
+    // Ensure we consume the whole value
+    const end = start + size;
+    if (this.cursor !== end) {
+      const type = dataType.toString(16);
+      const diff = end - this.cursor;
+      console.debug(`Cursor is off by ${diff} bytes at ${this.cursor} at supposed end \
+of typed value of type 0x${type}. The typed value started at offset ${start} \
+and is supposed to end at offset ${end}. Ignoring the rest of the value.`);
+      this.cursor = end;
+    }
+
+    this.debug && console.groupEnd();
+
+    return typedValue;
+  }
+
+  // https://twitter.com/kawasima/status/427730289201139712
+  convertIntToFloat(int) {
+    const buf = new ArrayBuffer(4);new Int32Array(buf)[0] = int;
+    return new Float32Array(buf)[0];
+  }
+
+  readString(encoding) {
+    this.debug && console.group('readString', encoding);
+    switch (encoding) {
+      case 'utf-8':
+        var stringLength = this.readLength8(encoding);
+        this.debug && console.debug('stringLength:', stringLength);
+        var byteLength = this.readLength8(encoding);
+        this.debug && console.debug('byteLength:', byteLength);
+        var value = this.buffer.toString(encoding, this.cursor, this.cursor += byteLength);
+        this.debug && console.debug('value:', value);
+        this.debug && console.groupEnd();
+        return value;
+      case 'ucs2':
+        stringLength = this.readLength16(encoding);
+        this.debug && console.debug('stringLength:', stringLength);
+        byteLength = stringLength * 2;
+        this.debug && console.debug('byteLength:', byteLength);
+        value = this.buffer.toString(encoding, this.cursor, this.cursor += byteLength);
+        this.debug && console.debug('value:', value);
+        this.debug && console.groupEnd();
+        return value;
+      default:
+        throw new Error(`Unsupported encoding '${encoding}'`);
+    }
+  }
+
+  readChunkHeader() {
+    this.debug && console.group('readChunkHeader');
+    var header = {
+      startOffset: this.cursor,
+      chunkType: this.readU16(),
+      headerSize: this.readU16(),
+      chunkSize: this.readU32()
+    };
+    this.debug && console.debug('startOffset:', header.startOffset);
+    this.debug && console.debug('chunkType:', header.chunkType);
+    this.debug && console.debug('headerSize:', header.headerSize);
+    this.debug && console.debug('chunkSize:', header.chunkSize);
+    this.debug && console.groupEnd();
+    return header;
+  }
+
+  readStringPool(header) {
+    this.debug && console.group('readStringPool');
+
+    header.stringCount = this.readU32();
+    this.debug && console.debug('stringCount:', header.stringCount);
+    header.styleCount = this.readU32();
+    this.debug && console.debug('styleCount:', header.styleCount);
+    header.flags = this.readU32();
+    this.debug && console.debug('flags:', header.flags);
+    header.stringsStart = this.readU32();
+    this.debug && console.debug('stringsStart:', header.stringsStart);
+    header.stylesStart = this.readU32();
+    this.debug && console.debug('stylesStart:', header.stylesStart);
+
+    if (header.chunkType !== ChunkType.STRING_POOL) {
+      throw new Error('Invalid string pool header');
+    }
+
+    const offsets = [];
+    for (let i = 0, l = header.stringCount; i < l; ++i) {
+      this.debug && console.debug('offset:', i);
+      offsets.push(this.readU32());
+    }
+
+    const sorted = (header.flags & StringFlags.SORTED) === StringFlags.SORTED;
+    this.debug && console.debug('sorted:', sorted);
+    const encoding = (header.flags & StringFlags.UTF8) === StringFlags.UTF8 ? 'utf-8' : 'ucs2';
+    this.debug && console.debug('encoding:', encoding);
+
+    const stringsStart = header.startOffset + header.stringsStart;
+    this.cursor = stringsStart;
+    for (let i = 0, l = header.stringCount; i < l; ++i) {
+      this.debug && console.debug('string:', i);
+      this.debug && console.debug('offset:', offsets[i]);
+      this.cursor = stringsStart + offsets[i];
+      this.strings.push(this.readString(encoding));
+    }
+
+    // Skip styles
+    this.cursor = header.startOffset + header.chunkSize;
+
+    this.debug && console.groupEnd();
+
+    return null;
+  }
+
+  readResourceMap(header) {
+    this.debug && console.group('readResourceMap');
+    const count = Math.floor((header.chunkSize - header.headerSize) / 4);
+    for (let i = 0; i < count; ++i) {
+      this.resources.push(this.readU32());
+    }
+    this.debug && console.groupEnd();
+    return null;
+  }
+
+  readXmlNamespaceStart() /* header */{
+    this.debug && console.group('readXmlNamespaceStart');
+
+    /* const line = */this.readU32();
+    /* const commentRef = */this.readU32();
+    /* const prefixRef = */this.readS32();
+    /* const uriRef = */this.readS32();
+
+    // We don't currently care about the values, but they could
+    // be accessed like so:
+    //
+    // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
+    // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
+
+    this.debug && console.groupEnd();
+
+    return null;
+  }
+
+  readXmlNamespaceEnd() /* header */{
+    this.debug && console.group('readXmlNamespaceEnd');
+
+    /* const line = */this.readU32();
+    /* const commentRef = */this.readU32();
+    /* const prefixRef = */this.readS32();
+    /* const uriRef = */this.readS32();
+
+    // We don't currently care about the values, but they could
+    // be accessed like so:
+    //
+    // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
+    // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
+
+    this.debug && console.groupEnd();
+
+    return null;
+  }
+
+  readXmlElementStart() /* header */{
+    this.debug && console.group('readXmlElementStart');
+
+    const node = {
+      namespaceURI: null,
+      nodeType: NodeType.ELEMENT_NODE,
+      nodeName: null,
+      attributes: [],
+      childNodes: []
+
+      /* const line = */ };this.readU32();
+    /* const commentRef = */this.readU32();
+    const nsRef = this.readS32();
+    const nameRef = this.readS32();
+
+    if (nsRef > 0) {
+      node.namespaceURI = this.strings[nsRef];
+    }
+
+    node.nodeName = this.strings[nameRef];
+
+    /* const attrStart = */this.readU16();
+    /* const attrSize = */this.readU16();
+    const attrCount = this.readU16();
+    /* const idIndex = */this.readU16();
+    /* const classIndex = */this.readU16();
+    /* const styleIndex = */this.readU16();
+
+    for (let i = 0; i < attrCount; ++i) {
+      node.attributes.push(this.readXmlAttribute());
+    }
+
+    if (this.document) {
+      this.parent.childNodes.push(node);
+      this.parent = node;
+    } else {
+      this.document = this.parent = node;
+    }
+
+    this.stack.push(node);
+
+    this.debug && console.groupEnd();
+
+    return node;
+  }
+
+  readXmlAttribute() {
+    this.debug && console.group('readXmlAttribute');
+
+    const attr = {
+      namespaceURI: null,
+      nodeType: NodeType.ATTRIBUTE_NODE,
+      nodeName: null,
+      name: null,
+      value: null,
+      typedValue: null
+    };
+
+    const nsRef = this.readS32();
+    const nameRef = this.readS32();
+    const valueRef = this.readS32();
+
+    if (nsRef > 0) {
+      attr.namespaceURI = this.strings[nsRef];
+    }
+
+    attr.nodeName = attr.name = this.strings[nameRef];
+
+    if (valueRef > 0) {
+      // some apk have versionName with special characters
+      if (attr.name === 'versionName') {
+        // only keep printable characters
+        // https://www.ascii-code.com/characters/printable-characters
+        this.strings[valueRef] = this.strings[valueRef].replace(/[^\x21-\x7E]/g, '');
+      }
+      attr.value = this.strings[valueRef];
+    }
+
+    attr.typedValue = this.readTypedValue();
+
+    this.debug && console.groupEnd();
+
+    return attr;
+  }
+
+  readXmlElementEnd() /* header */{
+    this.debug && console.group('readXmlCData');
+
+    /* const line = */this.readU32();
+    /* const commentRef = */this.readU32();
+    /* const nsRef = */this.readS32();
+    /* const nameRef = */this.readS32();
+
+    this.stack.pop();
+    this.parent = this.stack[this.stack.length - 1];
+
+    this.debug && console.groupEnd();
+
+    return null;
+  }
+
+  readXmlCData() /* header */{
+    this.debug && console.group('readXmlCData');
+
+    const cdata = {
+      namespaceURI: null,
+      nodeType: NodeType.CDATA_SECTION_NODE,
+      nodeName: '#cdata',
+      data: null,
+      typedValue: null
+
+      /* const line = */ };this.readU32();
+    /* const commentRef = */this.readU32();
+    const dataRef = this.readS32();
+
+    if (dataRef > 0) {
+      cdata.data = this.strings[dataRef];
+    }
+
+    cdata.typedValue = this.readTypedValue();
+
+    this.parent.childNodes.push(cdata);
+
+    this.debug && console.groupEnd();
+
+    return cdata;
+  }
+
+  readNull(header) {
+    this.debug && console.group('readNull');
+    this.cursor += header.chunkSize - header.headerSize;
+    this.debug && console.groupEnd();
+    return null;
+  }
+
+  parse() {
+    this.debug && console.group('BinaryXmlParser.parse');
+
+    const xmlHeader = this.readChunkHeader();
+    if (xmlHeader.chunkType !== ChunkType.XML) {
+      throw new Error('Invalid XML header');
+    }
+
+    while (this.cursor < this.buffer.length) {
+      this.debug && console.group('chunk');
+      const start = this.cursor;
+      const header = this.readChunkHeader();
+      switch (header.chunkType) {
+        case ChunkType.STRING_POOL:
+          this.readStringPool(header);
+          break;
+        case ChunkType.XML_RESOURCE_MAP:
+          this.readResourceMap(header);
+          break;
+        case ChunkType.XML_START_NAMESPACE:
+          this.readXmlNamespaceStart(header);
+          break;
+        case ChunkType.XML_END_NAMESPACE:
+          this.readXmlNamespaceEnd(header);
+          break;
+        case ChunkType.XML_START_ELEMENT:
+          this.readXmlElementStart(header);
+          break;
+        case ChunkType.XML_END_ELEMENT:
+          this.readXmlElementEnd(header);
+          break;
+        case ChunkType.XML_CDATA:
+          this.readXmlCData(header);
+          break;
+        case ChunkType.NULL:
+          this.readNull(header);
+          break;
+        default:
+          throw new Error(`Unsupported chunk type '${header.chunkType}'`);
+      }
+
+      // Ensure we consume the whole chunk
+      const end = start + header.chunkSize;
+      if (this.cursor !== end) {
+        const diff = end - this.cursor;
+        const type = header.chunkType.toString(16);
+        console.debug(`Cursor is off by ${diff} bytes at ${this.cursor} at supposed \
+end of chunk of type 0x${type}. The chunk started at offset ${start} and is \
+supposed to end at offset ${end}. Ignoring the rest of the chunk.`);
+        this.cursor = end;
+      }
+
+      this.debug && console.groupEnd();
+    }
+
+    this.debug && console.groupEnd();
+
+    return this.document;
+  }
+}
+
+module.exports = BinaryXmlParser;

lib/utils/app-info-parser/xml-parser/manifest.js

@@ -0,0 +1,224 @@
+'use strict';
+
+// From https://github.com/openstf/adbkit-apkreader
+const BinaryXmlParser = require('./binary');
+
+const INTENT_MAIN = 'android.intent.action.MAIN';
+const CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER';
+
+class ManifestParser {
+  constructor(buffer, options = {}) {
+    this.buffer = buffer;
+    this.xmlParser = new BinaryXmlParser(this.buffer, options);
+  }
+
+  collapseAttributes(element) {
+    const collapsed = Object.create(null);
+    for (let attr of Array.from(element.attributes)) {
+      collapsed[attr.name] = attr.typedValue.value;
+    }
+    return collapsed;
+  }
+
+  parseIntents(element, target) {
+    target.intentFilters = [];
+    target.metaData = [];
+
+    return element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'intent-filter':
+          {
+            const intentFilter = this.collapseAttributes(element);
+
+            intentFilter.actions = [];
+            intentFilter.categories = [];
+            intentFilter.data = [];
+
+            element.childNodes.forEach(element => {
+              switch (element.nodeName) {
+                case 'action':
+                  intentFilter.actions.push(this.collapseAttributes(element));
+                  break;
+                case 'category':
+                  intentFilter.categories.push(this.collapseAttributes(element));
+                  break;
+                case 'data':
+                  intentFilter.data.push(this.collapseAttributes(element));
+                  break;
+              }
+            });
+
+            target.intentFilters.push(intentFilter);
+            break;
+          }
+        case 'meta-data':
+          target.metaData.push(this.collapseAttributes(element));
+          break;
+      }
+    });
+  }
+
+  parseApplication(element) {
+    const app = this.collapseAttributes(element);
+
+    app.activities = [];
+    app.activityAliases = [];
+    app.launcherActivities = [];
+    app.services = [];
+    app.receivers = [];
+    app.providers = [];
+    app.usesLibraries = [];
+    app.metaData = [];
+
+    element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'activity':
+          {
+            const activity = this.collapseAttributes(element);
+            this.parseIntents(element, activity);
+            app.activities.push(activity);
+            if (this.isLauncherActivity(activity)) {
+              app.launcherActivities.push(activity);
+            }
+            break;
+          }
+        case 'activity-alias':
+          {
+            const activityAlias = this.collapseAttributes(element);
+            this.parseIntents(element, activityAlias);
+            app.activityAliases.push(activityAlias);
+            if (this.isLauncherActivity(activityAlias)) {
+              app.launcherActivities.push(activityAlias);
+            }
+            break;
+          }
+        case 'service':
+          {
+            const service = this.collapseAttributes(element);
+            this.parseIntents(element, service);
+            app.services.push(service);
+            break;
+          }
+        case 'receiver':
+          {
+            const receiver = this.collapseAttributes(element);
+            this.parseIntents(element, receiver);
+            app.receivers.push(receiver);
+            break;
+          }
+        case 'provider':
+          {
+            const provider = this.collapseAttributes(element);
+
+            provider.grantUriPermissions = [];
+            provider.metaData = [];
+            provider.pathPermissions = [];
+
+            element.childNodes.forEach(element => {
+              switch (element.nodeName) {
+                case 'grant-uri-permission':
+                  provider.grantUriPermissions.push(this.collapseAttributes(element));
+                  break;
+                case 'meta-data':
+                  provider.metaData.push(this.collapseAttributes(element));
+                  break;
+                case 'path-permission':
+                  provider.pathPermissions.push(this.collapseAttributes(element));
+                  break;
+              }
+            });
+
+            app.providers.push(provider);
+            break;
+          }
+        case 'uses-library':
+          app.usesLibraries.push(this.collapseAttributes(element));
+          break;
+        case 'meta-data':
+          app.metaData.push(this.collapseAttributes(element));
+          break;
+      }
+    });
+
+    return app;
+  }
+
+  isLauncherActivity(activity) {
+    return activity.intentFilters.some(function (filter) {
+      const hasMain = filter.actions.some(action => action.name === INTENT_MAIN);
+      if (!hasMain) {
+        return false;
+      }
+      return filter.categories.some(category => category.name === CATEGORY_LAUNCHER);
+    });
+  }
+
+  parse() {
+    const document = this.xmlParser.parse();
+    const manifest = this.collapseAttributes(document);
+
+    manifest.usesPermissions = [];
+    manifest.usesPermissionsSDK23 = [];
+    manifest.permissions = [];
+    manifest.permissionTrees = [];
+    manifest.permissionGroups = [];
+    manifest.instrumentation = null;
+    manifest.usesSdk = null;
+    manifest.usesConfiguration = null;
+    manifest.usesFeatures = [];
+    manifest.supportsScreens = null;
+    manifest.compatibleScreens = [];
+    manifest.supportsGlTextures = [];
+    manifest.application = Object.create(null);
+
+    document.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'uses-permission':
+          manifest.usesPermissions.push(this.collapseAttributes(element));
+          break;
+        case 'uses-permission-sdk-23':
+          manifest.usesPermissionsSDK23.push(this.collapseAttributes(element));
+          break;
+        case 'permission':
+          manifest.permissions.push(this.collapseAttributes(element));
+          break;
+        case 'permission-tree':
+          manifest.permissionTrees.push(this.collapseAttributes(element));
+          break;
+        case 'permission-group':
+          manifest.permissionGroups.push(this.collapseAttributes(element));
+          break;
+        case 'instrumentation':
+          manifest.instrumentation = this.collapseAttributes(element);
+          break;
+        case 'uses-sdk':
+          manifest.usesSdk = this.collapseAttributes(element);
+          break;
+        case 'uses-configuration':
+          manifest.usesConfiguration = this.collapseAttributes(element);
+          break;
+        case 'uses-feature':
+          manifest.usesFeatures.push(this.collapseAttributes(element));
+          break;
+        case 'supports-screens':
+          manifest.supportsScreens = this.collapseAttributes(element);
+          break;
+        case 'compatible-screens':
+          element.childNodes.forEach(screen => {
+            return manifest.compatibleScreens.push(this.collapseAttributes(screen));
+          });
+          break;
+        case 'supports-gl-texture':
+          manifest.supportsGlTextures.push(this.collapseAttributes(element));
+          break;
+        case 'application':
+          manifest.application = this.parseApplication(element);
+          break;
+      }
+    });
+
+    return manifest;
+  }
+}
+
+module.exports = ManifestParser;

lib/utils/app-info-parser/zip.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const Unzip = require('isomorphic-unzip');
+const { isBrowser, decodeNullUnicode } = require('./utils');
+
+class Zip {
+  constructor(file) {
+    if (isBrowser()) {
+      if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
+        throw new Error('Param error: [file] must be an instance of Blob or File in browser.');
+      }
+      this.file = file;
+    } else {
+      if (typeof file !== 'string') {
+        throw new Error('Param error: [file] must be file path in Node.');
+      }
+      this.file = require('path').resolve(file);
+    }
+    this.unzip = new Unzip(this.file);
+  }
+
+  /**
+   * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+   * @param {Array} regexps // regexps for matching files
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */
+  getEntries(regexps, type = 'buffer') {
+    regexps = regexps.map(regex => decodeNullUnicode(regex));
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer(regexps, { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers);
+      });
+    });
+  }
+  /**
+   * get entry by regex, return an instance of Buffer or Blob
+   * @param {Regex} regex // regex for matching file
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */
+  getEntry(regex, type = 'buffer') {
+    regex = decodeNullUnicode(regex);
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer([regex], { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers[regex]);
+      });
+    });
+  }
+}
+
+module.exports = Zip;

lib/utils/index.js

@@ -0,0 +1,155 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pricingPageUrl = undefined;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+exports.question = question;
+exports.translateOptions = translateOptions;
+exports.getRNVersion = getRNVersion;
+exports.getApkInfo = getApkInfo;
+exports.getIpaInfo = getIpaInfo;
+exports.saveToLocal = saveToLocal;
+exports.printVersionCommand = printVersionCommand;
+
+var _fsExtra = require('fs-extra');
+
+var _fsExtra2 = _interopRequireDefault(_fsExtra);
+
+var _os = require('os');
+
+var _os2 = _interopRequireDefault(_os);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _package = require('../../package.json');
+
+var _package2 = _interopRequireDefault(_package);
+
+var _appInfoParser = require('./app-info-parser');
+
+var _appInfoParser2 = _interopRequireDefault(_appInfoParser);
+
+var _read = require('read');
+
+var _read2 = _interopRequireDefault(_read);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function question(query, password) {
+  if (NO_INTERACTIVE) {
+    return Promise.resolve('');
+  }
+  return new Promise((resolve, reject) => (0, _read2.default)({
+    prompt: query,
+    silent: password,
+    replace: password ? '*' : undefined
+  }, (err, result) => err ? reject(err) : resolve(result)));
+}
+
+function translateOptions(options) {
+  const ret = {};
+  for (let key in options) {
+    const v = options[key];
+    if (typeof v === 'string') {
+      ret[key] = v.replace(/\$\{(\w+)\}/g, function (v, n) {
+        return options[n] || process.env[n] || v;
+      });
+    } else {
+      ret[key] = v;
+    }
+  }
+  return ret;
+}
+
+function getRNVersion() {
+  const version = JSON.parse(_fsExtra2.default.readFileSync(require.resolve('react-native/package.json', {
+    paths: [process.cwd()]
+  }))).version;
+
+  // We only care about major and minor version.
+  const match = /^(\d+)\.(\d+)\./.exec(version);
+  return {
+    version,
+    major: match[1] | 0,
+    minor: match[2] | 0
+  };
+}
+
+async function getApkInfo(fn) {
+  const appInfoParser = new _appInfoParser2.default(fn);
+  const bundleFile = await appInfoParser.parser.getEntry(/assets\/index.android.bundle/);
+  if (!bundleFile) {
+    throw new Error('找不到bundle文件。请确保此apk为release版本，且bundle文件名为默认的index.android.bundle');
+  }
+  const updateJsonFile = await appInfoParser.parser.getEntry(/res\/raw\/update.json/);
+  let appCredential = {};
+  if (updateJsonFile) {
+    appCredential = JSON.parse(updateJsonFile.toString()).android;
+  }
+  const { versionName, application } = await appInfoParser.parse();
+  let buildTime = 0;
+  if (Array.isArray(application.metaData)) {
+    for (const meta of application.metaData) {
+      if (meta.name === 'pushy_build_time') {
+        buildTime = meta.value[0];
+      }
+    }
+  }
+  if (buildTime == 0) {
+    throw new Error('无法获取此包的编译时间戳。请更新react-native-update到最新版本后重新打包上传。');
+  }
+  return _extends({ versionName, buildTime }, appCredential);
+}
+
+async function getIpaInfo(fn) {
+  const appInfoParser = new _appInfoParser2.default(fn);
+  const bundleFile = await appInfoParser.parser.getEntry(/payload\/.+?\.app\/main.jsbundle/);
+  if (!bundleFile) {
+    throw new Error('找不到bundle文件。请确保此ipa为release版本，且bundle文件名为默认的main.jsbundle');
+  }
+  const updateJsonFile = await appInfoParser.parser.getEntry(/payload\/.+?\.app\/assets\/update.json/);
+  let appCredential = {};
+  if (updateJsonFile) {
+    appCredential = JSON.parse(updateJsonFile.toString()).ios;
+  }
+  const { CFBundleShortVersionString: versionName } = await appInfoParser.parse();
+  let buildTimeTxtBuffer = await appInfoParser.parser.getEntry(/payload\/.+?\.app\/pushy_build_time.txt/);
+  if (!buildTimeTxtBuffer) {
+    // Not in root bundle when use `use_frameworks`
+    buildTimeTxtBuffer = await appInfoParser.parser.getEntry(/payload\/.+?\.app\/frameworks\/react_native_update.framework\/pushy_build_time.txt/);
+  }
+  if (!buildTimeTxtBuffer) {
+    throw new Error('无法获取此包的编译时间戳。请更新react-native-update到最新版本后重新打包上传。');
+  }
+  const buildTime = buildTimeTxtBuffer.toString().replace('\n', '');
+  return _extends({ versionName, buildTime }, appCredential);
+}
+
+const localDir = _path2.default.resolve(_os2.default.homedir(), '.pushy');
+_fsExtra2.default.ensureDirSync(localDir);
+function saveToLocal(originPath, destName) {
+  // TODO
+  // const destPath = path.join(localDir, destName);
+  // fs.ensureDirSync(path.dirname(destPath));
+  // fs.copyFileSync(originPath, destPath);
+}
+
+function printVersionCommand() {
+  console.log('react-native-update-cli: ' + _package2.default.version);
+  try {
+    const PACKAGE_JSON_PATH = require.resolve('react-native-update/package.json', {
+      paths: [process.cwd()]
+    });
+    console.log('react-native-update: ' + require(PACKAGE_JSON_PATH).version);
+  } catch (e) {
+    console.log('react-native-update: 无法获取版本号，请在项目目录中运行命令');
+  }
+}
+
+const pricingPageUrl = exports.pricingPageUrl = 'https://pushy.reactnative.cn/pricing.html';

lib/versions.js

@@ -0,0 +1,193 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commands = undefined;
+
+var _api = require('./api');
+
+var _utils = require('./utils');
+
+var _app = require('./app');
+
+var _package = require('./package');
+
+var _compareVersions = require('compare-versions');
+
+async function showVersion(appId, offset) {
+  const { data, count } = await (0, _api.get)(`/app/${appId}/version/list`);
+  console.log(`Offset ${offset}`);
+  for (const version of data) {
+    let packageInfo = version.packages.slice(0, 3).map(v => v.name).join(', ');
+    const count = version.packages.length;
+    if (count > 3) {
+      packageInfo += `...and ${count - 3} more`;
+    }
+    if (count === 0) {
+      packageInfo = `(no package)`;
+    } else {
+      packageInfo = `[${packageInfo}]`;
+    }
+    console.log(`${version.id}) ${version.hash.slice(0, 8)} ${version.name} ${packageInfo}`);
+  }
+  return data;
+}
+
+async function listVersions(appId) {
+  let offset = 0;
+  while (true) {
+    await showVersion(appId, offset);
+    const cmd = await (0, _utils.question)('page Up/page Down/Begin/Quit(U/D/B/Q)');
+    switch (cmd.toLowerCase()) {
+      case 'u':
+        offset = Math.max(0, offset - 10);
+        break;
+      case 'd':
+        offset += 10;
+        break;
+      case 'b':
+        offset = 0;
+        break;
+      case 'q':
+        return;
+    }
+  }
+}
+
+async function chooseVersion(appId) {
+  let offset = 0;
+  while (true) {
+    const data = await showVersion(appId, offset);
+    const cmd = await (0, _utils.question)('Enter versionId or page Up/page Down/Begin(U/D/B)');
+    switch (cmd.toLowerCase()) {
+      case 'U':
+        offset = Math.max(0, offset - 10);
+        break;
+      case 'D':
+        offset += 10;
+        break;
+      case 'B':
+        offset = 0;
+        break;
+      default:
+        {
+          const v = data.find(v => v.id === (cmd | 0));
+          if (v) {
+            return v;
+          }
+        }
+    }
+  }
+}
+
+const commands = exports.commands = {
+  publish: async function ({ args, options }) {
+    const fn = args[0];
+    const { name, description, metaInfo } = options;
+
+    if (!fn || !fn.endsWith('.ppk')) {
+      throw new Error('使用方法: pushy publish ppk后缀文件 --platform ios|android');
+    }
+
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { appId } = await (0, _app.getSelectedApp)(platform);
+
+    const { hash } = await (0, _api.uploadFile)(fn);
+
+    const { id } = await (0, _api.post)(`/app/${appId}/version/create`, {
+      name: name || (await (0, _utils.question)('输入版本名称: ')) || '(未命名)',
+      hash,
+      description: description || (await (0, _utils.question)('输入版本描述:')),
+      metaInfo: metaInfo || (await (0, _utils.question)('输入自定义的 meta info:'))
+    });
+    // TODO local diff
+    (0, _utils.saveToLocal)(fn, `${appId}/ppk/${id}.ppk`);
+    console.log(`已成功上传新热更包（id: ${id}）`);
+
+    const v = await (0, _utils.question)('是否现在将此热更应用到原生包上？(Y/N)');
+    if (v.toLowerCase() === 'y') {
+      await this.update({ args: [], options: { versionId: id, platform } });
+    }
+  },
+  versions: async function ({ options }) {
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { appId } = await (0, _app.getSelectedApp)(platform);
+    await listVersions(appId);
+  },
+  update: async function ({ args, options }) {
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { appId } = await (0, _app.getSelectedApp)(platform);
+    const versionId = options.versionId || (await chooseVersion(appId)).id;
+
+    let pkgId;
+    let pkgVersion = options.packageVersion;
+    let minPkgVersion = options.minPackageVersion;
+    let maxPkgVersion = options.maxPackageVersion;
+    if (pkgVersion) {
+      pkgVersion = pkgVersion.trim();
+      const { data } = await (0, _api.get)(`/app/${appId}/package/list?limit=1000`);
+      const pkg = data.find(d => d.name === pkgVersion);
+      if (pkg) {
+        pkgId = pkg.id;
+      } else {
+        throw new Error(`未查询到匹配原生版本：${pkgVersion}`);
+      }
+    }
+    if (minPkgVersion) {
+      minPkgVersion = String(minPkgVersion).trim();
+      const { data } = await (0, _api.get)(`/app/${appId}/package/list?limit=1000`);
+      const pkgs = data.filter(d => (0, _compareVersions.compare)(d.name, minPkgVersion, '>='));
+      if (pkgs.length === 0) {
+        throw new Error(`未查询到 >= ${minPkgVersion} 的原生版本`);
+      }
+      for (const pkg of pkgs) {
+        await (0, _api.put)(`/app/${appId}/package/${pkg.id}`, {
+          versionId
+        });
+        console.log(`已将版本 ${versionId} 绑定到原生版本 ${pkg.name}`);
+      }
+      console.log(`操作完成，共已绑定 ${pkgs.length} 个原生版本`);
+      return;
+    }
+    if (maxPkgVersion) {
+      maxPkgVersion = String(maxPkgVersion).trim();
+      const { data } = await (0, _api.get)(`/app/${appId}/package/list?limit=1000`);
+      const pkgs = data.filter(d => (0, _compareVersions.compare)(d.name, maxPkgVersion, '<='));
+      if (pkgs.length === 0) {
+        throw new Error(`未查询到 <= ${maxPkgVersion} 的原生版本`);
+      }
+      for (const pkg of pkgs) {
+        await (0, _api.put)(`/app/${appId}/package/${pkg.id}`, {
+          versionId
+        });
+        console.log(`已将版本 ${versionId} 绑定到原生版本 ${pkg.name}`);
+      }
+      console.log(`操作完成，共已绑定 ${pkgs.length} 个原生版本`);
+      return;
+    }
+    if (!pkgId) {
+      pkgId = options.packageId || (await (0, _package.choosePackage)(appId)).id;
+    }
+
+    if (!pkgId) {
+      throw new Error('请提供 packageId 或 packageVersion 参数');
+    }
+    await (0, _api.put)(`/app/${appId}/package/${pkgId}`, {
+      versionId
+    });
+    console.log('操作成功');
+  },
+  updateVersionInfo: async function ({ args, options }) {
+    const platform = (0, _app.checkPlatform)(options.platform || (await (0, _utils.question)('平台(ios/android):')));
+    const { appId } = await (0, _app.getSelectedApp)(platform);
+    const versionId = options.versionId || (await chooseVersion(appId)).id;
+
+    const updateParams = {};
+    options.name && (updateParams.name = options.name);
+    options.description && (updateParams.description = options.description);
+    options.metaInfo && (updateParams.metaInfo = options.metaInfo);
+    await (0, _api.put)(`/app/${appId}/version/${versionId}`, updateParams);
+    console.log('操作成功');
+  }
+};

package.json

@@ -0,0 +1,66 @@
+{
+  "name": "react-native-update-cli",
+  "version": "1.27.0",
+  "description": "Command tools for javaScript updater with `pushy` service for react native apps.",
+  "main": "index.js",
+  "bin": {
+    "pushy": "lib/index.js"
+  },
+  "files": [
+    "lib",
+    "src",
+    "cli.json"
+  ],
+  "scripts": {
+    "prepublish": "babel src --out-dir lib && chmod +x lib/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reactnativecn/react-native-pushy-cli.git"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "update"
+  ],
+  "author": "reactnativecn",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/reactnativecn/react-native-pushy/issues"
+  },
+  "homepage": "https://github.com/reactnativecn/react-native-pushy/tree/master/react-native-pushy-cli",
+  "dependencies": {
+    "bplist-parser": "^0.2.0",
+    "bytebuffer": "^5.0.1",
+    "cgbi-to-png": "^1.0.7",
+    "cli-arguments": "^0.2.1",
+    "commander": "^7.2.0",
+    "compare-versions": "^6.1.1",
+    "filesize-parser": "^1.5.0",
+    "fs-extra": "8",
+    "gradle-to-js": "^2.0.1",
+    "isomorphic-unzip": "^1.1.5",
+    "node-fetch": "^2.6.1",
+    "plist": "^3.0.1",
+    "progress": "^2.0.3",
+    "properties": "^1.2.1",
+    "read": "^1.0.7",
+    "request": "^2.88.2",
+    "tcp-ping": "^0.1.1",
+    "tty-table": "4.2",
+    "update-notifier": "^5.1.0",
+    "yauzl": "^2.10.0",
+    "yazl": "2.5.1"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-plugin-syntax-object-rest-spread": "^6.13.0",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+    "babel-plugin-transform-es2015-spread": "^6.22.0",
+    "babel-plugin-transform-object-rest-spread": "^6.26.0"
+  },
+  "engines": {
+    "node": ">= 10"
+  }
+}

src/api.js

@@ -0,0 +1,177 @@
+import fetch from 'node-fetch';
+const defaultEndpoint = 'https://update.reactnative.cn/api';
+let host = process.env.PUSHY_REGISTRY || defaultEndpoint;
+import fs from 'fs';
+import request from 'request';
+import ProgressBar from 'progress';
+import packageJson from '../package.json';
+import tcpp from 'tcp-ping';
+import util from 'util';
+import path from 'path';
+import filesizeParser from 'filesize-parser';
+import { pricingPageUrl } from './utils';
+
+const tcpPing = util.promisify(tcpp.ping);
+
+let session = undefined;
+let savedSession = undefined;
+
+const userAgent = `react-native-update-cli/${packageJson.version}`;
+
+export const getSession = function () {
+  return session;
+};
+
+export const replaceSession = function (newSession) {
+  session = newSession;
+};
+
+export const loadSession = async function () {
+  if (fs.existsSync('.update')) {
+    try {
+      replaceSession(JSON.parse(fs.readFileSync('.update', 'utf8')));
+      savedSession = session;
+    } catch (e) {
+      console.error(
+        'Failed to parse file `.update`. Try to remove it manually.',
+      );
+      throw e;
+    }
+  }
+};
+
+export const saveSession = function () {
+  // Only save on change.
+  if (session !== savedSession) {
+    const current = session;
+    const data = JSON.stringify(current, null, 4);
+    fs.writeFileSync('.update', data, 'utf8');
+    savedSession = current;
+  }
+};
+
+export const closeSession = function () {
+  if (fs.existsSync('.update')) {
+    fs.unlinkSync('.update');
+    savedSession = undefined;
+  }
+  session = undefined;
+  host = process.env.PUSHY_REGISTRY || defaultEndpoint;
+};
+
+async function query(url, options) {
+  const resp = await fetch(url, options);
+  const text = await resp.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Server error: ${text}`);
+  }
+
+  if (resp.status !== 200) {
+    throw Object.assign(new Error(json.message || json.error), {
+      status: resp.status,
+    });
+  }
+  return json;
+}
+
+function queryWithoutBody(method) {
+  return function (api) {
+    return query(host + api, {
+      method,
+      headers: {
+        'User-Agent': userAgent,
+        'X-AccessToken': session ? session.token : '',
+      },
+    });
+  };
+}
+
+function queryWithBody(method) {
+  return function (api, body) {
+    return query(host + api, {
+      method,
+      headers: {
+        'User-Agent': userAgent,
+        'Content-Type': 'application/json',
+        'X-AccessToken': session ? session.token : '',
+      },
+      body: JSON.stringify(body),
+    });
+  };
+}
+
+export const get = queryWithoutBody('GET');
+export const post = queryWithBody('POST');
+export const put = queryWithBody('PUT');
+export const doDelete = queryWithBody('DELETE');
+
+export async function uploadFile(fn, key) {
+  const { url, backupUrl, formData, maxSize } = await post('/upload', {
+    ext: path.extname(fn),
+  });
+  let realUrl = url;
+
+  if (backupUrl) {
+    if (global.USE_ACC_OSS) {
+      realUrl = backupUrl;
+    } else {
+      const pingResult = await tcpPing({
+        address: url.replace('https://', ''),
+        attempts: 4,
+        timeout: 1000,
+      });
+      // console.log({pingResult});
+      if (isNaN(pingResult.avg) || pingResult.avg > 150) {
+        realUrl = backupUrl;
+      }
+    }
+    // console.log({realUrl});
+  }
+
+  const fileSize = fs.statSync(fn).size;
+  if (maxSize && fileSize > filesizeParser(maxSize)) {
+    throw new Error(
+      `此文件大小${(fileSize / 1048576).toFixed(
+        1,
+      )}m, 超出当前额度${maxSize}。您可以考虑升级付费业务以提升此额度。详情请访问: ${pricingPageUrl}`,
+    );
+  }
+
+  const bar = new ProgressBar('  上传中 [:bar] :percent :etas', {
+    complete: '=',
+    incomplete: ' ',
+    total: fileSize,
+  });
+
+  const info = await new Promise((resolve, reject) => {
+    if (key) {
+      formData.key = key;
+    }
+    formData.file = fs.createReadStream(fn);
+
+    formData.file.on('data', function (data) {
+      bar.tick(data.length);
+    });
+    request.post(
+      realUrl,
+      {
+        formData,
+      },
+      (err, resp, body) => {
+        if (err) {
+          return reject(err);
+        }
+        if (resp.statusCode > 299) {
+          return reject(
+            Object.assign(new Error(body), { status: resp.statusCode }),
+          );
+        }
+        resolve({ hash: formData.key });
+      },
+    );
+  });
+  return info;
+}

src/app.js

@@ -0,0 +1,127 @@
+import { question } from './utils';
+import fs from 'fs';
+import Table from 'tty-table';
+
+import { post, get, doDelete } from './api';
+
+const validPlatforms = {
+  ios: 1,
+  android: 1,
+};
+
+export function checkPlatform(platform) {
+  if (!validPlatforms[platform]) {
+    throw new Error(`无法识别的平台 '${platform}'`);
+  }
+  return platform;
+}
+
+export function getSelectedApp(platform) {
+  checkPlatform(platform);
+
+  if (!fs.existsSync('update.json')) {
+    throw new Error(
+      `App not selected. run 'pushy selectApp --platform ${platform}' first!`,
+    );
+  }
+  const updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
+  if (!updateInfo[platform]) {
+    throw new Error(
+      `App not selected. run 'pushy selectApp --platform ${platform}' first!`,
+    );
+  }
+  return updateInfo[platform];
+}
+
+export async function listApp(platform) {
+  const { data } = await get('/app/list');
+  const list = platform ? data.filter((v) => v.platform === platform) : data;
+
+  const header = [
+    { value: '应用 id' },
+    { value: '应用名称' },
+    { value: '平台' },
+  ];
+  const rows = [];
+  for (const app of list) {
+    rows.push([app.id, app.name, app.platform]);
+  }
+
+  console.log(Table(header, rows).render());
+
+  if (platform) {
+    console.log(`\共 ${list.length} ${platform} 个应用`);
+  } else {
+    console.log(`\共 ${list.length} 个应用`);
+  }
+  return list;
+}
+
+export async function chooseApp(platform) {
+  const list = await listApp(platform);
+
+  while (true) {
+    const id = await question('输入应用 id:');
+    const app = list.find((v) => v.id === (id | 0));
+    if (app) {
+      return app;
+    }
+  }
+}
+
+export const commands = {
+  createApp: async function ({ options }) {
+    const name = options.name || (await question('应用名称:'));
+    const { downloadUrl } = options;
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { id } = await post('/app/create', { name, platform });
+    console.log(`已成功创建应用（id: ${id}）`);
+    await this.selectApp({
+      args: [id],
+      options: { platform, downloadUrl },
+    });
+  },
+  deleteApp: async function ({ args, options }) {
+    const { platform } = options;
+    const id = args[0] || chooseApp(platform);
+    if (!id) {
+      console.log('已取消');
+    }
+    await doDelete(`/app/${id}`);
+    console.log('操作成功');
+  },
+  apps: async function ({ options }) {
+    const { platform } = options;
+    listApp(platform);
+  },
+  selectApp: async function ({ args, options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const id = args[0] ? parseInt(args[0]) : (await chooseApp(platform)).id;
+
+    let updateInfo = {};
+    if (fs.existsSync('update.json')) {
+      try {
+        updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
+      } catch (e) {
+        console.error(
+          'Failed to parse file `update.json`. Try to remove it manually.',
+        );
+        throw e;
+      }
+    }
+    const { appKey } = await get(`/app/${id}`);
+    updateInfo[platform] = {
+      appId: id,
+      appKey,
+    };
+    fs.writeFileSync(
+      'update.json',
+      JSON.stringify(updateInfo, null, 4),
+      'utf8',
+    );
+  },
+};

src/bundle.js

@@ -0,0 +1,700 @@
+import path from 'path';
+import { getRNVersion, translateOptions } from './utils';
+import * as fs from 'fs-extra';
+import { ZipFile } from 'yazl';
+import { open as openZipFile } from 'yauzl';
+import { question, printVersionCommand } from './utils';
+import { checkPlatform } from './app';
+import { spawn, spawnSync } from 'child_process';
+const g2js = require('gradle-to-js/lib/parser');
+import os from 'os';
+const properties = require('properties');
+
+let bsdiff, hdiff, diff;
+try {
+  bsdiff = require('node-bsdiff').diff;
+} catch (e) {}
+
+try {
+  hdiff = require('node-hdiffpatch').diff;
+} catch (e) {}
+
+async function runReactNativeBundleCommand(
+  bundleName,
+  development,
+  entryFile,
+  outputFolder,
+  platform,
+  sourcemapOutput,
+  config,
+) {
+  let gradleConfig = {};
+  if (platform === 'android') {
+    gradleConfig = await checkGradleConfig();
+    if (gradleConfig.crunchPngs !== false) {
+      console.warn(
+        'android的crunchPngs选项似乎尚未禁用（如已禁用则请忽略此提示），这可能导致热更包体积异常增大，具体请参考 https://pushy.reactnative.cn/docs/getting-started.html#%E7%A6%81%E7%94%A8-android-%E7%9A%84-crunch-%E4%BC%98%E5%8C%96 \n',
+      );
+    }
+  }
+
+  let reactNativeBundleArgs = [];
+
+  let envArgs = process.env.PUSHY_ENV_ARGS;
+
+  if (envArgs) {
+    Array.prototype.push.apply(
+      reactNativeBundleArgs,
+      envArgs.trim().split(/\s+/),
+    );
+  }
+
+  fs.emptyDirSync(outputFolder);
+
+  let cliPath = require.resolve('react-native/local-cli/cli.js', {
+    paths: [process.cwd()],
+  });
+  try {
+    require.resolve('expo-router', {
+      paths: [process.cwd()],
+    });
+
+    console.log(`expo-router detected, will use @expo/cli to bundle.\n`);
+    // if using expo-router, use expo-cli
+    cliPath = require.resolve('@expo/cli', {
+      paths: [process.cwd()],
+    });
+  } catch (e) {}
+  const bundleCommand = cliPath.includes('@expo/cli')
+    ? 'export:embed'
+    : 'bundle';
+
+  Array.prototype.push.apply(reactNativeBundleArgs, [
+    cliPath,
+    bundleCommand,
+    '--assets-dest',
+    outputFolder,
+    '--bundle-output',
+    path.join(outputFolder, bundleName),
+    '--dev',
+    development,
+    '--entry-file',
+    entryFile,
+    '--platform',
+    platform,
+    '--reset-cache',
+  ]);
+
+  if (sourcemapOutput) {
+    reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
+  }
+
+  if (config) {
+    reactNativeBundleArgs.push('--config', config);
+  }
+
+  const reactNativeBundleProcess = spawn('node', reactNativeBundleArgs);
+  console.log(
+    `Running bundle command: node ${reactNativeBundleArgs.join(' ')}`,
+  );
+
+  return new Promise((resolve, reject) => {
+    reactNativeBundleProcess.stdout.on('data', (data) => {
+      console.log(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.stderr.on('data', (data) => {
+      console.error(data.toString().trim());
+    });
+
+    reactNativeBundleProcess.on('close', async (exitCode) => {
+      if (exitCode) {
+        reject(
+          new Error(
+            `"react-native bundle" command exited with code ${exitCode}.`,
+          ),
+        );
+      } else {
+        let hermesEnabled = false;
+
+        if (platform === 'android') {
+          const gradlePropeties = await new Promise((resolve) => {
+            properties.parse(
+              './android/gradle.properties',
+              { path: true },
+              function (error, props) {
+                if (error) {
+                  console.error(error);
+                  resolve(null);
+                }
+
+                resolve(props);
+              },
+            );
+          });
+          hermesEnabled = gradlePropeties.hermesEnabled;
+
+          if (typeof hermesEnabled !== 'boolean')
+            hermesEnabled = gradleConfig.enableHermes;
+        } else if (
+          platform === 'ios' &&
+          fs.existsSync('ios/Pods/hermes-engine')
+        ) {
+          hermesEnabled = true;
+        }
+        if (hermesEnabled) {
+          await compileHermesByteCode(
+            bundleName,
+            outputFolder,
+            sourcemapOutput,
+          );
+        }
+        resolve(null);
+      }
+    });
+  });
+}
+
+function getHermesOSBin() {
+  if (os.platform() === 'win32') return 'win64-bin';
+  if (os.platform() === 'darwin') return 'osx-bin';
+  if (os.platform() === 'linux') return 'linux64-bin';
+}
+
+async function checkGradleConfig() {
+  let enableHermes = false;
+  let crunchPngs;
+  try {
+    const gradleConfig = await g2js.parseFile('android/app/build.gradle');
+    const projectConfig = gradleConfig['project.ext.react'];
+    for (const packagerConfig of projectConfig) {
+      if (
+        packagerConfig.includes('enableHermes') &&
+        packagerConfig.includes('true')
+      ) {
+        enableHermes = true;
+        break;
+      }
+    }
+    crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
+  } catch (e) {}
+  return {
+    enableHermes,
+    crunchPngs,
+  };
+}
+
+async function compileHermesByteCode(
+  bundleName,
+  outputFolder,
+  sourcemapOutput,
+) {
+  console.log(`Hermes enabled, now compiling to hermes bytecode:\n`);
+  // >= rn 0.69
+  const rnDir = path.dirname(
+    require.resolve('react-native', {
+      paths: [process.cwd()],
+    }),
+  );
+  let hermesPath = path.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
+
+  // < rn 0.69
+  if (!fs.existsSync(hermesPath)) {
+    hermesPath = `node_modules/hermes-engine/${getHermesOSBin()}`;
+  }
+
+  const hermesCommand = `${hermesPath}/hermesc`;
+  
+  const args = [
+    '-emit-binary',
+    '-out',
+    path.join(outputFolder, bundleName),
+    path.join(outputFolder, bundleName),
+    '-O',
+  ];
+  if (sourcemapOutput) {
+    args.push('-output-source-map');
+  }
+  console.log(
+    'Running hermesc: ' + hermesCommand + ' ' + args.join(' ') + '\n',
+  );
+  spawnSync(hermesCommand, args, {
+    stdio: 'ignore',
+  });
+}
+
+async function pack(dir, output) {
+  console.log('Packing');
+  fs.ensureDirSync(path.dirname(output));
+  await new Promise((resolve, reject) => {
+    const zipfile = new ZipFile();
+
+    function addDirectory(root, rel) {
+      if (rel) {
+        zipfile.addEmptyDirectory(rel);
+      }
+      const childs = fs.readdirSync(root);
+      for (const name of childs) {
+        if (name === '.' || name === '..' || name === 'index.bundlejs.map') {
+          continue;
+        }
+        const fullPath = path.join(root, name);
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile()) {
+          //console.log('adding: ' + rel+name);
+          zipfile.addFile(fullPath, rel + name);
+        } else if (stat.isDirectory()) {
+          //console.log('adding: ' + rel+name+'/');
+          addDirectory(fullPath, rel + name + '/');
+        }
+      }
+    }
+
+    addDirectory(dir, '');
+
+    zipfile.outputStream.on('error', (err) => reject(err));
+    zipfile.outputStream
+      .pipe(fs.createWriteStream(output))
+      .on('close', function () {
+        resolve();
+      });
+    zipfile.end();
+  });
+  console.log('ppk热更包已生成并保存到: ' + output);
+}
+
+function readEntire(entry, zipFile) {
+  const buffers = [];
+  return new Promise((resolve, reject) => {
+    zipFile.openReadStream(entry, (err, stream) => {
+      stream.pipe({
+        write(chunk) {
+          buffers.push(chunk);
+        },
+        end() {
+          resolve(Buffer.concat(buffers));
+        },
+        prependListener() {},
+        on() {},
+        once() {},
+        emit() {},
+      });
+    });
+  });
+}
+
+function basename(fn) {
+  const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
+  return m && m[1];
+}
+
+async function diffFromPPK(origin, next, output) {
+  fs.ensureDirSync(path.dirname(output));
+
+  const originEntries = {};
+  const originMap = {};
+
+  let originSource;
+
+  await enumZipEntries(origin, (entry, zipFile) => {
+    originEntries[entry.fileName] = entry;
+    if (!/\/$/.test(entry.fileName)) {
+      // isFile
+      originMap[entry.crc32] = entry.fileName;
+
+      if (entry.fileName === 'index.bundlejs') {
+        // This is source.
+        return readEntire(entry, zipFile).then((v) => (originSource = v));
+      }
+    }
+  });
+
+  if (!originSource) {
+    throw new Error(
+      `Bundle file not found! Please use default bundle file name and path.`,
+    );
+  }
+
+  const copies = {};
+
+  const zipfile = new ZipFile();
+
+  const writePromise = new Promise((resolve, reject) => {
+    zipfile.outputStream.on('error', (err) => {
+      throw err;
+    });
+    zipfile.outputStream
+      .pipe(fs.createWriteStream(output))
+      .on('close', function () {
+        resolve();
+      });
+  });
+
+  const addedEntry = {};
+
+  function addEntry(fn) {
+    //console.log(fn);
+    if (!fn || addedEntry[fn]) {
+      return;
+    }
+    const base = basename(fn);
+    if (base) {
+      addEntry(base);
+    }
+    zipfile.addEmptyDirectory(fn);
+  }
+
+  const newEntries = {};
+
+  await enumZipEntries(next, (entry, nextZipfile) => {
+    newEntries[entry.fileName] = entry;
+
+    if (/\/$/.test(entry.fileName)) {
+      // Directory
+      if (!originEntries[entry.fileName]) {
+        addEntry(entry.fileName);
+      }
+    } else if (entry.fileName === 'index.bundlejs') {
+      //console.log('Found bundle');
+      return readEntire(entry, nextZipfile).then((newSource) => {
+        //console.log('Begin diff');
+        zipfile.addBuffer(
+          diff(originSource, newSource),
+          'index.bundlejs.patch',
+        );
+        //console.log('End diff');
+      });
+    } else {
+      // If same file.
+      const originEntry = originEntries[entry.fileName];
+      if (originEntry && originEntry.crc32 === entry.crc32) {
+        // ignore
+        return;
+      }
+
+      // If moved from other place
+      if (originMap[entry.crc32]) {
+        const base = basename(entry.fileName);
+        if (!originEntries[base]) {
+          addEntry(base);
+        }
+        copies[entry.fileName] = originMap[entry.crc32];
+        return;
+      }
+
+      // New file.
+      addEntry(basename(entry.fileName));
+
+      return new Promise((resolve, reject) => {
+        nextZipfile.openReadStream(entry, function (err, readStream) {
+          if (err) {
+            return reject(err);
+          }
+          zipfile.addReadStream(readStream, entry.fileName);
+          readStream.on('end', () => {
+            //console.log('add finished');
+            resolve();
+          });
+        });
+      });
+    }
+  });
+
+  const deletes = {};
+
+  for (let k in originEntries) {
+    if (!newEntries[k]) {
+      console.log('Delete ' + k);
+      deletes[k] = 1;
+    }
+  }
+
+  //console.log({copies, deletes});
+  zipfile.addBuffer(
+    Buffer.from(JSON.stringify({ copies, deletes })),
+    '__diff.json',
+  );
+  zipfile.end();
+  await writePromise;
+}
+
+async function diffFromPackage(
+  origin,
+  next,
+  output,
+  originBundleName,
+  transformPackagePath = (v) => v,
+) {
+  fs.ensureDirSync(path.dirname(output));
+
+  const originEntries = {};
+  const originMap = {};
+
+  let originSource;
+
+  await enumZipEntries(origin, (entry, zipFile) => {
+    if (!/\/$/.test(entry.fileName)) {
+      const fn = transformPackagePath(entry.fileName);
+      if (!fn) {
+        return;
+      }
+
+      //console.log(fn);
+      // isFile
+      originEntries[fn] = entry.crc32;
+      originMap[entry.crc32] = fn;
+
+      if (fn === originBundleName) {
+        // This is source.
+        return readEntire(entry, zipFile).then((v) => (originSource = v));
+      }
+    }
+  });
+
+  if (!originSource) {
+    throw new Error(
+      `Bundle file not found! Please use default bundle file name and path.`,
+    );
+  }
+
+  const copies = {};
+
+  const zipfile = new ZipFile();
+
+  const writePromise = new Promise((resolve, reject) => {
+    zipfile.outputStream.on('error', (err) => {
+      throw err;
+    });
+    zipfile.outputStream
+      .pipe(fs.createWriteStream(output))
+      .on('close', function () {
+        resolve();
+      });
+  });
+
+  await enumZipEntries(next, (entry, nextZipfile) => {
+    if (/\/$/.test(entry.fileName)) {
+      // Directory
+      zipfile.addEmptyDirectory(entry.fileName);
+    } else if (entry.fileName === 'index.bundlejs') {
+      //console.log('Found bundle');
+      return readEntire(entry, nextZipfile).then((newSource) => {
+        //console.log('Begin diff');
+        zipfile.addBuffer(
+          diff(originSource, newSource),
+          'index.bundlejs.patch',
+        );
+        //console.log('End diff');
+      });
+    } else {
+      // If same file.
+      if (originEntries[entry.fileName] === entry.crc32) {
+        copies[entry.fileName] = '';
+        return;
+      }
+      // If moved from other place
+      if (originMap[entry.crc32]) {
+        copies[entry.fileName] = originMap[entry.crc32];
+        return;
+      }
+
+      return new Promise((resolve, reject) => {
+        nextZipfile.openReadStream(entry, function (err, readStream) {
+          if (err) {
+            return reject(err);
+          }
+          zipfile.addReadStream(readStream, entry.fileName);
+          readStream.on('end', () => {
+            //console.log('add finished');
+            resolve();
+          });
+        });
+      });
+    }
+  });
+
+  zipfile.addBuffer(Buffer.from(JSON.stringify({ copies })), '__diff.json');
+  zipfile.end();
+  await writePromise;
+}
+
+function enumZipEntries(zipFn, callback) {
+  return new Promise((resolve, reject) => {
+    openZipFile(zipFn, { lazyEntries: true }, (err, zipfile) => {
+      if (err) {
+        return reject(err);
+      }
+      zipfile.on('end', resolve);
+      zipfile.on('error', reject);
+      zipfile.on('entry', (entry) => {
+        const result = callback(entry, zipfile);
+        if (result && typeof result.then === 'function') {
+          result.then(() => zipfile.readEntry());
+        } else {
+          zipfile.readEntry();
+        }
+      });
+      zipfile.readEntry();
+    });
+  });
+}
+
+function diffArgsCheck(args, options, diffFn) {
+  const [origin, next] = args;
+
+  if (!origin || !next) {
+    console.error(`Usage: pushy ${diffFn} <origin> <next>`);
+    process.exit(1);
+  }
+
+  if (diffFn.startsWith('hdiff')) {
+    if (!hdiff) {
+      console.error(
+        `This function needs "node-hdiffpatch". 
+        Please run "npm i node-hdiffpatch" to install`,
+      );
+      process.exit(1);
+    }
+    diff = hdiff;
+  } else {
+    if (!bsdiff) {
+      console.error(
+        `This function needs "node-bsdiff". 
+        Please run "npm i node-bsdiff" to install`,
+      );
+      process.exit(1);
+    }
+    diff = bsdiff;
+  }
+  const { output } = options;
+
+  return {
+    origin,
+    next,
+    realOutput: output.replace(/\$\{time\}/g, '' + Date.now()),
+  };
+}
+
+export const commands = {
+  bundle: async function ({ options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+
+    let { bundleName, entryFile, intermediaDir, output, dev, sourcemap } =
+      translateOptions({
+        ...options,
+        platform,
+      });
+
+    const sourcemapOutput = path.join(intermediaDir, bundleName + '.map');
+
+    const realOutput = output.replace(/\$\{time\}/g, '' + Date.now());
+
+    if (!platform) {
+      throw new Error('Platform must be specified.');
+    }
+
+    const { version, major, minor } = getRNVersion();
+
+    console.log('Bundling with react-native: ', version);
+    printVersionCommand();
+
+    await runReactNativeBundleCommand(
+      bundleName,
+      dev,
+      entryFile,
+      intermediaDir,
+      platform,
+      sourcemap ? sourcemapOutput : '',
+    );
+
+    await pack(path.resolve(intermediaDir), realOutput);
+
+    const v = await question('是否现在上传此热更包?(Y/N)');
+    if (v.toLowerCase() === 'y') {
+      await this.publish({
+        args: [realOutput],
+        options: {
+          platform,
+        },
+      });
+    }
+  },
+
+  async diff({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'diff');
+
+    await diffFromPPK(origin, next, realOutput, 'index.bundlejs');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiff({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiff');
+
+    await diffFromPPK(origin, next, realOutput, 'index.bundlejs');
+    console.log(`${realOutput} generated.`);
+  },
+
+  async diffFromApk({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(
+      args,
+      options,
+      'diffFromApk',
+    );
+
+    await diffFromPackage(
+      origin,
+      next,
+      realOutput,
+      'assets/index.android.bundle',
+    );
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiffFromApk({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(
+      args,
+      options,
+      'hdiffFromApk',
+    );
+
+    await diffFromPackage(
+      origin,
+      next,
+      realOutput,
+      'assets/index.android.bundle',
+    );
+    console.log(`${realOutput} generated.`);
+  },
+
+  async diffFromIpa({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(
+      args,
+      options,
+      'diffFromIpa',
+    );
+
+    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v) => {
+      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+      return m && m[1];
+    });
+
+    console.log(`${realOutput} generated.`);
+  },
+
+  async hdiffFromIpa({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(
+      args,
+      options,
+      'hdiffFromIpa',
+    );
+
+    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v) => {
+      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
+      return m && m[1];
+    });
+
+    console.log(`${realOutput} generated.`);
+  },
+};

src/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { loadSession } from './api';
+import updateNotifier from 'update-notifier';
+import { printVersionCommand } from './utils/index.js';
+import pkg from '../package.json';
+
+updateNotifier({ pkg }).notify({ isGlobal: true });
+
+function printUsage({ args }) {
+  // const commandName = args[0];
+  // TODO: print usage of commandName, or print global usage.
+
+  console.log('Usage is under development now.');
+  console.log(
+    'Visit `https://github.com/reactnativecn/react-native-pushy` for early document.',
+  );
+  process.exit(1);
+}
+
+const commands = {
+  ...require('./user').commands,
+  ...require('./bundle').commands,
+  ...require('./app').commands,
+  ...require('./package').commands,
+  ...require('./versions').commands,
+  help: printUsage,
+};
+
+function run() {
+  if (process.argv.indexOf('-v') >= 0 || process.argv[2] === 'version') {
+    printVersionCommand();
+    process.exit();
+  }
+
+  const argv = require('cli-arguments').parse(require('../cli.json'));
+  global.NO_INTERACTIVE = argv.options['no-interactive'];
+  global.USE_ACC_OSS = argv.options['acc'];
+
+  loadSession()
+    .then(() => commands[argv.command](argv))
+    .catch((err) => {
+      if (err.status === 401) {
+        console.log('尚未登录。\n请在项目目录中运行`pushy login`命令来登录');
+        return;
+      }
+      console.error(err.stack);
+      process.exit(-1);
+    });
+}
+
+run();

src/package.js

@@ -0,0 +1,146 @@
+import { get, post, uploadFile } from './api';
+import { question, saveToLocal } from './utils';
+
+import { checkPlatform, getSelectedApp } from './app';
+
+import { getApkInfo, getIpaInfo } from './utils';
+import Table from 'tty-table';
+
+export async function listPackage(appId) {
+  const { data } = await get(`/app/${appId}/package/list?limit=1000`);
+
+  const header = [{ value: '原生包 Id' }, { value: '原生版本' }];
+  const rows = [];
+  for (const pkg of data) {
+    const { version } = pkg;
+    let versionInfo = '';
+    if (version) {
+      versionInfo = `, 已绑定：${version.name} (${version.id})`;
+    } else {
+      // versionInfo = ' (newest)';
+    }
+    let output = pkg.name;
+    if (pkg.status === 'paused') {
+      output += '(已暂停)';
+    }
+    if (pkg.status === 'expired') {
+      output += '(已过期)';
+    }
+    output += versionInfo;
+    rows.push([pkg.id, output]);
+  }
+
+  console.log(Table(header, rows).render());
+  console.log(`\n共 ${data.length} 个包`);
+  return data;
+}
+
+export async function choosePackage(appId) {
+  const list = await listPackage(appId);
+
+  while (true) {
+    const id = await question('输入原生包 id:');
+    const app = list.find((v) => v.id === (id | 0));
+    if (app) {
+      return app;
+    }
+  }
+}
+
+export const commands = {
+  uploadIpa: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.ipa')) {
+      throw new Error('使用方法: pushy uploadIpa ipa后缀文件');
+    }
+    const {
+      versionName,
+      buildTime,
+      appId: appIdInPkg,
+      appKey: appKeyInPkg,
+    } = await getIpaInfo(fn);
+    const { appId, appKey } = await getSelectedApp('ios');
+
+    if (appIdInPkg && appIdInPkg != appId) {
+      throw new Error(
+        `appId不匹配！当前ipa: ${appIdInPkg}, 当前update.json: ${appId}`,
+      );
+    }
+
+    if (appKeyInPkg && appKeyInPkg !== appKey) {
+      throw new Error(
+        `appKey不匹配！当前ipa: ${appKeyInPkg}, 当前update.json: ${appKey}`,
+      );
+    }
+
+    const { hash } = await uploadFile(fn);
+
+    const { id } = await post(`/app/${appId}/package/create`, {
+      name: versionName,
+      hash,
+      buildTime,
+    });
+    saveToLocal(fn, `${appId}/package/${id}.ipa`);
+    console.log(
+      `已成功上传ipa原生包（id: ${id}, version: ${versionName}, buildTime: ${buildTime}）`,
+    );
+  },
+  uploadApk: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.apk')) {
+      throw new Error('使用方法: pushy uploadApk apk后缀文件');
+    }
+    const {
+      versionName,
+      buildTime,
+      appId: appIdInPkg,
+      appKey: appKeyInPkg,
+    } = await getApkInfo(fn);
+    const { appId, appKey } = await getSelectedApp('android');
+
+    if (appIdInPkg && appIdInPkg != appId) {
+      throw new Error(
+        `appId不匹配！当前apk: ${appIdInPkg}, 当前update.json: ${appId}`,
+      );
+    }
+
+    if (appKeyInPkg && appKeyInPkg !== appKey) {
+      throw new Error(
+        `appKey不匹配！当前apk: ${appKeyInPkg}, 当前update.json: ${appKey}`,
+      );
+    }
+
+    const { hash } = await uploadFile(fn);
+
+    const { id } = await post(`/app/${appId}/package/create`, {
+      name: versionName,
+      hash,
+      buildTime,
+    });
+    saveToLocal(fn, `${appId}/package/${id}.apk`);
+    console.log(
+      `已成功上传apk原生包（id: ${id}, version: ${versionName}, buildTime: ${buildTime}）`,
+    );
+  },
+  parseIpa: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.ipa')) {
+      throw new Error('使用方法: pushy parseIpa ipa后缀文件');
+    }
+    console.log(await getIpaInfo(fn));
+  },
+  parseApk: async function ({ args }) {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.apk')) {
+      throw new Error('使用方法: pushy parseApk apk后缀文件');
+    }
+    console.log(await getApkInfo(fn));
+  },
+  packages: async function ({ options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { appId } = await getSelectedApp(platform);
+    await listPackage(appId);
+  },
+};

src/user.js

@@ -0,0 +1,33 @@
+import { question } from './utils';
+import { post, get, replaceSession, saveSession, closeSession } from './api';
+import crypto from 'crypto';
+
+function md5(str) {
+  return crypto.createHash('md5').update(str).digest('hex');
+}
+
+export const commands = {
+  login: async function ({ args }) {
+    const email = args[0] || (await question('email:'));
+    const pwd = args[1] || (await question('password:', true));
+    const { token, info } = await post('/user/login', {
+      email,
+      pwd: md5(pwd),
+    });
+    replaceSession({ token });
+    await saveSession();
+    console.log(`欢迎使用 pushy 热更新服务， ${info.name}.`);
+  },
+  logout: async function () {
+    await closeSession();
+    console.log('已退出登录');
+  },
+  me: async function () {
+    const me = await get('/user/me');
+    for (const k in me) {
+      if (k !== 'ok') {
+        console.log(`${k}: ${me[k]}`);
+      }
+    }
+  },
+};

src/utils/app-info-parser/apk.js

@@ -0,0 +1,90 @@
+const Zip = require('./zip')
+const { mapInfoResource, findApkIconPath, getBase64FromBuffer } = require('./utils')
+const ManifestName = /^androidmanifest\.xml$/
+const ResourceName = /^resources\.arsc$/
+
+const ManifestXmlParser = require('./xml-parser/manifest')
+const ResourceFinder = require('./resource-finder')
+
+class ApkParser extends Zip {
+  /**
+   * parser for parsing .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    super(file)
+    if (!(this instanceof ApkParser)) {
+      return new ApkParser(file)
+    }
+  }
+  parse () {
+    return new Promise((resolve, reject) => {
+      this.getEntries([ManifestName, ResourceName]).then(buffers => {
+        if (!buffers[ManifestName]) {
+          throw new Error('AndroidManifest.xml can\'t be found.')
+        }
+        let apkInfo = this._parseManifest(buffers[ManifestName])
+        let resourceMap
+        if (!buffers[ResourceName]) {
+          resolve(apkInfo)
+        } else {
+          // parse resourceMap
+          resourceMap = this._parseResourceMap(buffers[ResourceName])
+          // update apkInfo with resourceMap
+          apkInfo = mapInfoResource(apkInfo, resourceMap)
+
+          // find icon path and parse icon
+          const iconPath = findApkIconPath(apkInfo)
+          if (iconPath) {
+            this.getEntry(iconPath).then(iconBuffer => {
+              apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null
+              resolve(apkInfo)
+            }).catch(e => {
+              apkInfo.icon = null
+              resolve(apkInfo)
+              console.warn('[Warning] failed to parse icon: ', e)
+            })
+          } else {
+            apkInfo.icon = null
+            resolve(apkInfo)
+          }
+        }
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  _parseManifest (buffer) {
+    try {
+      const parser = new ManifestXmlParser(buffer, {
+        ignore: [
+          'application.activity',
+          'application.service',
+          'application.receiver',
+          'application.provider',
+          'permission-group'
+        ]
+      })
+      return parser.parse()
+    } catch (e) {
+      throw new Error('Parse AndroidManifest.xml error: ', e)
+    }
+  }
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  _parseResourceMap (buffer) {
+    try {
+      return new ResourceFinder().processResourceTable(buffer)
+    } catch (e) {
+      throw new Error('Parser resources.arsc error: ' + e)
+    }
+  }
+}
+
+module.exports = ApkParser

src/utils/app-info-parser/index.js

@@ -0,0 +1,35 @@
+const ApkParser = require('./apk')
+const IpaParser = require('./ipa')
+const supportFileTypes = ['ipa', 'apk']
+
+class AppInfoParser {
+  /**
+   * parser for parsing .ipa or .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    if (!file) {
+      throw new Error('Param miss: file(file\'s path in Node, instance of File or Blob in browser).')
+    }
+    const splits = (file.name || file).split('.')
+    const fileType = splits[splits.length - 1].toLowerCase()
+    if (!supportFileTypes.includes(fileType)) {
+      throw new Error('Unsupported file type, only support .ipa or .apk file.')
+    }
+    this.file = file
+
+    switch (fileType) {
+      case 'ipa':
+        this.parser = new IpaParser(this.file)
+        break
+      case 'apk':
+        this.parser = new ApkParser(this.file)
+        break
+    }
+  }
+  parse () {
+    return this.parser.parse()
+  }
+}
+
+module.exports = AppInfoParser

src/utils/app-info-parser/ipa.js

@@ -0,0 +1,92 @@
+const parsePlist = require('plist').parse
+const parseBplist = require('bplist-parser').parseBuffer
+const cgbiToPng = require('cgbi-to-png')
+
+const Zip = require('./zip')
+const { findIpaIconPath, getBase64FromBuffer, isBrowser } = require('./utils')
+
+const PlistName = new RegExp('payload/[^/]+?.app/info.plist$', 'i')
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/
+
+class IpaParser extends Zip {
+  /**
+   * parser for parsing .ipa file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor (file) {
+    super(file)
+    if (!(this instanceof IpaParser)) {
+      return new IpaParser(file)
+    }
+  }
+  parse () {
+    return new Promise((resolve, reject) => {
+      this.getEntries([PlistName, ProvisionName]).then(buffers => {
+        if (!buffers[PlistName]) {
+          throw new Error('Info.plist can\'t be found.')
+        }
+        const plistInfo = this._parsePlist(buffers[PlistName])
+        // parse mobile provision
+        const provisionInfo = this._parseProvision(buffers[ProvisionName])
+        plistInfo.mobileProvision = provisionInfo
+
+        // find icon path and parse icon
+        const iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase())
+        this.getEntry(iconRegex).then(iconBuffer => {
+          try {
+            // In general, the ipa file's icon has been specially processed, should be converted
+            plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null
+          } catch (err) {
+            if (isBrowser()) {
+              // Normal conversion in other cases
+              plistInfo.icon = iconBuffer ? getBase64FromBuffer(window.btoa(String.fromCharCode(...iconBuffer))) : null
+            } else {
+              plistInfo.icon = null
+              console.warn('[Warning] failed to parse icon: ', err)
+            }
+          }
+          resolve(plistInfo)
+        }).catch(e => {
+          reject(e)
+        })
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+  /**
+   * Parse plist
+   * @param {Buffer} buffer // plist file's buffer
+   */
+  _parsePlist (buffer) {
+    let result
+    const bufferType = buffer[0]
+    if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+      result = parsePlist(buffer.toString())
+    } else if (bufferType === 98) {
+      result = parseBplist(buffer)[0]
+    } else {
+      throw new Error('Unknown plist buffer type.')
+    }
+    return result
+  }
+  /**
+   * parse provision
+   * @param {Buffer} buffer // provision file's buffer
+   */
+  _parseProvision (buffer) {
+    let info = {}
+    if (buffer) {
+      let content = buffer.toString('utf-8')
+      const firstIndex = content.indexOf('<?xml')
+      const endIndex = content.indexOf('</plist>')
+      content = content.slice(firstIndex, endIndex + 8)
+      if (content) {
+        info = parsePlist(content)
+      }
+    }
+    return info
+  }
+}
+
+module.exports = IpaParser

src/utils/app-info-parser/resource-finder.js

@@ -0,0 +1,499 @@
+/**
+ * Code translated from a C# project https://github.com/hylander0/Iteedee.ApkReader/blob/master/Iteedee.ApkReader/ApkResourceFinder.cs
+ *
+ * Decode binary file `resources.arsc` from a .apk file to a JavaScript Object.
+ */
+
+var ByteBuffer = require("bytebuffer");
+
+var DEBUG = false;
+
+var RES_STRING_POOL_TYPE = 0x0001;
+var RES_TABLE_TYPE = 0x0002;
+var RES_TABLE_PACKAGE_TYPE = 0x0200;
+var RES_TABLE_TYPE_TYPE = 0x0201;
+var RES_TABLE_TYPE_SPEC_TYPE = 0x0202;
+
+// The 'data' holds a ResTable_ref, a reference to another resource
+// table entry.
+var TYPE_REFERENCE = 0x01;
+// The 'data' holds an index into the containing resource table's
+// global value string pool.
+var TYPE_STRING = 0x03;
+
+function ResourceFinder() {
+  this.valueStringPool = null;
+  this.typeStringPool = null;
+  this.keyStringPool = null;
+
+  this.package_id = 0;
+
+  this.responseMap = {};
+  this.entryMap = {};
+}
+
+/**
+ * Same to C# BinaryReader.readBytes
+ *
+ * @param bb ByteBuffer
+ * @param len length
+ * @returns {Buffer}
+ */
+ResourceFinder.readBytes = function(bb, len) {
+  var uint8Array = new Uint8Array(len);
+  for (var i = 0; i < len; i++) {
+    uint8Array[i] = bb.readUint8();
+  }
+
+  return ByteBuffer.wrap(uint8Array, "binary", true);
+};
+
+//
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Map<String, Set<String>>}
+ */
+ResourceFinder.prototype.processResourceTable = function(resourceBuffer) {
+  const bb = ByteBuffer.wrap(resourceBuffer, "binary", true);
+
+  // Resource table structure
+  var type = bb.readShort(),
+    headerSize = bb.readShort(),
+    size = bb.readInt(),
+    packageCount = bb.readInt(),
+    buffer,
+    bb2;
+  if (type != RES_TABLE_TYPE) {
+    throw new Error("No RES_TABLE_TYPE found!");
+  }
+  if (size != bb.limit) {
+    throw new Error("The buffer size not matches to the resource table size.");
+  }
+  bb.offset = headerSize;
+
+  var realStringPoolCount = 0,
+    realPackageCount = 0;
+
+  while (true) {
+    var pos, t, hs, s;
+    try {
+      pos = bb.offset;
+      t = bb.readShort();
+      hs = bb.readShort();
+      s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+    if (t == RES_STRING_POOL_TYPE) {
+      // Process the string pool
+      if (realStringPoolCount == 0) {
+        // Only the first string pool is processed.
+        if (DEBUG) {
+          console.log("Processing the string pool ...");
+        }
+
+        buffer = new ByteBuffer(s);
+        bb.offset = pos;
+        bb.prependTo(buffer);
+
+        bb2 = ByteBuffer.wrap(buffer, "binary", true);
+
+        bb2.LE();
+        this.valueStringPool = this.processStringPool(bb2);
+      }
+      realStringPoolCount++;
+    } else if (t == RES_TABLE_PACKAGE_TYPE) {
+      // Process the package
+      if (DEBUG) {
+        console.log("Processing the package " + realPackageCount + " ...");
+      }
+
+      buffer = new ByteBuffer(s);
+      bb.offset = pos;
+      bb.prependTo(buffer);
+
+      bb2 = ByteBuffer.wrap(buffer, "binary", true);
+      bb2.LE();
+      this.processPackage(bb2);
+
+      realPackageCount++;
+    } else {
+      throw new Error("Unsupported type");
+    }
+    bb.offset = pos + s;
+    if (!bb.remaining()) break;
+  }
+
+  if (realStringPoolCount != 1) {
+    throw new Error("More than 1 string pool found!");
+  }
+  if (realPackageCount != packageCount) {
+    throw new Error("Real package count not equals the declared count.");
+  }
+
+  return this.responseMap;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processPackage = function(bb) {
+  // Package structure
+  var type = bb.readShort(),
+    headerSize = bb.readShort(),
+    size = bb.readInt(),
+    id = bb.readInt();
+
+  this.package_id = id;
+
+  for (var i = 0; i < 256; ++i) {
+    bb.readUint8();
+  }
+
+  var typeStrings = bb.readInt(),
+    lastPublicType = bb.readInt(),
+    keyStrings = bb.readInt(),
+    lastPublicKey = bb.readInt();
+
+  if (typeStrings != headerSize) {
+    throw new Error(
+      "TypeStrings must immediately following the package structure header."
+    );
+  }
+
+  if (DEBUG) {
+    console.log("Type strings:");
+  }
+
+  var lastPosition = bb.offset;
+  bb.offset = typeStrings;
+  var bbTypeStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.typeStringPool = this.processStringPool(bbTypeStrings);
+
+  // Key strings
+  if (DEBUG) {
+    console.log("Key strings:");
+  }
+
+  bb.offset = keyStrings;
+  var key_type = bb.readShort(),
+    key_headerSize = bb.readShort(),
+    key_size = bb.readInt();
+
+  lastPosition = bb.offset;
+  bb.offset = keyStrings;
+  var bbKeyStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.keyStringPool = this.processStringPool(bbKeyStrings);
+
+  // Iterate through all chunks
+  var typeSpecCount = 0;
+  var typeCount = 0;
+
+  bb.offset = keyStrings + key_size;
+
+  var bb2;
+
+  while (true) {
+    var pos = bb.offset;
+    try {
+      var t = bb.readShort();
+      var hs = bb.readShort();
+      var s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+
+    if (t == RES_TABLE_TYPE_SPEC_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processTypeSpec(bb2);
+
+      typeSpecCount++;
+    } else if (t == RES_TABLE_TYPE_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processType(bb2);
+
+      typeCount++;
+    }
+
+    if (s == 0) {
+      break;
+    }
+
+    bb.offset = pos + s;
+
+    if (!bb.remaining()) {
+      break;
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processType = function(bb) {
+  var type = bb.readShort(),
+    headerSize = bb.readShort(),
+    size = bb.readInt(),
+    id = bb.readByte(),
+    res0 = bb.readByte(),
+    res1 = bb.readShort(),
+    entryCount = bb.readInt(),
+    entriesStart = bb.readInt();
+
+  var refKeys = {};
+
+  var config_size = bb.readInt();
+
+  // Skip the config data
+  bb.offset = headerSize;
+
+  if (headerSize + entryCount * 4 != entriesStart) {
+    throw new Error("HeaderSize, entryCount and entriesStart are not valid.");
+  }
+
+  // Start to get entry indices
+  var entryIndices = new Array(entryCount);
+  for (var i = 0; i < entryCount; ++i) {
+    entryIndices[i] = bb.readInt();
+  }
+
+  // Get entries
+  for (var i = 0; i < entryCount; ++i) {
+    if (entryIndices[i] == -1) continue;
+
+    var resource_id = (this.package_id << 24) | (id << 16) | i;
+
+    var pos = bb.offset,
+      entry_size,
+      entry_flag,
+      entry_key,
+      value_size,
+      value_res0,
+      value_dataType,
+      value_data;
+    try {
+      entry_size = bb.readShort()
+      entry_flag = bb.readShort()
+      entry_key = bb.readInt()
+    } catch (e) {
+      break
+    }
+
+    // Get the value (simple) or map (complex)
+
+    var FLAG_COMPLEX = 0x0001;
+    if ((entry_flag & FLAG_COMPLEX) == 0) {
+      // Simple case
+      value_size = bb.readShort();
+      value_res0 = bb.readByte();
+      value_dataType = bb.readByte();
+      value_data = bb.readInt();
+
+      var idStr = Number(resource_id).toString(16);
+      var keyStr = this.keyStringPool[entry_key];
+
+      var data = null;
+
+      if (DEBUG) {
+        console.log(
+          "Entry 0x" + idStr + ", key: " + keyStr + ", simple value type: "
+        );
+      }
+
+      var key = parseInt(idStr, 16);
+
+      var entryArr = this.entryMap[key];
+      if (entryArr == null) {
+        entryArr = [];
+      }
+      entryArr.push(keyStr);
+
+      this.entryMap[key] = entryArr;
+
+      if (value_dataType == TYPE_STRING) {
+        data = this.valueStringPool[value_data];
+
+        if (DEBUG) {
+          console.log(", data: " + this.valueStringPool[value_data] + "");
+        }
+      } else if (value_dataType == TYPE_REFERENCE) {
+        var hexIndex = Number(value_data).toString(16);
+
+        refKeys[idStr] = value_data;
+      } else {
+        data = "" + value_data;
+        if (DEBUG) {
+          console.log(", data: " + value_data + "");
+        }
+      }
+
+      this.putIntoMap("@" + idStr, data);
+    } else {
+      // Complex case
+      var entry_parent = bb.readInt();
+      var entry_count = bb.readInt();
+
+      for (var j = 0; j < entry_count; ++j) {
+        var ref_name = bb.readInt();
+        value_size = bb.readShort();
+        value_res0 = bb.readByte();
+        value_dataType = bb.readByte();
+        value_data = bb.readInt();
+      }
+
+      if (DEBUG) {
+        console.log(
+          "Entry 0x" +
+            Number(resource_id).toString(16) +
+            ", key: " +
+            this.keyStringPool[entry_key] +
+            ", complex value, not printed."
+        );
+      }
+    }
+  }
+
+  for (var refK in refKeys) {
+    var values = this.responseMap[
+      "@" +
+        Number(refKeys[refK])
+          .toString(16)
+          .toUpperCase()
+    ];
+    if (values != null && Object.keys(values).length < 1000) {
+      for (var value in values) {
+        this.putIntoMap("@" + refK, values[value]);
+      }
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Array}
+ */
+ResourceFinder.prototype.processStringPool = function(bb) {
+  // String pool structure
+  //
+  var type = bb.readShort(),
+    headerSize = bb.readShort(),
+    size = bb.readInt(),
+    stringCount = bb.readInt(),
+    styleCount = bb.readInt(),
+    flags = bb.readInt(),
+    stringsStart = bb.readInt(),
+    stylesStart = bb.readInt(),
+    u16len,
+    buffer;
+
+  var isUTF_8 = (flags & 256) != 0;
+
+  var offsets = new Array(stringCount);
+  for (var i = 0; i < stringCount; ++i) {
+    offsets[i] = bb.readInt();
+  }
+
+  var strings = new Array(stringCount);
+
+  for (var i = 0; i < stringCount; ++i) {
+    var pos = stringsStart + offsets[i];
+    bb.offset = pos;
+
+    strings[i] = "";
+
+    if (isUTF_8) {
+      u16len = bb.readUint8();
+
+      if ((u16len & 0x80) != 0) {
+        u16len = ((u16len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      var u8len = bb.readUint8();
+      if ((u8len & 0x80) != 0) {
+        u8len = ((u8len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      if (u8len > 0) {
+        buffer = ResourceFinder.readBytes(bb, u8len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      } else {
+        strings[i] = "";
+      }
+    } else {
+      u16len = bb.readUint16();
+      if ((u16len & 0x8000) != 0) {
+        // larger than 32768
+        u16len = ((u16len & 0x7fff) << 16) + bb.readUint16();
+      }
+
+      if (u16len > 0) {
+        var len = u16len * 2;
+        buffer = ResourceFinder.readBytes(bb, len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      }
+    }
+
+    if (DEBUG) {
+      console.log("Parsed value: {0}", strings[i]);
+    }
+  }
+
+  return strings;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processTypeSpec = function(bb) {
+  var type = bb.readShort(),
+    headerSize = bb.readShort(),
+    size = bb.readInt(),
+    id = bb.readByte(),
+    res0 = bb.readByte(),
+    res1 = bb.readShort(),
+    entryCount = bb.readInt();
+
+  if (DEBUG) {
+    console.log("Processing type spec " + this.typeStringPool[id - 1] + "...");
+  }
+
+  var flags = new Array(entryCount);
+
+  for (var i = 0; i < entryCount; ++i) {
+    flags[i] = bb.readInt();
+  }
+};
+
+ResourceFinder.prototype.putIntoMap = function(resId, value) {
+  if (this.responseMap[resId.toUpperCase()] == null) {
+    this.responseMap[resId.toUpperCase()] = []
+  }
+  if(value){
+    this.responseMap[resId.toUpperCase()].push(value)
+  }
+};
+
+module.exports = ResourceFinder;

src/utils/app-info-parser/utils.js

@@ -0,0 +1,167 @@
+function objectType (o) {
+  return Object.prototype.toString.call(o).slice(8, -1).toLowerCase()
+}
+
+function isArray (o) {
+  return objectType(o) === 'array'
+}
+
+function isObject (o) {
+  return objectType(o) === 'object'
+}
+
+function isPrimitive (o) {
+  return o === null || ['boolean', 'number', 'string', 'undefined'].includes(objectType(o))
+}
+
+function isBrowser () {
+  return (
+    typeof process === 'undefined' ||
+    Object.prototype.toString.call(process) !== '[object process]'
+  )
+}
+
+/**
+ * map file place with resourceMap
+ * @param {Object} apkInfo // json info parsed from .apk file
+ * @param {Object} resourceMap // resourceMap
+ */
+function mapInfoResource (apkInfo, resourceMap) {
+  iteratorObj(apkInfo)
+  return apkInfo
+  function iteratorObj (obj) {
+    for (var i in obj) {
+      if (isArray(obj[i])) {
+        iteratorArray(obj[i])
+      } else if (isObject(obj[i])) {
+        iteratorObj(obj[i])
+      } else if (isPrimitive(obj[i])) {
+        if (isResources(obj[i])) {
+          obj[i] = resourceMap[transKeyToMatchResourceMap(obj[i])]
+        }
+      }
+    }
+  }
+
+  function iteratorArray (array) {
+    const l = array.length
+    for (let i = 0; i < l; i++) {
+      if (isArray(array[i])) {
+        iteratorArray(array[i])
+      } else if (isObject(array[i])) {
+        iteratorObj(array[i])
+      } else if (isPrimitive(array[i])) {
+        if (isResources(array[i])) {
+          array[i] = resourceMap[transKeyToMatchResourceMap(array[i])]
+        }
+      }
+    }
+  }
+
+  function isResources (attrValue) {
+    if (!attrValue) return false
+    if (typeof attrValue !== 'string') {
+      attrValue = attrValue.toString()
+    }
+    return attrValue.indexOf('resourceId:') === 0
+  }
+
+  function transKeyToMatchResourceMap (resourceId) {
+    return '@' + resourceId.replace('resourceId:0x', '').toUpperCase()
+  }
+}
+
+/**
+ * find .apk file's icon path from json info
+ * @param info // json info parsed from .apk file
+ */
+function findApkIconPath (info) {
+  if (!info.application.icon || !info.application.icon.splice) {
+    return ''
+  }
+  const rulesMap = {
+    mdpi: 48,
+    hdpi: 72,
+    xhdpi: 96,
+    xxdpi: 144,
+    xxxhdpi: 192
+  }
+  const resultMap = {}
+  const maxDpiIcon = { dpi: 120, icon: '' }
+
+  for (const i in rulesMap) {
+    info.application.icon.some((icon) => {
+      if (icon && icon.indexOf(i) !== -1) {
+        resultMap['application-icon-' + rulesMap[i]] = icon
+        return true
+      }
+    })
+
+    // get the maximal size icon
+    if (
+      resultMap['application-icon-' + rulesMap[i]] &&
+      rulesMap[i] >= maxDpiIcon.dpi
+    ) {
+      maxDpiIcon.dpi = rulesMap[i]
+      maxDpiIcon.icon = resultMap['application-icon-' + rulesMap[i]]
+    }
+  }
+
+  if (Object.keys(resultMap).length === 0 || !maxDpiIcon.icon) {
+    maxDpiIcon.dpi = 120
+    maxDpiIcon.icon = info.application.icon[0] || ''
+    resultMap['applicataion-icon-120'] = maxDpiIcon.icon
+  }
+  return maxDpiIcon.icon
+}
+
+/**
+ * find .ipa file's icon path from json info
+ * @param info // json info parsed from .ipa file
+ */
+function findIpaIconPath (info) {
+  if (
+    info.CFBundleIcons &&
+    info.CFBundleIcons.CFBundlePrimaryIcon &&
+    info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles &&
+    info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length
+  ) {
+    return info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles[info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length - 1]
+  } else if (info.CFBundleIconFiles && info.CFBundleIconFiles.length) {
+    return info.CFBundleIconFiles[info.CFBundleIconFiles.length - 1]
+  } else {
+    return '.app/Icon.png'
+  }
+}
+
+/**
+ * transform buffer to base64
+ * @param {Buffer} buffer
+ */
+function getBase64FromBuffer (buffer) {
+  return 'data:image/png;base64,' + buffer.toString('base64')
+}
+
+/**
+ * 去除unicode空字符
+ * @param {String} str
+ */
+function decodeNullUnicode (str) {
+  if (typeof str === 'string') {
+    // eslint-disable-next-line
+    str = str.replace(/\u0000/g, '')
+  }
+  return str
+}
+
+module.exports = {
+  isArray,
+  isObject,
+  isPrimitive,
+  isBrowser,
+  mapInfoResource,
+  findApkIconPath,
+  findIpaIconPath,
+  getBase64FromBuffer,
+  decodeNullUnicode
+}

src/utils/app-info-parser/xml-parser/binary.js

@@ -0,0 +1,674 @@
+// From https://github.com/openstf/adbkit-apkreader
+const NodeType = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  CDATA_SECTION_NODE: 4
+}
+
+const ChunkType = {
+  NULL: 0x0000,
+  STRING_POOL: 0x0001,
+  TABLE: 0x0002,
+  XML: 0x0003,
+  XML_FIRST_CHUNK: 0x0100,
+  XML_START_NAMESPACE: 0x0100,
+  XML_END_NAMESPACE: 0x0101,
+  XML_START_ELEMENT: 0x0102,
+  XML_END_ELEMENT: 0x0103,
+  XML_CDATA: 0x0104,
+  XML_LAST_CHUNK: 0x017f,
+  XML_RESOURCE_MAP: 0x0180,
+  TABLE_PACKAGE: 0x0200,
+  TABLE_TYPE: 0x0201,
+  TABLE_TYPE_SPEC: 0x0202
+}
+
+const StringFlags = {
+  SORTED: 1 << 0,
+  UTF8: 1 << 8
+}
+
+// Taken from android.util.TypedValue
+const TypedValue = {
+  COMPLEX_MANTISSA_MASK: 0x00ffffff,
+  COMPLEX_MANTISSA_SHIFT: 0x00000008,
+  COMPLEX_RADIX_0p23: 0x00000003,
+  COMPLEX_RADIX_16p7: 0x00000001,
+  COMPLEX_RADIX_23p0: 0x00000000,
+  COMPLEX_RADIX_8p15: 0x00000002,
+  COMPLEX_RADIX_MASK: 0x00000003,
+  COMPLEX_RADIX_SHIFT: 0x00000004,
+  COMPLEX_UNIT_DIP: 0x00000001,
+  COMPLEX_UNIT_FRACTION: 0x00000000,
+  COMPLEX_UNIT_FRACTION_PARENT: 0x00000001,
+  COMPLEX_UNIT_IN: 0x00000004,
+  COMPLEX_UNIT_MASK: 0x0000000f,
+  COMPLEX_UNIT_MM: 0x00000005,
+  COMPLEX_UNIT_PT: 0x00000003,
+  COMPLEX_UNIT_PX: 0x00000000,
+  COMPLEX_UNIT_SHIFT: 0x00000000,
+  COMPLEX_UNIT_SP: 0x00000002,
+  DENSITY_DEFAULT: 0x00000000,
+  DENSITY_NONE: 0x0000ffff,
+  TYPE_ATTRIBUTE: 0x00000002,
+  TYPE_DIMENSION: 0x00000005,
+  TYPE_FIRST_COLOR_INT: 0x0000001c,
+  TYPE_FIRST_INT: 0x00000010,
+  TYPE_FLOAT: 0x00000004,
+  TYPE_FRACTION: 0x00000006,
+  TYPE_INT_BOOLEAN: 0x00000012,
+  TYPE_INT_COLOR_ARGB4: 0x0000001e,
+  TYPE_INT_COLOR_ARGB8: 0x0000001c,
+  TYPE_INT_COLOR_RGB4: 0x0000001f,
+  TYPE_INT_COLOR_RGB8: 0x0000001d,
+  TYPE_INT_DEC: 0x00000010,
+  TYPE_INT_HEX: 0x00000011,
+  TYPE_LAST_COLOR_INT: 0x0000001f,
+  TYPE_LAST_INT: 0x0000001f,
+  TYPE_NULL: 0x00000000,
+  TYPE_REFERENCE: 0x00000001,
+  TYPE_STRING: 0x00000003
+}
+
+class BinaryXmlParser {
+  constructor (buffer, options = {}) {
+    this.buffer = buffer
+    this.cursor = 0
+    this.strings = []
+    this.resources = []
+    this.document = null
+    this.parent = null
+    this.stack = []
+    this.debug = options.debug || false
+  }
+
+  readU8 () {
+    this.debug && console.group('readU8')
+    this.debug && console.debug('cursor:', this.cursor)
+    const val = this.buffer[this.cursor]
+    this.debug && console.debug('value:', val)
+    this.cursor += 1
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readU16 () {
+    this.debug && console.group('readU16')
+    this.debug && console.debug('cursor:', this.cursor)
+    const val = this.buffer.readUInt16LE(this.cursor)
+    this.debug && console.debug('value:', val)
+    this.cursor += 2
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readS32 () {
+    this.debug && console.group('readS32')
+    this.debug && console.debug('cursor:', this.cursor)
+    const val = this.buffer.readInt32LE(this.cursor)
+    this.debug && console.debug('value:', val)
+    this.cursor += 4
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readU32 () {
+    this.debug && console.group('readU32')
+    this.debug && console.debug('cursor:', this.cursor)
+    const val = this.buffer.readUInt32LE(this.cursor)
+    this.debug && console.debug('value:', val)
+    this.cursor += 4
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readLength8 () {
+    this.debug && console.group('readLength8')
+    let len = this.readU8()
+    if (len & 0x80) {
+      len = (len & 0x7f) << 8
+      len += this.readU8()
+    }
+    this.debug && console.debug('length:', len)
+    this.debug && console.groupEnd()
+    return len
+  }
+
+  readLength16 () {
+    this.debug && console.group('readLength16')
+    let len = this.readU16()
+    if (len & 0x8000) {
+      len = (len & 0x7fff) << 16
+      len += this.readU16()
+    }
+    this.debug && console.debug('length:', len)
+    this.debug && console.groupEnd()
+    return len
+  }
+
+  readDimension () {
+    this.debug && console.group('readDimension')
+
+    const dimension = {
+      value: null,
+      unit: null,
+      rawUnit: null
+    }
+
+    const value = this.readU32()
+    const unit = dimension.value & 0xff
+
+    dimension.value = value >> 8
+    dimension.rawUnit = unit
+
+    switch (unit) {
+      case TypedValue.COMPLEX_UNIT_MM:
+        dimension.unit = 'mm'
+        break
+      case TypedValue.COMPLEX_UNIT_PX:
+        dimension.unit = 'px'
+        break
+      case TypedValue.COMPLEX_UNIT_DIP:
+        dimension.unit = 'dp'
+        break
+      case TypedValue.COMPLEX_UNIT_SP:
+        dimension.unit = 'sp'
+        break
+      case TypedValue.COMPLEX_UNIT_PT:
+        dimension.unit = 'pt'
+        break
+      case TypedValue.COMPLEX_UNIT_IN:
+        dimension.unit = 'in'
+        break
+    }
+
+    this.debug && console.groupEnd()
+
+    return dimension
+  }
+
+  readFraction () {
+    this.debug && console.group('readFraction')
+
+    const fraction = {
+      value: null,
+      type: null,
+      rawType: null
+    }
+
+    const value = this.readU32()
+    const type = value & 0xf
+
+    fraction.value = this.convertIntToFloat(value >> 4)
+    fraction.rawType = type
+
+    switch (type) {
+      case TypedValue.COMPLEX_UNIT_FRACTION:
+        fraction.type = '%'
+        break
+      case TypedValue.COMPLEX_UNIT_FRACTION_PARENT:
+        fraction.type = '%p'
+        break
+    }
+
+    this.debug && console.groupEnd()
+
+    return fraction
+  }
+
+  readHex24 () {
+    this.debug && console.group('readHex24')
+    var val = (this.readU32() & 0xffffff).toString(16)
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readHex32 () {
+    this.debug && console.group('readHex32')
+    var val = this.readU32().toString(16)
+    this.debug && console.groupEnd()
+    return val
+  }
+
+  readTypedValue () {
+    this.debug && console.group('readTypedValue')
+
+    const typedValue = {
+      value: null,
+      type: null,
+      rawType: null
+    }
+
+    const start = this.cursor
+
+    let size = this.readU16()
+    /* const zero = */ this.readU8()
+    const dataType = this.readU8()
+
+    // Yes, there has been a real world APK where the size is malformed.
+    if (size === 0) {
+      size = 8
+    }
+
+    typedValue.rawType = dataType
+
+    switch (dataType) {
+      case TypedValue.TYPE_INT_DEC:
+        typedValue.value = this.readS32()
+        typedValue.type = 'int_dec'
+        break
+      case TypedValue.TYPE_INT_HEX:
+        typedValue.value = this.readS32()
+        typedValue.type = 'int_hex'
+        break
+      case TypedValue.TYPE_STRING:
+        var ref = this.readS32()
+        typedValue.value = ref > 0 ? this.strings[ref] : ''
+        typedValue.type = 'string'
+        break
+      case TypedValue.TYPE_REFERENCE:
+        var id = this.readU32()
+        typedValue.value = `resourceId:0x${id.toString(16)}`
+        typedValue.type = 'reference'
+        break
+      case TypedValue.TYPE_INT_BOOLEAN:
+        typedValue.value = this.readS32() !== 0
+        typedValue.type = 'boolean'
+        break
+      case TypedValue.TYPE_NULL:
+        this.readU32()
+        typedValue.value = null
+        typedValue.type = 'null'
+        break
+      case TypedValue.TYPE_INT_COLOR_RGB8:
+        typedValue.value = this.readHex24()
+        typedValue.type = 'rgb8'
+        break
+      case TypedValue.TYPE_INT_COLOR_RGB4:
+        typedValue.value = this.readHex24()
+        typedValue.type = 'rgb4'
+        break
+      case TypedValue.TYPE_INT_COLOR_ARGB8:
+        typedValue.value = this.readHex32()
+        typedValue.type = 'argb8'
+        break
+      case TypedValue.TYPE_INT_COLOR_ARGB4:
+        typedValue.value = this.readHex32()
+        typedValue.type = 'argb4'
+        break
+      case TypedValue.TYPE_DIMENSION:
+        typedValue.value = this.readDimension()
+        typedValue.type = 'dimension'
+        break
+      case TypedValue.TYPE_FRACTION:
+        typedValue.value = this.readFraction()
+        typedValue.type = 'fraction'
+        break
+      default: {
+        const type = dataType.toString(16)
+        console.debug(`Not sure what to do with typed value of type 0x${type}, falling back to reading an uint32.`)
+        typedValue.value = this.readU32()
+        typedValue.type = 'unknown'
+      }
+    }
+
+    // Ensure we consume the whole value
+    const end = start + size
+    if (this.cursor !== end) {
+      const type = dataType.toString(16)
+      const diff = end - this.cursor
+      console.debug(`Cursor is off by ${diff} bytes at ${this.cursor} at supposed end \
+of typed value of type 0x${type}. The typed value started at offset ${start} \
+and is supposed to end at offset ${end}. Ignoring the rest of the value.`)
+      this.cursor = end
+    }
+
+    this.debug && console.groupEnd()
+
+    return typedValue
+  }
+
+  // https://twitter.com/kawasima/status/427730289201139712
+  convertIntToFloat (int) {
+    const buf = new ArrayBuffer(4)
+    ;(new Int32Array(buf))[0] = int
+    return (new Float32Array(buf))[0]
+  }
+
+  readString (encoding) {
+    this.debug && console.group('readString', encoding)
+    switch (encoding) {
+      case 'utf-8':
+        var stringLength = this.readLength8(encoding)
+        this.debug && console.debug('stringLength:', stringLength)
+        var byteLength = this.readLength8(encoding)
+        this.debug && console.debug('byteLength:', byteLength)
+        var value = this.buffer.toString(encoding, this.cursor, (this.cursor += byteLength))
+        this.debug && console.debug('value:', value)
+        this.debug && console.groupEnd()
+        return value
+      case 'ucs2':
+        stringLength = this.readLength16(encoding)
+        this.debug && console.debug('stringLength:', stringLength)
+        byteLength = stringLength * 2
+        this.debug && console.debug('byteLength:', byteLength)
+        value = this.buffer.toString(encoding, this.cursor, (this.cursor += byteLength))
+        this.debug && console.debug('value:', value)
+        this.debug && console.groupEnd()
+        return value
+      default:
+        throw new Error(`Unsupported encoding '${encoding}'`)
+    }
+  }
+
+  readChunkHeader () {
+    this.debug && console.group('readChunkHeader')
+    var header = {
+      startOffset: this.cursor,
+      chunkType: this.readU16(),
+      headerSize: this.readU16(),
+      chunkSize: this.readU32()
+    }
+    this.debug && console.debug('startOffset:', header.startOffset)
+    this.debug && console.debug('chunkType:', header.chunkType)
+    this.debug && console.debug('headerSize:', header.headerSize)
+    this.debug && console.debug('chunkSize:', header.chunkSize)
+    this.debug && console.groupEnd()
+    return header
+  }
+
+  readStringPool (header) {
+    this.debug && console.group('readStringPool')
+
+    header.stringCount = this.readU32()
+    this.debug && console.debug('stringCount:', header.stringCount)
+    header.styleCount = this.readU32()
+    this.debug && console.debug('styleCount:', header.styleCount)
+    header.flags = this.readU32()
+    this.debug && console.debug('flags:', header.flags)
+    header.stringsStart = this.readU32()
+    this.debug && console.debug('stringsStart:', header.stringsStart)
+    header.stylesStart = this.readU32()
+    this.debug && console.debug('stylesStart:', header.stylesStart)
+
+    if (header.chunkType !== ChunkType.STRING_POOL) {
+      throw new Error('Invalid string pool header')
+    }
+
+    const offsets = []
+    for (let i = 0, l = header.stringCount; i < l; ++i) {
+      this.debug && console.debug('offset:', i)
+      offsets.push(this.readU32())
+    }
+
+    const sorted = (header.flags & StringFlags.SORTED) === StringFlags.SORTED
+    this.debug && console.debug('sorted:', sorted)
+    const encoding = (header.flags & StringFlags.UTF8) === StringFlags.UTF8
+      ? 'utf-8'
+      : 'ucs2'
+    this.debug && console.debug('encoding:', encoding)
+
+    const stringsStart = header.startOffset + header.stringsStart
+    this.cursor = stringsStart
+    for (let i = 0, l = header.stringCount; i < l; ++i) {
+      this.debug && console.debug('string:', i)
+      this.debug && console.debug('offset:', offsets[i])
+      this.cursor = stringsStart + offsets[i]
+      this.strings.push(this.readString(encoding))
+    }
+
+    // Skip styles
+    this.cursor = header.startOffset + header.chunkSize
+
+    this.debug && console.groupEnd()
+
+    return null
+  }
+
+  readResourceMap (header) {
+    this.debug && console.group('readResourceMap')
+    const count = Math.floor((header.chunkSize - header.headerSize) / 4)
+    for (let i = 0; i < count; ++i) {
+      this.resources.push(this.readU32())
+    }
+    this.debug && console.groupEnd()
+    return null
+  }
+
+  readXmlNamespaceStart (/* header */) {
+    this.debug && console.group('readXmlNamespaceStart')
+
+    /* const line = */ this.readU32()
+    /* const commentRef = */ this.readU32()
+    /* const prefixRef = */ this.readS32()
+    /* const uriRef = */ this.readS32()
+
+    // We don't currently care about the values, but they could
+    // be accessed like so:
+    //
+    // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
+    // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
+
+    this.debug && console.groupEnd()
+
+    return null
+  }
+
+  readXmlNamespaceEnd (/* header */) {
+    this.debug && console.group('readXmlNamespaceEnd')
+
+    /* const line = */ this.readU32()
+    /* const commentRef = */ this.readU32()
+    /* const prefixRef = */ this.readS32()
+    /* const uriRef = */ this.readS32()
+
+    // We don't currently care about the values, but they could
+    // be accessed like so:
+    //
+    // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
+    // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
+
+    this.debug && console.groupEnd()
+
+    return null
+  }
+
+  readXmlElementStart (/* header */) {
+    this.debug && console.group('readXmlElementStart')
+
+    const node = {
+      namespaceURI: null,
+      nodeType: NodeType.ELEMENT_NODE,
+      nodeName: null,
+      attributes: [],
+      childNodes: []
+    }
+
+    /* const line = */ this.readU32()
+    /* const commentRef = */ this.readU32()
+    const nsRef = this.readS32()
+    const nameRef = this.readS32()
+
+    if (nsRef > 0) {
+      node.namespaceURI = this.strings[nsRef]
+    }
+
+    node.nodeName = this.strings[nameRef]
+
+    /* const attrStart = */ this.readU16()
+    /* const attrSize = */ this.readU16()
+    const attrCount = this.readU16()
+    /* const idIndex = */ this.readU16()
+    /* const classIndex = */ this.readU16()
+    /* const styleIndex = */ this.readU16()
+
+    for (let i = 0; i < attrCount; ++i) {
+      node.attributes.push(this.readXmlAttribute())
+    }
+
+    if (this.document) {
+      this.parent.childNodes.push(node)
+      this.parent = node
+    } else {
+      this.document = (this.parent = node)
+    }
+
+    this.stack.push(node)
+
+    this.debug && console.groupEnd()
+
+    return node
+  }
+
+  readXmlAttribute () {
+    this.debug && console.group('readXmlAttribute')
+
+    const attr = {
+      namespaceURI: null,
+      nodeType: NodeType.ATTRIBUTE_NODE,
+      nodeName: null,
+      name: null,
+      value: null,
+      typedValue: null
+    }
+
+    const nsRef = this.readS32()
+    const nameRef = this.readS32()
+    const valueRef = this.readS32()
+
+    if (nsRef > 0) {
+      attr.namespaceURI = this.strings[nsRef]
+    }
+
+    attr.nodeName = attr.name = this.strings[nameRef]
+
+    if (valueRef > 0) {
+      // some apk have versionName with special characters
+      if (attr.name === 'versionName') {
+        // only keep printable characters
+        // https://www.ascii-code.com/characters/printable-characters
+        this.strings[valueRef] = this.strings[valueRef].replace(/[^\x21-\x7E]/g, '')
+      }
+      attr.value = this.strings[valueRef]
+    }
+
+    attr.typedValue = this.readTypedValue()
+
+    this.debug && console.groupEnd()
+
+    return attr
+  }
+
+  readXmlElementEnd (/* header */) {
+    this.debug && console.group('readXmlCData')
+
+    /* const line = */ this.readU32()
+    /* const commentRef = */ this.readU32()
+    /* const nsRef = */ this.readS32()
+    /* const nameRef = */ this.readS32()
+
+    this.stack.pop()
+    this.parent = this.stack[this.stack.length - 1]
+
+    this.debug && console.groupEnd()
+
+    return null
+  }
+
+  readXmlCData (/* header */) {
+    this.debug && console.group('readXmlCData')
+
+    const cdata = {
+      namespaceURI: null,
+      nodeType: NodeType.CDATA_SECTION_NODE,
+      nodeName: '#cdata',
+      data: null,
+      typedValue: null
+    }
+
+    /* const line = */ this.readU32()
+    /* const commentRef = */ this.readU32()
+    const dataRef = this.readS32()
+
+    if (dataRef > 0) {
+      cdata.data = this.strings[dataRef]
+    }
+
+    cdata.typedValue = this.readTypedValue()
+
+    this.parent.childNodes.push(cdata)
+
+    this.debug && console.groupEnd()
+
+    return cdata
+  }
+
+  readNull (header) {
+    this.debug && console.group('readNull')
+    this.cursor += header.chunkSize - header.headerSize
+    this.debug && console.groupEnd()
+    return null
+  }
+
+  parse () {
+    this.debug && console.group('BinaryXmlParser.parse')
+
+    const xmlHeader = this.readChunkHeader()
+    if (xmlHeader.chunkType !== ChunkType.XML) {
+      throw new Error('Invalid XML header')
+    }
+
+    while (this.cursor < this.buffer.length) {
+      this.debug && console.group('chunk')
+      const start = this.cursor
+      const header = this.readChunkHeader()
+      switch (header.chunkType) {
+        case ChunkType.STRING_POOL:
+          this.readStringPool(header)
+          break
+        case ChunkType.XML_RESOURCE_MAP:
+          this.readResourceMap(header)
+          break
+        case ChunkType.XML_START_NAMESPACE:
+          this.readXmlNamespaceStart(header)
+          break
+        case ChunkType.XML_END_NAMESPACE:
+          this.readXmlNamespaceEnd(header)
+          break
+        case ChunkType.XML_START_ELEMENT:
+          this.readXmlElementStart(header)
+          break
+        case ChunkType.XML_END_ELEMENT:
+          this.readXmlElementEnd(header)
+          break
+        case ChunkType.XML_CDATA:
+          this.readXmlCData(header)
+          break
+        case ChunkType.NULL:
+          this.readNull(header)
+          break
+        default:
+          throw new Error(`Unsupported chunk type '${header.chunkType}'`)
+      }
+
+      // Ensure we consume the whole chunk
+      const end = start + header.chunkSize
+      if (this.cursor !== end) {
+        const diff = end - this.cursor
+        const type = header.chunkType.toString(16)
+        console.debug(`Cursor is off by ${diff} bytes at ${this.cursor} at supposed \
+end of chunk of type 0x${type}. The chunk started at offset ${start} and is \
+supposed to end at offset ${end}. Ignoring the rest of the chunk.`)
+        this.cursor = end
+      }
+
+      this.debug && console.groupEnd()
+    }
+
+    this.debug && console.groupEnd()
+
+    return this.document
+  }
+}
+
+module.exports = BinaryXmlParser

src/utils/app-info-parser/xml-parser/manifest.js

@@ -0,0 +1,216 @@
+// From https://github.com/openstf/adbkit-apkreader
+const BinaryXmlParser = require('./binary')
+
+const INTENT_MAIN = 'android.intent.action.MAIN'
+const CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER'
+
+class ManifestParser {
+  constructor (buffer, options = {}) {
+    this.buffer = buffer
+    this.xmlParser = new BinaryXmlParser(this.buffer, options)
+  }
+
+  collapseAttributes (element) {
+    const collapsed = Object.create(null)
+    for (let attr of Array.from(element.attributes)) {
+      collapsed[attr.name] = attr.typedValue.value
+    }
+    return collapsed
+  }
+
+  parseIntents (element, target) {
+    target.intentFilters = []
+    target.metaData = []
+
+    return element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'intent-filter': {
+          const intentFilter = this.collapseAttributes(element)
+
+          intentFilter.actions = []
+          intentFilter.categories = []
+          intentFilter.data = []
+
+          element.childNodes.forEach(element => {
+            switch (element.nodeName) {
+              case 'action':
+                intentFilter.actions.push(this.collapseAttributes(element))
+                break
+              case 'category':
+                intentFilter.categories.push(this.collapseAttributes(element))
+                break
+              case 'data':
+                intentFilter.data.push(this.collapseAttributes(element))
+                break
+            }
+          })
+
+          target.intentFilters.push(intentFilter)
+          break
+        }
+        case 'meta-data':
+          target.metaData.push(this.collapseAttributes(element))
+          break
+      }
+    })
+  }
+
+  parseApplication (element) {
+    const app = this.collapseAttributes(element)
+
+    app.activities = []
+    app.activityAliases = []
+    app.launcherActivities = []
+    app.services = []
+    app.receivers = []
+    app.providers = []
+    app.usesLibraries = []
+    app.metaData = []
+
+    element.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'activity': {
+          const activity = this.collapseAttributes(element)
+          this.parseIntents(element, activity)
+          app.activities.push(activity)
+          if (this.isLauncherActivity(activity)) {
+            app.launcherActivities.push(activity)
+          }
+          break
+        }
+        case 'activity-alias': {
+          const activityAlias = this.collapseAttributes(element)
+          this.parseIntents(element, activityAlias)
+          app.activityAliases.push(activityAlias)
+          if (this.isLauncherActivity(activityAlias)) {
+            app.launcherActivities.push(activityAlias)
+          }
+          break
+        }
+        case 'service': {
+          const service = this.collapseAttributes(element)
+          this.parseIntents(element, service)
+          app.services.push(service)
+          break
+        }
+        case 'receiver': {
+          const receiver = this.collapseAttributes(element)
+          this.parseIntents(element, receiver)
+          app.receivers.push(receiver)
+          break
+        }
+        case 'provider': {
+          const provider = this.collapseAttributes(element)
+
+          provider.grantUriPermissions = []
+          provider.metaData = []
+          provider.pathPermissions = []
+
+          element.childNodes.forEach(element => {
+            switch (element.nodeName) {
+              case 'grant-uri-permission':
+                provider.grantUriPermissions.push(this.collapseAttributes(element))
+                break
+              case 'meta-data':
+                provider.metaData.push(this.collapseAttributes(element))
+                break
+              case 'path-permission':
+                provider.pathPermissions.push(this.collapseAttributes(element))
+                break
+            }
+          })
+
+          app.providers.push(provider)
+          break
+        }
+        case 'uses-library':
+          app.usesLibraries.push(this.collapseAttributes(element))
+          break
+        case 'meta-data':
+          app.metaData.push(this.collapseAttributes(element))
+          break
+      }
+    })
+
+    return app
+  }
+
+  isLauncherActivity (activity) {
+    return activity.intentFilters.some(function (filter) {
+      const hasMain = filter.actions.some(action => action.name === INTENT_MAIN)
+      if (!hasMain) {
+        return false
+      }
+      return filter.categories.some(category => category.name === CATEGORY_LAUNCHER)
+    })
+  }
+
+  parse () {
+    const document = this.xmlParser.parse()
+    const manifest = this.collapseAttributes(document)
+
+    manifest.usesPermissions = []
+    manifest.usesPermissionsSDK23 = []
+    manifest.permissions = []
+    manifest.permissionTrees = []
+    manifest.permissionGroups = []
+    manifest.instrumentation = null
+    manifest.usesSdk = null
+    manifest.usesConfiguration = null
+    manifest.usesFeatures = []
+    manifest.supportsScreens = null
+    manifest.compatibleScreens = []
+    manifest.supportsGlTextures = []
+    manifest.application = Object.create(null)
+
+    document.childNodes.forEach(element => {
+      switch (element.nodeName) {
+        case 'uses-permission':
+          manifest.usesPermissions.push(this.collapseAttributes(element))
+          break
+        case 'uses-permission-sdk-23':
+          manifest.usesPermissionsSDK23.push(this.collapseAttributes(element))
+          break
+        case 'permission':
+          manifest.permissions.push(this.collapseAttributes(element))
+          break
+        case 'permission-tree':
+          manifest.permissionTrees.push(this.collapseAttributes(element))
+          break
+        case 'permission-group':
+          manifest.permissionGroups.push(this.collapseAttributes(element))
+          break
+        case 'instrumentation':
+          manifest.instrumentation = this.collapseAttributes(element)
+          break
+        case 'uses-sdk':
+          manifest.usesSdk = this.collapseAttributes(element)
+          break
+        case 'uses-configuration':
+          manifest.usesConfiguration = this.collapseAttributes(element)
+          break
+        case 'uses-feature':
+          manifest.usesFeatures.push(this.collapseAttributes(element))
+          break
+        case 'supports-screens':
+          manifest.supportsScreens = this.collapseAttributes(element)
+          break
+        case 'compatible-screens':
+          element.childNodes.forEach(screen => {
+            return manifest.compatibleScreens.push(this.collapseAttributes(screen))
+          })
+          break
+        case 'supports-gl-texture':
+          manifest.supportsGlTextures.push(this.collapseAttributes(element))
+          break
+        case 'application':
+          manifest.application = this.parseApplication(element)
+          break
+      }
+    })
+
+    return manifest
+  }
+}
+
+module.exports = ManifestParser

src/utils/app-info-parser/zip.js

@@ -0,0 +1,48 @@
+const Unzip = require('isomorphic-unzip')
+const { isBrowser, decodeNullUnicode } = require('./utils')
+
+class Zip {
+  constructor (file) {
+    if (isBrowser()) {
+      if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
+        throw new Error('Param error: [file] must be an instance of Blob or File in browser.')
+      }
+      this.file = file
+    } else {
+      if (typeof file !== 'string') {
+        throw new Error('Param error: [file] must be file path in Node.')
+      }
+      this.file = require('path').resolve(file)
+    }
+    this.unzip = new Unzip(this.file)
+  }
+
+  /**
+   * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+   * @param {Array} regexps // regexps for matching files
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */
+  getEntries (regexps, type = 'buffer') {
+    regexps = regexps.map(regex => decodeNullUnicode(regex))
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer(regexps, { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers)
+      })
+    })
+  }
+  /**
+   * get entry by regex, return an instance of Buffer or Blob
+   * @param {Regex} regex // regex for matching file
+   * @param {String} type // return type, can be buffer or blob, default buffer
+   */
+  getEntry (regex, type = 'buffer') {
+    regex = decodeNullUnicode(regex)
+    return new Promise((resolve, reject) => {
+      this.unzip.getBuffer([regex], { type }, (err, buffers) => {
+        err ? reject(err) : resolve(buffers[regex])
+      })
+    })
+  }
+}
+
+module.exports = Zip

src/utils/index.js

@@ -0,0 +1,153 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import pkg from '../../package.json';
+import AppInfoParser from './app-info-parser';
+
+import read from 'read';
+
+export function question(query, password) {
+  if (NO_INTERACTIVE) {
+    return Promise.resolve('');
+  }
+  return new Promise((resolve, reject) =>
+    read(
+      {
+        prompt: query,
+        silent: password,
+        replace: password ? '*' : undefined,
+      },
+      (err, result) => (err ? reject(err) : resolve(result)),
+    ),
+  );
+}
+
+export function translateOptions(options) {
+  const ret = {};
+  for (let key in options) {
+    const v = options[key];
+    if (typeof v === 'string') {
+      ret[key] = v.replace(/\$\{(\w+)\}/g, function (v, n) {
+        return options[n] || process.env[n] || v;
+      });
+    } else {
+      ret[key] = v;
+    }
+  }
+  return ret;
+}
+
+export function getRNVersion() {
+  const version = JSON.parse(
+    fs.readFileSync(
+      require.resolve('react-native/package.json', {
+        paths: [process.cwd()],
+      }),
+    ),
+  ).version;
+
+  // We only care about major and minor version.
+  const match = /^(\d+)\.(\d+)\./.exec(version);
+  return {
+    version,
+    major: match[1] | 0,
+    minor: match[2] | 0,
+  };
+}
+
+export async function getApkInfo(fn) {
+  const appInfoParser = new AppInfoParser(fn);
+  const bundleFile = await appInfoParser.parser.getEntry(
+    /assets\/index.android.bundle/,
+  );
+  if (!bundleFile) {
+    throw new Error(
+      '找不到bundle文件。请确保此apk为release版本，且bundle文件名为默认的index.android.bundle',
+    );
+  }
+  const updateJsonFile = await appInfoParser.parser.getEntry(
+    /res\/raw\/update.json/,
+  );
+  let appCredential = {};
+  if (updateJsonFile) {
+    appCredential = JSON.parse(updateJsonFile.toString()).android;
+  }
+  const { versionName, application } = await appInfoParser.parse();
+  let buildTime = 0;
+  if (Array.isArray(application.metaData)) {
+    for (const meta of application.metaData) {
+      if (meta.name === 'pushy_build_time') {
+        buildTime = meta.value[0];
+      }
+    }
+  }
+  if (buildTime == 0) {
+    throw new Error(
+      '无法获取此包的编译时间戳。请更新react-native-update到最新版本后重新打包上传。',
+    );
+  }
+  return { versionName, buildTime, ...appCredential };
+}
+
+export async function getIpaInfo(fn) {
+  const appInfoParser = new AppInfoParser(fn);
+  const bundleFile = await appInfoParser.parser.getEntry(
+    /payload\/.+?\.app\/main.jsbundle/,
+  );
+  if (!bundleFile) {
+    throw new Error(
+      '找不到bundle文件。请确保此ipa为release版本，且bundle文件名为默认的main.jsbundle',
+    );
+  }
+  const updateJsonFile = await appInfoParser.parser.getEntry(
+    /payload\/.+?\.app\/assets\/update.json/,
+  );
+  let appCredential = {};
+  if (updateJsonFile) {
+    appCredential = JSON.parse(updateJsonFile.toString()).ios;
+  }
+  const { CFBundleShortVersionString: versionName } =
+    await appInfoParser.parse();
+  let buildTimeTxtBuffer = await appInfoParser.parser.getEntry(
+    /payload\/.+?\.app\/pushy_build_time.txt/,
+  );
+  if (!buildTimeTxtBuffer) {
+    // Not in root bundle when use `use_frameworks`
+    buildTimeTxtBuffer = await appInfoParser.parser.getEntry(
+      /payload\/.+?\.app\/frameworks\/react_native_update.framework\/pushy_build_time.txt/,
+    );
+  }
+  if (!buildTimeTxtBuffer) {
+    throw new Error(
+      '无法获取此包的编译时间戳。请更新react-native-update到最新版本后重新打包上传。',
+    );
+  }
+  const buildTime = buildTimeTxtBuffer.toString().replace('\n', '');
+  return { versionName, buildTime, ...appCredential };
+}
+
+const localDir = path.resolve(os.homedir(), '.pushy');
+fs.ensureDirSync(localDir);
+export function saveToLocal(originPath, destName) {
+  // TODO
+  // const destPath = path.join(localDir, destName);
+  // fs.ensureDirSync(path.dirname(destPath));
+  // fs.copyFileSync(originPath, destPath);
+}
+
+export function printVersionCommand() {
+  console.log('react-native-update-cli: ' + pkg.version);
+  try {
+    const PACKAGE_JSON_PATH = require.resolve(
+      'react-native-update/package.json',
+      {
+        paths: [process.cwd()],
+      },
+    );
+    console.log('react-native-update: ' + require(PACKAGE_JSON_PATH).version);
+  } catch (e) {
+    console.log('react-native-update: 无法获取版本号，请在项目目录中运行命令');
+  }
+}
+
+export const pricingPageUrl = 'https://pushy.reactnative.cn/pricing.html';

src/versions.js

@@ -0,0 +1,205 @@
+import { get, post, put, uploadFile } from './api';
+import { question, saveToLocal } from './utils';
+
+import { checkPlatform, getSelectedApp } from './app';
+import { choosePackage } from './package';
+import { compare } from 'compare-versions';
+
+async function showVersion(appId, offset) {
+  const { data, count } = await get(`/app/${appId}/version/list`);
+  console.log(`Offset ${offset}`);
+  for (const version of data) {
+    let packageInfo = version.packages
+      .slice(0, 3)
+      .map((v) => v.name)
+      .join(', ');
+    const count = version.packages.length;
+    if (count > 3) {
+      packageInfo += `...and ${count - 3} more`;
+    }
+    if (count === 0) {
+      packageInfo = `(no package)`;
+    } else {
+      packageInfo = `[${packageInfo}]`;
+    }
+    console.log(
+      `${version.id}) ${version.hash.slice(0, 8)} ${
+        version.name
+      } ${packageInfo}`,
+    );
+  }
+  return data;
+}
+
+async function listVersions(appId) {
+  let offset = 0;
+  while (true) {
+    await showVersion(appId, offset);
+    const cmd = await question('page Up/page Down/Begin/Quit(U/D/B/Q)');
+    switch (cmd.toLowerCase()) {
+      case 'u':
+        offset = Math.max(0, offset - 10);
+        break;
+      case 'd':
+        offset += 10;
+        break;
+      case 'b':
+        offset = 0;
+        break;
+      case 'q':
+        return;
+    }
+  }
+}
+
+async function chooseVersion(appId) {
+  let offset = 0;
+  while (true) {
+    const data = await showVersion(appId, offset);
+    const cmd = await question(
+      'Enter versionId or page Up/page Down/Begin(U/D/B)',
+    );
+    switch (cmd.toLowerCase()) {
+      case 'U':
+        offset = Math.max(0, offset - 10);
+        break;
+      case 'D':
+        offset += 10;
+        break;
+      case 'B':
+        offset = 0;
+        break;
+      default: {
+        const v = data.find((v) => v.id === (cmd | 0));
+        if (v) {
+          return v;
+        }
+      }
+    }
+  }
+}
+
+export const commands = {
+  publish: async function ({ args, options }) {
+    const fn = args[0];
+    const { name, description, metaInfo } = options;
+
+    if (!fn || !fn.endsWith('.ppk')) {
+      throw new Error(
+        '使用方法: pushy publish ppk后缀文件 --platform ios|android',
+      );
+    }
+
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { appId } = await getSelectedApp(platform);
+
+    const { hash } = await uploadFile(fn);
+
+    const { id } = await post(`/app/${appId}/version/create`, {
+      name: name || (await question('输入版本名称: ')) || '(未命名)',
+      hash,
+      description: description || (await question('输入版本描述:')),
+      metaInfo: metaInfo || (await question('输入自定义的 meta info:')),
+    });
+    // TODO local diff
+    saveToLocal(fn, `${appId}/ppk/${id}.ppk`);
+    console.log(`已成功上传新热更包（id: ${id}）`);
+
+    const v = await question('是否现在将此热更应用到原生包上？(Y/N)');
+    if (v.toLowerCase() === 'y') {
+      await this.update({ args: [], options: { versionId: id, platform } });
+    }
+  },
+  versions: async function ({ options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { appId } = await getSelectedApp(platform);
+    await listVersions(appId);
+  },
+  update: async function ({ args, options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { appId } = await getSelectedApp(platform);
+    const versionId = options.versionId || (await chooseVersion(appId)).id;
+
+    let pkgId;
+    let pkgVersion = options.packageVersion;
+    let minPkgVersion = options.minPackageVersion;
+    let maxPkgVersion = options.maxPackageVersion;
+    if (pkgVersion) {
+      pkgVersion = pkgVersion.trim();
+      const { data } = await get(`/app/${appId}/package/list?limit=1000`);
+      const pkg = data.find((d) => d.name === pkgVersion);
+      if (pkg) {
+        pkgId = pkg.id;
+      } else {
+        throw new Error(`未查询到匹配原生版本：${pkgVersion}`);
+      }
+    }
+    if (minPkgVersion) {
+      minPkgVersion = String(minPkgVersion).trim();
+      const { data } = await get(`/app/${appId}/package/list?limit=1000`);
+      const pkgs = data.filter((d) => compare(d.name, minPkgVersion, '>='));
+      if (pkgs.length === 0) {
+        throw new Error(
+          `未查询到 >= ${minPkgVersion} 的原生版本`,
+        );
+      }
+      for (const pkg of pkgs) {
+        await put(`/app/${appId}/package/${pkg.id}`, {
+          versionId,
+        });
+        console.log(`已将版本 ${versionId} 绑定到原生版本 ${pkg.name}`);
+      }
+      console.log(`操作完成，共已绑定 ${pkgs.length} 个原生版本`);
+      return;
+    }
+    if (maxPkgVersion) {
+      maxPkgVersion = String(maxPkgVersion).trim();
+      const { data } = await get(`/app/${appId}/package/list?limit=1000`);
+      const pkgs = data.filter((d) => compare(d.name, maxPkgVersion, '<='));
+      if (pkgs.length === 0) {
+        throw new Error(
+          `未查询到 <= ${maxPkgVersion} 的原生版本`,
+        );
+      }
+      for (const pkg of pkgs) {
+        await put(`/app/${appId}/package/${pkg.id}`, {
+          versionId,
+        });
+        console.log(`已将版本 ${versionId} 绑定到原生版本 ${pkg.name}`);
+      }
+      console.log(`操作完成，共已绑定 ${pkgs.length} 个原生版本`);
+      return;
+    }
+    if (!pkgId) {
+      pkgId = options.packageId || (await choosePackage(appId)).id;
+    }
+
+    if (!pkgId) {
+      throw new Error('请提供 packageId 或 packageVersion 参数');
+    }
+    await put(`/app/${appId}/package/${pkgId}`, {
+      versionId,
+    });
+    console.log('操作成功');
+  },
+  updateVersionInfo: async function ({ args, options }) {
+    const platform = checkPlatform(
+      options.platform || (await question('平台(ios/android):')),
+    );
+    const { appId } = await getSelectedApp(platform);
+    const versionId = options.versionId || (await chooseVersion(appId)).id;
+
+    const updateParams = {};
+    options.name && (updateParams.name = options.name);
+    options.description && (updateParams.description = options.description);
+    options.metaInfo && (updateParams.metaInfo = options.metaInfo);
+    await put(`/app/${appId}/version/${versionId}`, updateParams);
+    console.log('操作成功');
+  },
+};