yakuza0 2.23.30 → 2.23.32-beta.2

package/cli/index.js

@@ -5,10 +5,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.run = undefined;
 
+var _from = require('babel-runtime/core-js/array/from');
+
+var _from2 = _interopRequireDefault(_from);
+
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
+var _isInteger = require('babel-runtime/core-js/number/is-integer');
+
+var _isInteger2 = _interopRequireDefault(_isInteger);
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
 var _stringify = require('babel-runtime/core-js/json/stringify');
 
 var _stringify2 = _interopRequireDefault(_stringify);
 
+var _isFinite = require('babel-runtime/core-js/number/is-finite');
+
+var _isFinite2 = _interopRequireDefault(_isFinite);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
 var _regenerator = require('babel-runtime/regenerator');
 
 var _regenerator2 = _interopRequireDefault(_regenerator);
@@ -21,6 +49,18 @@ var _semver = require('semver');
 
 var _semver2 = _interopRequireDefault(_semver);
 
+var _crypto = require('crypto');
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+require('isomorphic-fetch');
+
 var _paths = require('../config/paths');
 
 var _paths2 = _interopRequireDefault(_paths);
@@ -29,10 +69,6 @@ var _inclusive = require('../utils/inclusive.js');
 
 var _inclusive2 = _interopRequireDefault(_inclusive);
 
-var _midfilter = require('../utils/midfilter.js');
-
-var _midfilter2 = _interopRequireDefault(_midfilter);
-
 var _compress = require('../utils/compress.js');
 
 var _compress2 = _interopRequireDefault(_compress);
@@ -45,221 +81,1457 @@ var _package = require('../package.json');
 
 var _package2 = _interopRequireDefault(_package);
 
-var _cli = require('@nuxt/cli');
+var _cli = require('@nuxt/cli');
+
+var nuxtCli = _interopRequireWildcard(_cli);
+
+var _consola = require('consola');
+
+var _consola2 = _interopRequireDefault(_consola);
+
+var _msg = require('../config/msg');
+
+var _os = require('os');
+
+var _os2 = _interopRequireDefault(_os);
+
+var _rimraf = require('rimraf');
+
+var _rimraf2 = _interopRequireDefault(_rimraf);
+
+var _decompress = require('decompress');
+
+var _decompress2 = _interopRequireDefault(_decompress);
+
+var _verify = require('../utils/verify');
+
+var _server = require('yakuza1/server');
+
+var _jsonFormat = require('json-format');
+
+var _jsonFormat2 = _interopRequireDefault(_jsonFormat);
+
+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 }; }
+
+process.env.YK_USAGE = 'CLI';
+
+var _require = require('child_process'),
+    execSync = _require.execSync,
+    spawn = _require.spawn;
+
+// const util = require('util');
+// const spawn = util.promisify(require('child_process').spawn);
+
+if (_semver2.default.satisfies(process.versions.node, '>= 6.0.0')) require('v8-compile-cache');
+
+var params = {
+  serverPath: '../server',
+  serverLite: '../server/mode/lite'
+};
+
+// const watchChange = (watchPaths = [], callback) => {
+//   const watcher = chokidar.watch(watchPaths, {
+//     persistent: true,
+//     usePolling: true,
+//   });
+//
+//   watcher.on('change', callback);
+// };
+
+var gi = function () {
+  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    var app, dkyModeDef, ykServerEnv, enabledAll, appsNoneExit, apps, _ref2, conf;
+
+    return _regenerator2.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            app = options.app || process.env.npm_config_yk0_build_app || process.env.npm_config_y0ba;
+            dkyModeDef = process.env.NODE_ENV === 'development' ? 'dev' : 'normal';
+            ykServerEnv = process.env.YK_SERVER_ENV || options.ykServerEnv || 'local';
+            enabledAll = process.env.YK_MACHINE_TYPE === 'workstation';
+            appsNoneExit = typeof options.appsNoneExit === 'boolean' ? options.appsNoneExit : true;
+            // console.log(ykServerEnv);
+
+            if (!_paths2.default.access(_paths2.default.envPath())) {
+              _consola2.default.error(_msg.errMsg["server.config.none"]);
+              process.exit(1);
+            }
+
+            apps = [];
+
+            if (typeof app === 'string') {
+              apps = app.split(',').map(function (a) {
+                return 'app.' + a;
+              });
+            }
+
+            _paths2.default.interfereFile.forEach(function (p) {
+              _rimraf2.default.sync(p);
+            });
+            _context.next = 11;
+            return (0, _inclusive2.default)({
+              apps: apps,
+              enabledAll: enabledAll,
+              ykServerEnv: ykServerEnv,
+              pkg: _package2.default,
+              dkyModeDef: dkyModeDef
+            });
+
+          case 11:
+            _ref2 = _context.sent;
+            conf = _ref2.conf;
+
+            if (!conf.extend.plugins.husky.enabled) {
+              _context.next = 18;
+              break;
+            }
+
+            _context.next = 16;
+            return (0, _verify.commitInit)();
+
+          case 16:
+            _context.next = 19;
+            break;
+
+          case 18:
+            _paths2.default.rm(_paths2.default.gitHooksCommitMsg);
+
+          case 19:
+
+            if (conf.dev) {
+              // conf
+              (0, _server.watchDirChange)([_paths2.default.ykConfigJs, _paths2.default.envPath(), _paths2.default.envPath(ykServerEnv)], function () {
+                (0, _inclusive2.default)({
+                  apps: apps,
+                  enabledAll: enabledAll,
+                  ykServerEnv: ykServerEnv,
+                  pkg: _package2.default,
+                  dkyModeDef: 'dev'
+                }).then();
+              }, { event: "change" });
+            }
+
+            if (apps.length === 0) {
+              apps = _server._.compact(_server._.map(conf.router.config, function (v, key) {
+                if (v.enabled) {
+                  return key;
+                }
+              }));
+            }
+
+            if (apps.length === 0 && appsNoneExit) {
+              _consola2.default.error(_msg.errMsg["server.apps.none"]);
+              process.exit(1);
+            }
+            return _context.abrupt('return', { conf: conf, apps: apps });
+
+          case 23:
+          case 'end':
+            return _context.stop();
+        }
+      }
+    }, _callee, undefined);
+  }));
+
+  return function gi() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var alias = function alias() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  _server.global.__cln_appName__ = options.appName;
+};
+
+var execCmd = function execCmd(cmd) {
+  execSync(cmd, { shell: true, stdio: 'inherit' });
+};
+
+var BUILD_HEARTBEAT_FILE = '.build.heartbeat';
+
+var createBuildHeartbeat = function createBuildHeartbeat() {
+  var apps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+  var heartbeatDir = _paths2.default.ykServerPath;
+  var heartbeatPath = _path2.default.join(heartbeatDir, BUILD_HEARTBEAT_FILE);
+  var timer = null;
+
+  var writeHeartbeat = function writeHeartbeat() {
+    _paths2.default.mkdir(heartbeatDir);
+    _paths2.default.write(heartbeatPath, (0, _jsonFormat2.default)({
+      pid: process.pid,
+      status: 'building',
+      apps: apps,
+      updatedAt: new Date().toISOString()
+    }));
+  };
+
+  writeHeartbeat();
+  timer = setInterval(writeHeartbeat, 1000);
+
+  return {
+    heartbeatPath: heartbeatPath,
+    stop: function stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      _paths2.default.rm(heartbeatPath);
+    }
+  };
+};
+
+var spawnBuildProcess = function spawnBuildProcess(appName) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  return new _promise2.default(function (resolve, reject) {
+    var activeChildren = options.activeChildren,
+        abortState = options.abortState;
+
+    var child = spawn(process.execPath, [_path2.default.join(_paths2.default.ykRoot, 'bin', 'yk.js'), 'bd', appName], {
+      stdio: 'inherit'
+    });
+    var settled = false;
+
+    if (activeChildren) {
+      activeChildren.add(child);
+    }
+
+    var cleanup = function cleanup() {
+      if (activeChildren) {
+        activeChildren.delete(child);
+      }
+    };
+
+    var settleReject = function settleReject(error) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+
+    var settleResolve = function settleResolve() {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve();
+    };
+
+    child.on('error', function (error) {
+      if (abortState) {
+        abortState.stopped = true;
+      }
+      settleReject(error);
+    });
+    child.on('close', function (exitCode, signal) {
+      if (abortState && abortState.stopped && abortState.error && signal === 'SIGTERM') {
+        settleResolve();
+        return;
+      }
+      if (signal) {
+        if (abortState) {
+          abortState.stopped = true;
+        }
+        settleReject(new Error('Build interrupted for ' + appName + ' with signal ' + signal));
+        return;
+      }
+      if (exitCode !== 0) {
+        if (abortState) {
+          abortState.stopped = true;
+        }
+        settleReject(new Error('Build failed for ' + appName + ' with exit code ' + exitCode));
+        return;
+      }
+      settleResolve();
+    });
+  });
+};
+
+var CLN_CI_DOWNLOAD_BASE_URL = 'https://registry-pxnpm.rdc.nfjbill.ren:20021/__static/srv/downloads';
+var CLN_CI_INDEX_URL = CLN_CI_DOWNLOAD_BASE_URL + '/cln-ci/stable/index.json';
+var CLN_CI_PRODUCT = 'cln-ci';
+var CLN_CI_CHANNEL = 'stable';
+var CLN_CI_CONNECT_TIMEOUT = 2000;
+
+var resolveDownloadUrl = function resolveDownloadUrl(urlOrPath) {
+  if (/^https?:\/\//i.test(urlOrPath)) {
+    return urlOrPath;
+  }
+  return CLN_CI_DOWNLOAD_BASE_URL + '/' + String(urlOrPath).replace(/^\/+/, '');
+};
+
+var getClnCiPlatform = function getClnCiPlatform() {
+  var osMap = {
+    win32: 'windows',
+    darwin: 'darwin',
+    linux: 'linux'
+  };
+  var archMap = {
+    x64: 'amd64',
+    arm64: 'arm64'
+  };
+  var osName = osMap[process.platform];
+  var archName = archMap[process.arch];
+
+  if (!osName || !archName) {
+    throw new Error('Unsupported platform: ' + process.platform + '/' + process.arch);
+  }
+
+  return { os: osName, arch: archName };
+};
+
+var resolveCurrentPlatformId = function resolveCurrentPlatformId() {
+  var platformKey = getClnCiPlatform();
+  return platformKey.os + '-' + platformKey.arch;
+};
+
+var fetchJson = function () {
+  var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(url) {
+    var res;
+    return _regenerator2.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return fetch(url, { headers: { accept: 'application/json' } });
+
+          case 2:
+            res = _context2.sent;
+
+            if (res.ok) {
+              _context2.next = 5;
+              break;
+            }
+
+            throw new Error('Failed to fetch ' + url + ': ' + res.status + ' ' + res.statusText);
+
+          case 5:
+            _context2.next = 7;
+            return res.json();
+
+          case 7:
+            return _context2.abrupt('return', _context2.sent);
+
+          case 8:
+          case 'end':
+            return _context2.stop();
+        }
+      }
+    }, _callee2, undefined);
+  }));
+
+  return function fetchJson(_x5) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+var fetchWithTimeout = function () {
+  var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(url) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : CLN_CI_CONNECT_TIMEOUT;
+    return _regenerator2.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return _promise2.default.race([fetch(url, options), new _promise2.default(function (_, reject) {
+              setTimeout(function () {
+                reject(new Error('Request timeout for ' + url));
+              }, timeout);
+            })]);
+
+          case 2:
+            return _context3.abrupt('return', _context3.sent);
+
+          case 3:
+          case 'end':
+            return _context3.stop();
+        }
+      }
+    }, _callee3, undefined);
+  }));
+
+  return function fetchWithTimeout(_x8) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+var formatBytes = function formatBytes(bytes) {
+  if (!(0, _isFinite2.default)(bytes)) {
+    return '0 B';
+  }
+  if (bytes < 1024) {
+    return bytes + ' B';
+  }
+  var units = ['KB', 'MB', 'GB', 'TB'];
+  var size = bytes / 1024;
+  var unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+  return size.toFixed(1) + ' ' + units[unitIndex];
+};
+
+var renderDownloadProgress = function renderDownloadProgress(downloaded, total) {
+  if (!process.stdout.isTTY) {
+    return;
+  }
+  if (!total) {
+    process.stdout.write('\rDownloading ' + formatBytes(downloaded));
+    return;
+  }
+
+  var width = 24;
+  var percent = Math.min(downloaded / total, 1);
+  var filled = Math.round(width * percent);
+  var bar = '' + '='.repeat(filled) + ' '.repeat(width - filled);
+  process.stdout.write('\rDownloading [' + bar + '] ' + (percent * 100).toFixed(1) + '% (' + formatBytes(downloaded) + '/' + formatBytes(total) + ')');
+};
+
+var finalizeDownloadProgress = function finalizeDownloadProgress() {
+  if (process.stdout.isTTY) {
+    process.stdout.write('\n');
+  }
+};
+
+var downloadFile = function () {
+  var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(url, destination) {
+    var res, tempPath, buffer;
+    return _regenerator2.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return fetch(url);
+
+          case 2:
+            res = _context4.sent;
+
+            if (res.ok) {
+              _context4.next = 5;
+              break;
+            }
+
+            throw new Error('Failed to download ' + url + ': ' + res.status + ' ' + res.statusText);
+
+          case 5:
+            tempPath = destination + '.download';
+            _context4.next = 8;
+            return _fs2.default.promises.mkdir(_path2.default.dirname(destination), { recursive: true });
+
+          case 8:
+            _context4.prev = 8;
+            _context4.next = 11;
+            return res.buffer();
+
+          case 11:
+            buffer = _context4.sent;
+
+            renderDownloadProgress(buffer.length, buffer.length);
+            _context4.next = 15;
+            return _fs2.default.promises.writeFile(tempPath, buffer);
+
+          case 15:
+            finalizeDownloadProgress();
+            _context4.next = 18;
+            return _fs2.default.promises.rename(tempPath, destination);
+
+          case 18:
+            _context4.next = 26;
+            break;
+
+          case 20:
+            _context4.prev = 20;
+            _context4.t0 = _context4['catch'](8);
+
+            finalizeDownloadProgress();
+            _context4.next = 25;
+            return _fs2.default.promises.rm(tempPath, { force: true }).catch(function () {
+              return undefined;
+            });
+
+          case 25:
+            throw _context4.t0;
+
+          case 26:
+          case 'end':
+            return _context4.stop();
+        }
+      }
+    }, _callee4, undefined, [[8, 20]]);
+  }));
+
+  return function downloadFile(_x9, _x10) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+
+var sha256File = function () {
+  var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(filePath) {
+    var hash, stream;
+    return _regenerator2.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            hash = (0, _crypto.createHash)('sha256');
+            stream = _fs2.default.createReadStream(filePath);
+            _context5.next = 4;
+            return new _promise2.default(function (resolve, reject) {
+              stream.on('error', reject);
+              stream.on('data', function (chunk) {
+                return hash.update(chunk);
+              });
+              stream.on('end', resolve);
+            });
+
+          case 4:
+            return _context5.abrupt('return', hash.digest('hex'));
+
+          case 5:
+          case 'end':
+            return _context5.stop();
+        }
+      }
+    }, _callee5, undefined);
+  }));
+
+  return function sha256File(_x11) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+var tryReplaceFile = function () {
+  var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(sourcePath, targetPath) {
+    return _regenerator2.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.prev = 0;
+            _context6.next = 3;
+            return _fs2.default.promises.rename(sourcePath, targetPath);
+
+          case 3:
+            return _context6.abrupt('return');
+
+          case 6:
+            _context6.prev = 6;
+            _context6.t0 = _context6['catch'](0);
+
+            if (!(_context6.t0.code !== 'EEXIST')) {
+              _context6.next = 10;
+              break;
+            }
+
+            throw _context6.t0;
+
+          case 10:
+            _context6.prev = 10;
+            _context6.next = 13;
+            return _fs2.default.promises.rm(targetPath, { force: true });
+
+          case 13:
+            _context6.next = 19;
+            break;
+
+          case 15:
+            _context6.prev = 15;
+            _context6.t1 = _context6['catch'](10);
+
+            if (['EBUSY', 'EPERM', 'ENOENT'].includes(_context6.t1.code)) {
+              _context6.next = 19;
+              break;
+            }
+
+            throw _context6.t1;
+
+          case 19:
+            _context6.next = 21;
+            return _fs2.default.promises.rename(sourcePath, targetPath);
+
+          case 21:
+          case 'end':
+            return _context6.stop();
+        }
+      }
+    }, _callee6, undefined, [[0, 6], [10, 15]]);
+  }));
+
+  return function tryReplaceFile(_x12, _x13) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+
+var moveExtractedBinary = function () {
+  var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7(extractedPath, outputDir, entry) {
+    var targetPath, entryDir, entryName, tempName, tempEntry, tempPath;
+    return _regenerator2.default.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            targetPath = _path2.default.join(outputDir, entry);
+            _context7.next = 3;
+            return _fs2.default.promises.mkdir(_path2.default.dirname(targetPath), { recursive: true });
+
+          case 3:
+            _context7.prev = 3;
+            _context7.next = 6;
+            return tryReplaceFile(extractedPath, targetPath);
+
+          case 6:
+            return _context7.abrupt('return', { entryPath: targetPath, entryRelative: entry });
+
+          case 9:
+            _context7.prev = 9;
+            _context7.t0 = _context7['catch'](3);
+
+            if (['EBUSY', 'EPERM'].includes(_context7.t0.code)) {
+              _context7.next = 13;
+              break;
+            }
+
+            throw _context7.t0;
+
+          case 13:
+            entryDir = _path2.default.dirname(entry);
+            entryName = _path2.default.basename(entry);
+            tempName = entryName + '.tmp-' + Date.now() + '-' + Math.random().toString(16).slice(2, 8);
+            tempEntry = _path2.default.join(entryDir === '.' ? '' : entryDir, tempName);
+            tempPath = _path2.default.join(outputDir, tempEntry);
+            _context7.next = 20;
+            return _fs2.default.promises.mkdir(_path2.default.dirname(tempPath), { recursive: true });
+
+          case 20:
+            _context7.next = 22;
+            return _fs2.default.promises.rename(extractedPath, tempPath);
+
+          case 22:
+            return _context7.abrupt('return', { entryPath: tempPath, entryRelative: entry, tempEntry: tempEntry });
+
+          case 23:
+          case 'end':
+            return _context7.stop();
+        }
+      }
+    }, _callee7, undefined, [[3, 9]]);
+  }));
+
+  return function moveExtractedBinary(_x14, _x15, _x16) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+
+var extractZip = function () {
+  var _ref9 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8(archivePath, outputDir, entry) {
+    var tempDir, extractedPath;
+    return _regenerator2.default.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            tempDir = _path2.default.join(outputDir, '.tmp-' + Date.now() + '-' + Math.random().toString(16).slice(2));
+            _context8.next = 3;
+            return _fs2.default.promises.mkdir(tempDir, { recursive: true });
+
+          case 3:
+            _context8.prev = 3;
+            _context8.next = 6;
+            return (0, _decompress2.default)(archivePath, tempDir);
+
+          case 6:
+            extractedPath = _path2.default.join(tempDir, entry);
+
+            if (_fs2.default.existsSync(extractedPath)) {
+              _context8.next = 9;
+              break;
+            }
+
+            throw new Error('Expected entry ' + entry + ' was not found after extraction.');
+
+          case 9:
+            _context8.next = 11;
+            return moveExtractedBinary(extractedPath, outputDir, entry);
+
+          case 11:
+            return _context8.abrupt('return', _context8.sent);
+
+          case 12:
+            _context8.prev = 12;
+            _context8.next = 15;
+            return _fs2.default.promises.rm(tempDir, { recursive: true, force: true }).catch(function () {
+              return undefined;
+            });
+
+          case 15:
+            return _context8.finish(12);
+
+          case 16:
+          case 'end':
+            return _context8.stop();
+        }
+      }
+    }, _callee8, undefined, [[3,, 12, 16]]);
+  }));
+
+  return function extractZip(_x17, _x18, _x19) {
+    return _ref9.apply(this, arguments);
+  };
+}();
+
+var ensureProjectEnv = function ensureProjectEnv() {
+  if (process.env.CI_PROJECT_NAME && process.env.CI_PROJECT_ID) {
+    return {
+      CI_PROJECT_NAME: process.env.CI_PROJECT_NAME,
+      CI_PROJECT_ID: process.env.CI_PROJECT_ID
+    };
+  }
+
+  var projectRoot = process.cwd();
+  var baseDir = _path2.default.join(_os2.default.homedir(), '.cln-plus', 'projects');
+  var indexPath = _path2.default.join(baseDir, 'index.json');
+  var legacyEnvPath = _path2.default.join(projectRoot, '.cln-plus', 'ci-project.json');
+  var projectKey = (0, _crypto.createHash)('sha256').update(projectRoot).digest('hex').slice(0, 12);
+  var projectDir = _path2.default.join(baseDir, projectKey);
+  var envPath = _path2.default.join(projectDir, 'ci-project.json');
+  var projectId = null;
+  var indexData = {};
+
+  if (_fs2.default.existsSync(indexPath)) {
+    try {
+      indexData = JSON.parse(_fs2.default.readFileSync(indexPath, 'utf-8'));
+    } catch (error) {
+      indexData = {};
+    }
+  }
+
+  var indexed = indexData[projectRoot];
+  if (indexed && indexed.dir) {
+    projectDir = indexed.dir;
+    envPath = _path2.default.join(projectDir, 'ci-project.json');
+  }
+  if (indexed && indexed.id && /^\d{3}$/.test(indexed.id)) {
+    projectId = indexed.id;
+  }
+
+  var readProjectId = function readProjectId(filePath) {
+    try {
+      var parsed = JSON.parse(_fs2.default.readFileSync(filePath, 'utf-8'));
+      if (parsed.id && /^\d{3}$/.test(parsed.id)) {
+        return parsed.id;
+      }
+    } catch (error) {}
+    return null;
+  };
+
+  if (!projectId && _fs2.default.existsSync(envPath)) {
+    projectId = readProjectId(envPath);
+  }
+
+  if (!projectId && _fs2.default.existsSync(legacyEnvPath)) {
+    projectId = readProjectId(legacyEnvPath);
+  }
+
+  if (!projectId) {
+    projectId = String(Math.floor(100 + Math.random() * 900));
+  }
+
+  _fs2.default.mkdirSync(projectDir, { recursive: true });
+  if (!_fs2.default.existsSync(envPath)) {
+    _fs2.default.writeFileSync(envPath, (0, _stringify2.default)({ id: projectId }, null, 2));
+  }
+  _fs2.default.writeFileSync(_path2.default.join(projectDir, 'project.json'), (0, _stringify2.default)({ root: projectRoot }, null, 2));
+
+  indexData[projectRoot] = { id: projectId, dir: projectDir };
+  _fs2.default.mkdirSync(baseDir, { recursive: true });
+  _fs2.default.writeFileSync(indexPath, (0, _stringify2.default)(indexData, null, 2));
+
+  return {
+    CI_PROJECT_NAME: 'cln-local',
+    CI_PROJECT_ID: projectId
+  };
+};
+
+var createProjectEnv = function createProjectEnv() {
+  return (0, _extends3.default)({}, process.env, ensureProjectEnv());
+};
+
+var getClnCiRootDir = function getClnCiRootDir() {
+  return _path2.default.join(process.cwd(), '.cln-ci');
+};
+
+var getClnCiBinRootDir = function getClnCiBinRootDir() {
+  return _path2.default.join(getClnCiRootDir(), 'bin');
+};
+
+var getClnCiCacheDir = function getClnCiCacheDir(platformId) {
+  return _path2.default.join(getClnCiBinRootDir(), platformId);
+};
+
+var ensureClnCiDir = function () {
+  var _ref10 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(dirPath) {
+    return _regenerator2.default.wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            _context9.next = 2;
+            return _fs2.default.promises.mkdir(dirPath, { recursive: true });
+
+          case 2:
+          case 'end':
+            return _context9.stop();
+        }
+      }
+    }, _callee9, undefined);
+  }));
+
+  return function ensureClnCiDir(_x20) {
+    return _ref10.apply(this, arguments);
+  };
+}();
+
+var removeDirIfEmpty = function () {
+  var _ref11 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10(dirPath) {
+    var entries;
+    return _regenerator2.default.wrap(function _callee10$(_context10) {
+      while (1) {
+        switch (_context10.prev = _context10.next) {
+          case 0:
+            _context10.prev = 0;
+            _context10.next = 3;
+            return _fs2.default.promises.readdir(dirPath);
+
+          case 3:
+            entries = _context10.sent;
+
+            if (!(entries.length === 0)) {
+              _context10.next = 7;
+              break;
+            }
+
+            _context10.next = 7;
+            return _fs2.default.promises.rmdir(dirPath);
+
+          case 7:
+            _context10.next = 11;
+            break;
+
+          case 9:
+            _context10.prev = 9;
+            _context10.t0 = _context10['catch'](0);
+
+          case 11:
+          case 'end':
+            return _context10.stop();
+        }
+      }
+    }, _callee10, undefined, [[0, 9]]);
+  }));
+
+  return function removeDirIfEmpty(_x21) {
+    return _ref11.apply(this, arguments);
+  };
+}();
+
+var readMetadata = function readMetadata(metadataPath) {
+  if (!_fs2.default.existsSync(metadataPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(_fs2.default.readFileSync(metadataPath, 'utf-8'));
+  } catch (error) {
+    return null;
+  }
+};
+
+var writeMetadata = function () {
+  var _ref12 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11(metadataPath, metadata) {
+    return _regenerator2.default.wrap(function _callee11$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            _context11.next = 2;
+            return _fs2.default.promises.mkdir(_path2.default.dirname(metadataPath), { recursive: true });
+
+          case 2:
+            _context11.next = 4;
+            return _fs2.default.promises.writeFile(metadataPath, (0, _stringify2.default)(metadata, null, 2));
+
+          case 4:
+          case 'end':
+            return _context11.stop();
+        }
+      }
+    }, _callee11, undefined);
+  }));
+
+  return function writeMetadata(_x22, _x23) {
+    return _ref12.apply(this, arguments);
+  };
+}();
+
+var isClnCiReachable = function () {
+  var _ref13 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee12() {
+    var res;
+    return _regenerator2.default.wrap(function _callee12$(_context12) {
+      while (1) {
+        switch (_context12.prev = _context12.next) {
+          case 0:
+            _context12.prev = 0;
+            _context12.next = 3;
+            return fetchWithTimeout(CLN_CI_INDEX_URL, {
+              headers: { accept: 'application/json' }
+            });
+
+          case 3:
+            res = _context12.sent;
+            return _context12.abrupt('return', !!(res && res.ok));
+
+          case 7:
+            _context12.prev = 7;
+            _context12.t0 = _context12['catch'](0);
+            return _context12.abrupt('return', false);
+
+          case 10:
+          case 'end':
+            return _context12.stop();
+        }
+      }
+    }, _callee12, undefined, [[0, 7]]);
+  }));
+
+  return function isClnCiReachable() {
+    return _ref13.apply(this, arguments);
+  };
+}();
+
+var resolvePlatformId = function resolvePlatformId(platformInfo) {
+  return platformInfo.platform || platformInfo.os + '-' + platformInfo.arch;
+};
+
+var ensureClnCiPlatformBinary = function () {
+  var _ref14 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee13(platformInfo) {
+    var online = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+    var platformId, cacheDir, _metadataPath, _cached, _targetBinaryPath, _fallbackBinaryPath, manifest, file, metadataPath, cached, targetBinaryPath, fallbackBinaryPath, archiveName, archivePath, isCacheValid, binaryPath, actualSha, extracted;
+
+    return _regenerator2.default.wrap(function _callee13$(_context13) {
+      while (1) {
+        switch (_context13.prev = _context13.next) {
+          case 0:
+            platformId = resolvePlatformId(platformInfo);
+            cacheDir = getClnCiCacheDir(platformId);
+            _context13.next = 4;
+            return ensureClnCiDir(cacheDir);
+
+          case 4:
+            if (online) {
+              _context13.next = 14;
+              break;
+            }
+
+            _metadataPath = _path2.default.join(cacheDir, 'metadata.json');
+            _cached = readMetadata(_metadataPath);
+            _targetBinaryPath = _cached && _cached.entry ? _path2.default.join(cacheDir, _cached.entry) : null;
+            _fallbackBinaryPath = _cached && _cached.tempEntry ? _path2.default.join(cacheDir, _cached.tempEntry) : null;
+
+            if (!(_targetBinaryPath && _fs2.default.existsSync(_targetBinaryPath))) {
+              _context13.next = 11;
+              break;
+            }
+
+            return _context13.abrupt('return', {
+              binaryPath: _targetBinaryPath,
+              version: _cached.version,
+              platformId: platformId
+            });
+
+          case 11:
+            if (!(_fallbackBinaryPath && _fs2.default.existsSync(_fallbackBinaryPath))) {
+              _context13.next = 13;
+              break;
+            }
+
+            return _context13.abrupt('return', {
+              binaryPath: _fallbackBinaryPath,
+              version: _cached.version,
+              platformId: platformId
+            });
+
+          case 13:
+            throw new Error('Local cln-ci binary not found for ' + platformId + ' in ' + cacheDir);
+
+          case 14:
+            _context13.next = 16;
+            return fetchJson(resolveDownloadUrl(platformInfo.manifest));
+
+          case 16:
+            manifest = _context13.sent;
+            file = manifest.files && manifest.files[0];
+
+            if (!(!file || !file.pack || file.pack.format !== 'zip')) {
+              _context13.next = 20;
+              break;
+            }
+
+            throw new Error('Unsupported cln-ci package format: ' + (file && file.pack ? file.pack.format : 'unknown'));
+
+          case 20:
+            metadataPath = _path2.default.join(cacheDir, 'metadata.json');
+            cached = readMetadata(metadataPath);
+            targetBinaryPath = _path2.default.join(cacheDir, file.pack.entry);
+            fallbackBinaryPath = cached && cached.tempEntry ? _path2.default.join(cacheDir, cached.tempEntry) : null;
+            archiveName = _path2.default.basename(file.url);
+            archivePath = _path2.default.join(cacheDir, archiveName);
+            isCacheValid = cached && cached.version === manifest.version && cached.entry === file.pack.entry && cached.sha256 === file.sha256 && (_fs2.default.existsSync(targetBinaryPath) || fallbackBinaryPath && _fs2.default.existsSync(fallbackBinaryPath));
+            binaryPath = targetBinaryPath;
+
+            if (isCacheValid) {
+              _context13.next = 49;
+              break;
+            }
+
+            _context13.next = 31;
+            return downloadFile(resolveDownloadUrl(file.url), archivePath);
+
+          case 31:
+            _context13.next = 33;
+            return sha256File(archivePath);
+
+          case 33:
+            actualSha = _context13.sent;
+
+            if (!(actualSha !== file.sha256)) {
+              _context13.next = 38;
+              break;
+            }
+
+            _context13.next = 37;
+            return _fs2.default.promises.rm(archivePath, { force: true }).catch(function () {
+              return undefined;
+            });
+
+          case 37:
+            throw new Error('Downloaded cln-ci package failed sha256 verification.');
+
+          case 38:
+            _context13.next = 40;
+            return extractZip(archivePath, cacheDir, file.pack.entry);
+
+          case 40:
+            extracted = _context13.sent;
+
+            binaryPath = extracted.entryPath;
+
+            if (!(process.platform !== 'win32')) {
+              _context13.next = 45;
+              break;
+            }
+
+            _context13.next = 45;
+            return _fs2.default.promises.chmod(binaryPath, 493);
+
+          case 45:
+            _context13.next = 47;
+            return writeMetadata(metadataPath, {
+              version: manifest.version,
+              entry: file.pack.entry,
+              tempEntry: extracted.tempEntry,
+              archive: archiveName,
+              sha256: file.sha256
+            });
+
+          case 47:
+            _context13.next = 50;
+            break;
+
+          case 49:
+            if (!_fs2.default.existsSync(targetBinaryPath) && fallbackBinaryPath && _fs2.default.existsSync(fallbackBinaryPath)) {
+              binaryPath = fallbackBinaryPath;
+            }
+
+          case 50:
+            if (!_fs2.default.existsSync(targetBinaryPath)) {
+              _context13.next = 55;
+              break;
+            }
+
+            binaryPath = targetBinaryPath;
+
+            if (!(cached && cached.tempEntry)) {
+              _context13.next = 55;
+              break;
+            }
+
+            _context13.next = 55;
+            return _fs2.default.promises.rm(_path2.default.join(cacheDir, cached.tempEntry), { force: true }).catch(function () {
+              return undefined;
+            });
+
+          case 55:
+            return _context13.abrupt('return', { binaryPath: binaryPath, version: manifest.version });
+
+          case 56:
+          case 'end':
+            return _context13.stop();
+        }
+      }
+    }, _callee13, undefined);
+  }));
+
+  return function ensureClnCiPlatformBinary(_x25) {
+    return _ref14.apply(this, arguments);
+  };
+}();
 
-var nuxtCli = _interopRequireWildcard(_cli);
+var ensureLocalClnCiBinary = function () {
+  var _ref15 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee14() {
+    var platformId;
+    return _regenerator2.default.wrap(function _callee14$(_context14) {
+      while (1) {
+        switch (_context14.prev = _context14.next) {
+          case 0:
+            platformId = resolveCurrentPlatformId();
+            _context14.next = 3;
+            return ensureClnCiPlatformBinary({
+              os: getClnCiPlatform().os,
+              arch: getClnCiPlatform().arch,
+              platform: platformId
+            }, false);
+
+          case 3:
+            return _context14.abrupt('return', _context14.sent);
+
+          case 4:
+          case 'end':
+            return _context14.stop();
+        }
+      }
+    }, _callee14, undefined);
+  }));
 
-var _consola = require('consola');
+  return function ensureLocalClnCiBinary() {
+    return _ref15.apply(this, arguments);
+  };
+}();
 
-var _consola2 = _interopRequireDefault(_consola);
+var ensureClnCiBinary = function () {
+  var _ref16 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee16() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var platformKey, online, currentPlatformId, index, platforms, currentPlatformInfo;
+    return _regenerator2.default.wrap(function _callee16$(_context16) {
+      while (1) {
+        switch (_context16.prev = _context16.next) {
+          case 0:
+            platformKey = getClnCiPlatform();
+            _context16.next = 3;
+            return ensureClnCiDir(getClnCiRootDir());
 
-var _msg = require('../config/msg');
+          case 3:
+            _context16.next = 5;
+            return ensureClnCiDir(getClnCiBinRootDir());
 
-var _os = require('os');
+          case 5:
+            if (!options.preferLocal) {
+              _context16.next = 14;
+              break;
+            }
 
-var _os2 = _interopRequireDefault(_os);
+            _context16.prev = 6;
+            _context16.next = 9;
+            return ensureLocalClnCiBinary();
 
-var _rimraf = require('rimraf');
+          case 9:
+            return _context16.abrupt('return', _context16.sent);
 
-var _rimraf2 = _interopRequireDefault(_rimraf);
+          case 12:
+            _context16.prev = 12;
+            _context16.t0 = _context16['catch'](6);
 
-var _verify = require('../utils/verify');
+          case 14:
+            _context16.next = 16;
+            return isClnCiReachable();
 
-var _server = require('yakuza1/server');
+          case 16:
+            online = _context16.sent;
+            currentPlatformId = platformKey.os + '-' + platformKey.arch;
 
-var _commandExists = require('command-exists');
+            if (online) {
+              _context16.next = 22;
+              break;
+            }
 
-var _connectionTester = require('connection-tester');
+            _context16.next = 21;
+            return ensureClnCiPlatformBinary({
+              os: platformKey.os,
+              arch: platformKey.arch,
+              platform: currentPlatformId
+            }, false);
+
+          case 21:
+            return _context16.abrupt('return', _context16.sent);
+
+          case 22:
+            _context16.next = 24;
+            return fetchJson(CLN_CI_INDEX_URL);
+
+          case 24:
+            index = _context16.sent;
+            platforms = index.platforms || [];
+            currentPlatformInfo = platforms.find(function (entry) {
+              return entry.os === platformKey.os && entry.arch === platformKey.arch;
+            });
 
-var _connectionTester2 = _interopRequireDefault(_connectionTester);
+            if (currentPlatformInfo) {
+              _context16.next = 29;
+              break;
+            }
 
-var _jsonFormat = require('json-format');
+            throw new Error('No cln-ci build for ' + platformKey.os + '/' + platformKey.arch);
 
-var _jsonFormat2 = _interopRequireDefault(_jsonFormat);
+          case 29:
+            _context16.next = 31;
+            return _promise2.default.all(platforms.map(function () {
+              var _ref17 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee15(entry) {
+                return _regenerator2.default.wrap(function _callee15$(_context15) {
+                  while (1) {
+                    switch (_context15.prev = _context15.next) {
+                      case 0:
+                        _context15.prev = 0;
+                        _context15.next = 3;
+                        return ensureClnCiPlatformBinary(entry, true);
 
-var _syncRequest = require('sync-request');
+                      case 3:
+                        _context15.next = 12;
+                        break;
 
-var _syncRequest2 = _interopRequireDefault(_syncRequest);
+                      case 5:
+                        _context15.prev = 5;
+                        _context15.t0 = _context15['catch'](0);
 
-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; } }
+                        if (!(resolvePlatformId(entry) === resolvePlatformId(currentPlatformInfo))) {
+                          _context15.next = 9;
+                          break;
+                        }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+                        throw _context15.t0;
 
-process.env.YK_USAGE = 'CLI';
+                      case 9:
+                        _context15.next = 11;
+                        return removeDirIfEmpty(getClnCiCacheDir(resolvePlatformId(entry)));
 
-var _require = require('child_process'),
-    execSync = _require.execSync,
-    spawn = _require.spawn;
+                      case 11:
+                        _consola2.default.warn('Skip syncing optional cln-ci platform ' + resolvePlatformId(entry) + ': ' + (_context15.t0 && _context15.t0.message ? _context15.t0.message : _context15.t0));
 
-// const util = require('util');
-// const spawn = util.promisify(require('child_process').spawn);
+                      case 12:
+                      case 'end':
+                        return _context15.stop();
+                    }
+                  }
+                }, _callee15, undefined, [[0, 5]]);
+              }));
 
-if (_semver2.default.satisfies(process.versions.node, '>= 6.0.0')) require('v8-compile-cache');
+              return function (_x27) {
+                return _ref17.apply(this, arguments);
+              };
+            }()));
 
-var params = {
-  serverPath: '../server',
-  serverLite: '../server/mode/lite'
-};
+          case 31:
+            _context16.next = 33;
+            return ensureClnCiPlatformBinary(currentPlatformInfo, true);
 
-// const watchChange = (watchPaths = [], callback) => {
-//   const watcher = chokidar.watch(watchPaths, {
-//     persistent: true,
-//     usePolling: true,
-//   });
-//
-//   watcher.on('change', callback);
-// };
+          case 33:
+            return _context16.abrupt('return', _context16.sent);
 
-var gi = function () {
-  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+          case 34:
+          case 'end':
+            return _context16.stop();
+        }
+      }
+    }, _callee16, undefined, [[6, 12]]);
+  }));
 
-    var app, dkyModeDef, ykServerEnv, enabledAll, appsNoneExit, apps, _ref2, conf;
+  return function ensureClnCiBinary() {
+    return _ref16.apply(this, arguments);
+  };
+}();
 
-    return _regenerator2.default.wrap(function _callee$(_context) {
+var spawnClnCiBinary = function () {
+  var _ref18 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee17(binaryPath, args) {
+    return _regenerator2.default.wrap(function _callee17$(_context17) {
       while (1) {
-        switch (_context.prev = _context.next) {
+        switch (_context17.prev = _context17.next) {
           case 0:
-            app = options.app || process.env.npm_config_yk0_build_app || process.env.npm_config_y0ba;
-            dkyModeDef = process.env.NODE_ENV === 'development' ? 'dev' : 'normal';
-            ykServerEnv = process.env.YK_SERVER_ENV || options.ykServerEnv || 'local';
-            enabledAll = process.env.YK_MACHINE_TYPE === 'workstation';
-            appsNoneExit = typeof options.appsNoneExit === 'boolean' ? options.appsNoneExit : true;
-            // console.log(ykServerEnv);
+            _context17.next = 2;
+            return new _promise2.default(function (resolve, reject) {
+              var child = spawn(binaryPath, args, {
+                stdio: 'inherit',
+                env: createProjectEnv()
+              });
 
-            if (!_paths2.default.access(_paths2.default.envPath())) {
-              _consola2.default.error(_msg.errMsg["server.config.none"]);
-              process.exit(1);
-            }
+              child.on('error', reject);
+              child.on('close', function (code, signal) {
+                if (signal) {
+                  resolve(1);
+                  return;
+                }
+                resolve(code || 0);
+              });
+            });
 
-            apps = [];
+          case 2:
+            return _context17.abrupt('return', _context17.sent);
 
-            if (typeof app === 'string') {
-              apps = app.split(',').map(function (a) {
-                return 'app.' + a;
-              });
-            }
+          case 3:
+          case 'end':
+            return _context17.stop();
+        }
+      }
+    }, _callee17, undefined);
+  }));
 
-            _paths2.default.interfereFile.forEach(function (p) {
-              _rimraf2.default.sync(p);
-            });
-            _context.next = 11;
-            return (0, _inclusive2.default)({
-              apps: apps,
-              enabledAll: enabledAll,
-              ykServerEnv: ykServerEnv,
-              pkg: _package2.default,
-              dkyModeDef: dkyModeDef
-            });
+  return function spawnClnCiBinary(_x28, _x29) {
+    return _ref18.apply(this, arguments);
+  };
+}();
 
-          case 11:
-            _ref2 = _context.sent;
-            conf = _ref2.conf;
+var parseClnCiArgs = function parseClnCiArgs() {
+  var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
 
-            if (!conf.extend.plugins.husky.enabled) {
-              _context.next = 18;
-              break;
-            }
+  var passThroughArgs = [];
+  var preferLocal = false;
 
-            _context.next = 16;
-            return (0, _verify.commitInit)();
+  args.forEach(function (arg) {
+    if (arg === '--local-bin') {
+      preferLocal = true;
+      return;
+    }
+    passThroughArgs.push(arg);
+  });
 
-          case 16:
-            _context.next = 19;
-            break;
+  return {
+    preferLocal: preferLocal,
+    args: passThroughArgs
+  };
+};
 
-          case 18:
-            _paths2.default.rm(_paths2.default.gitHooksCommitMsg);
+var runClnCiCommand = function () {
+  var _ref19 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee18(command) {
+    var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
 
-          case 19:
+    var parsed, _ref20, binaryPath;
 
-            if (conf.dev) {
-              // conf
-              (0, _server.watchDirChange)([_paths2.default.ykConfigJs, _paths2.default.envPath(), _paths2.default.envPath(ykServerEnv)], function () {
-                (0, _inclusive2.default)({
-                  apps: apps,
-                  enabledAll: enabledAll,
-                  ykServerEnv: ykServerEnv,
-                  pkg: _package2.default,
-                  dkyModeDef: 'dev'
-                }).then();
-              }, { event: "change" });
-            }
+    return _regenerator2.default.wrap(function _callee18$(_context18) {
+      while (1) {
+        switch (_context18.prev = _context18.next) {
+          case 0:
+            parsed = parseClnCiArgs(args);
+            _context18.next = 3;
+            return ensureClnCiBinary({
+              preferLocal: parsed.preferLocal
+            });
 
-            if (apps.length === 0) {
-              apps = _server._.compact(_server._.map(conf.router.config, function (v, key) {
-                if (v.enabled) {
-                  return key;
-                }
-              }));
-            }
+          case 3:
+            _ref20 = _context18.sent;
+            binaryPath = _ref20.binaryPath;
+            _context18.next = 7;
+            return spawnClnCiBinary(binaryPath, [command].concat((0, _toConsumableArray3.default)(parsed.args)));
 
-            if (apps.length === 0 && appsNoneExit) {
-              _consola2.default.error(_msg.errMsg["server.apps.none"]);
-              process.exit(1);
-            }
-            return _context.abrupt('return', { conf: conf, apps: apps });
+          case 7:
+            return _context18.abrupt('return', _context18.sent);
 
-          case 23:
+          case 8:
           case 'end':
-            return _context.stop();
+            return _context18.stop();
         }
       }
-    }, _callee, undefined);
+    }, _callee18, undefined);
   }));
 
-  return function gi() {
-    return _ref.apply(this, arguments);
+  return function runClnCiCommand(_x32) {
+    return _ref19.apply(this, arguments);
   };
 }();
 
-var alias = function alias() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-  _server.global.__cln_appName__ = options.appName;
-};
-
-var execCmd = function execCmd(cmd) {
-  execSync(cmd, { shell: true, stdio: 'inherit' });
-};
-
 var run = exports.run = function () {
-  var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee17(_argv) {
-    return _regenerator2.default.wrap(function _callee17$(_context17) {
+  var _ref21 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee33(_argv) {
+    var argv, rawArgs, command, commandArgs, exitCode;
+    return _regenerator2.default.wrap(function _callee33$(_context33) {
       while (1) {
-        switch (_context17.prev = _context17.next) {
+        switch (_context33.prev = _context33.next) {
           case 0:
+            argv = Array.isArray(_argv) && _argv.length > 0 ? _argv : process.argv;
+            rawArgs = argv.slice(2);
+
+            if (!(rawArgs[0] === 'image')) {
+              _context33.next = 17;
+              break;
+            }
+
+            _context33.prev = 3;
+            command = rawArgs[1] || 'image';
+            commandArgs = rawArgs[1] ? rawArgs.slice(2) : [];
+            _context33.next = 8;
+            return runClnCiCommand(command, commandArgs);
+
+          case 8:
+            exitCode = _context33.sent;
+
+            process.exitCode = exitCode;
+            _context33.next = 16;
+            break;
+
+          case 12:
+            _context33.prev = 12;
+            _context33.t0 = _context33['catch'](3);
+
+            _consola2.default.error(_context33.t0 && _context33.t0.message ? _context33.t0.message : _context33.t0);
+            process.exitCode = 1;
+
+          case 16:
+            return _context33.abrupt('return');
+
+          case 17:
+
             _commander2.default.version(_package2.default.version, '-v, --version');
 
             _commander2.default.command('dev').description('go into developer mode').option('-y0ba, --yk0-build-app <appName>', 'Building a specified application').option('-e, --env <envName>', 'yk server env').option('-m, --mode <modeName>', 'yk develop start mode').action(function () {
-              var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(_ref4) {
-                var yk0BuildApp = _ref4.yk0BuildApp,
-                    env = _ref4.env,
-                    mode = _ref4.mode;
+              var _ref23 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee19(_ref22) {
+                var yk0BuildApp = _ref22.yk0BuildApp,
+                    env = _ref22.env,
+                    mode = _ref22.mode;
 
-                var _ref6, apps, bin;
+                var _ref24, apps, bin;
 
-                return _regenerator2.default.wrap(function _callee2$(_context2) {
+                return _regenerator2.default.wrap(function _callee19$(_context19) {
                   while (1) {
-                    switch (_context2.prev = _context2.next) {
+                    switch (_context19.prev = _context19.next) {
                       case 0:
                         // console.log(args);
                         _consola2.default.log('In the preparation...');
                         process.env.NODE_ENV = 'development';
-                        _context2.next = 4;
+                        _context19.next = 4;
                         return gi({ app: yk0BuildApp, ykServerEnv: env });
 
                       case 4:
-                        _ref6 = _context2.sent;
-                        apps = _ref6.apps;
+                        _ref24 = _context19.sent;
+                        apps = _ref24.apps;
                         bin = "yk-dev";
-                        _context2.t0 = _os2.default.type();
-                        _context2.next = _context2.t0 === "Linux" ? 10 : 12;
+                        _context19.t0 = _os2.default.type();
+                        _context19.next = _context19.t0 === "Linux" ? 10 : 12;
                         break;
 
                       case 10:
                         bin = "yk";
-                        return _context2.abrupt('break', 12);
+                        return _context19.abrupt('break', 12);
 
                       case 12:
 
@@ -277,71 +1549,71 @@ var run = exports.run = function () {
 
                       case 13:
                       case 'end':
-                        return _context2.stop();
+                        return _context19.stop();
                     }
                   }
-                }, _callee2, undefined);
+                }, _callee19, undefined);
               }));
 
-              return function (_x4) {
-                return _ref5.apply(this, arguments);
+              return function (_x34) {
+                return _ref23.apply(this, arguments);
               };
             }());
 
             _commander2.default.command('serve <cmd>').description('go into developer mode')
             // .option('-y0ba, --yk0-build-app <appName>', 'Building a specified application')
             .action(function () {
-              var _ref7 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(cmd) {
-                return _regenerator2.default.wrap(function _callee4$(_context4) {
+              var _ref25 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee21(cmd) {
+                return _regenerator2.default.wrap(function _callee21$(_context21) {
                   while (1) {
-                    switch (_context4.prev = _context4.next) {
+                    switch (_context21.prev = _context21.next) {
                       case 0:
                         // console.log(args);
                         process.env.NODE_ENV = 'development';
                         // gi({app: yk0BuildApp});
-                        _context4.next = 3;
+                        _context21.next = 3;
                         return _server._.asyncMap(cmd.split(','), function () {
-                          var _ref8 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(key) {
-                            return _regenerator2.default.wrap(function _callee3$(_context3) {
+                          var _ref26 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee20(key) {
+                            return _regenerator2.default.wrap(function _callee20$(_context20) {
                               while (1) {
-                                switch (_context3.prev = _context3.next) {
+                                switch (_context20.prev = _context20.next) {
                                   case 0:
                                     alias({ appName: key });
-                                    _context3.next = 3;
+                                    _context20.next = 3;
                                     return require(params.serverPath)('dev', key);
 
                                   case 3:
                                   case 'end':
-                                    return _context3.stop();
+                                    return _context20.stop();
                                 }
                               }
-                            }, _callee3, undefined);
+                            }, _callee20, undefined);
                           }));
 
-                          return function (_x6) {
-                            return _ref8.apply(this, arguments);
+                          return function (_x36) {
+                            return _ref26.apply(this, arguments);
                           };
                         }());
 
                       case 3:
                       case 'end':
-                        return _context4.stop();
+                        return _context21.stop();
                     }
                   }
-                }, _callee4, undefined);
+                }, _callee21, undefined);
               }));
 
-              return function (_x5) {
-                return _ref7.apply(this, arguments);
+              return function (_x35) {
+                return _ref25.apply(this, arguments);
               };
             }());
 
-            _commander2.default.command('init').description('cln2 is initialized.').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5() {
+            _commander2.default.command('init').description('cln2 is initialized.').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee22() {
               var pkgPath, _pkg, obj;
 
-              return _regenerator2.default.wrap(function _callee5$(_context5) {
+              return _regenerator2.default.wrap(function _callee22$(_context22) {
                 while (1) {
-                  switch (_context5.prev = _context5.next) {
+                  switch (_context22.prev = _context22.next) {
                     case 0:
                       // add image
                       try {
@@ -364,173 +1636,27 @@ var run = exports.run = function () {
 
                     case 2:
                     case 'end':
-                      return _context5.stop();
+                      return _context22.stop();
                   }
                 }
-              }, _callee5, undefined);
+              }, _callee22, undefined);
             })));
 
-            _commander2.default.command('image').description('Build image.').option('-nc, --no-cache', 'Do not use cache when building the image').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6() {
-              var isTestInner, res, inner, CS, isInner, CLNENV, CLNBUILD, CLNPACK, noCache, CLNWORKERS, TRY_TIMES, CLNVERSION, pkg, NMCI, projectName, obj, imageReleaseName, imageReleaseNameSave, BI, preLoad, DEP, EXPORT, DKY, Dockerfile, buildkit, prefixCmd, suffixCmd, fileStr, loop;
-              return _regenerator2.default.wrap(function _callee6$(_context6) {
-                while (1) {
-                  switch (_context6.prev = _context6.next) {
-                    case 0:
-                      isTestInner = false;
-                      // const {success: isTestInner} = connectionTester.test('fe-repo.inner.px.q7b.site', 5000, 1000)
-
-                      try {
-                        res = (0, _syncRequest2.default)('GET', 'https://sl.rdc.q7b.site/sys/health-check', {
-                          timeout: 1000
-                        });
-                        inner = JSON.parse(res.getBody('utf8'));
-
-                        isTestInner = inner.data === 'alive';
-                      } catch (e) {}
-
-                      CS = (0, _server.gPwd)();
-                      isInner = process.env.CLN_IMAGE_ISINNER === undefined ? isTestInner : process.env.CLN_IMAGE_ISINNER === '1';
-                      CLNENV = process.env.CLN_IMAGE_ENV || 'local';
-                      CLNBUILD = process.env.CLN_IMAGE_BUILD === undefined;
-                      CLNPACK = process.env.CLN_IMAGE_PACK === undefined;
-                      noCache = process.env.NO_CACHE === '1';
-                      CLNWORKERS = process.env.CLN_IMAGE_WORKERS || _os2.default.cpus().length;
-                      TRY_TIMES = process.env.TRY_TIMES || '3';
-                      CLNVERSION = process.env.CLN_IMAGE_VERSION || CS;
-                      pkg = _paths2.default.read(_paths2.default.appPackageJson);
-                      NMCI = 'nm_' + (0, _server.md5)(pkg).substring(0, 6);
-                      projectName = 'cln_img';
-
-                      try {
-                        obj = JSON.parse(pkg);
-
-                        projectName = obj.name;
-                        NMCI = 'nm_' + (0, _server.md5)((0, _stringify2.default)(obj.dependencies) + (0, _stringify2.default)(obj.peerDependencies) + (0, _stringify2.default)(obj.devDependencies)).substring(0, 6);
-                        CLNVERSION = process.env.CLN_IMAGE_VERSION || obj.version;
-                      } catch (e) {}
-                      projectName = process.env.CLN_IMAGE_NAME || projectName;
-                      imageReleaseName = projectName + ':' + CLNVERSION;
-                      imageReleaseNameSave = (projectName + '_' + CLNVERSION).replace(/\//g, "_");
-                      BI = process.env.CLN_IMAGE_BI || (isInner ? 'registry-image.rdc.q7b.site/cln-server:0.7.3' : 'nfjbill/cln-server:0.7.3');
-                      preLoad = (process.env.CLN_IMAGE_LOAD || '').split(',');
-                      // let BI = process.env.CLN_IMAGE_BI
-
-                      DEP = process.env.CLN_IMAGE_DEP === undefined ? false : process.env.CLN_IMAGE_DEP;
-                      EXPORT = process.env.CLN_IMAGE_EXPORT !== "false";
-                      DKY = process.env.CLN_IMAGE_DKY === "true";
-                      Dockerfile = "Dockerfile";
-                      buildkit = "DOCKER_BUILDKIT=1";
-                      prefixCmd = "";
-                      // let suffixCmd = process.env.CLN_IMAGE_SUFFIX !== undefined ? process.env.CLN_IMAGE_SUFFIX : " >/dev/null 2>&1"
-
-                      suffixCmd = process.env.CLN_IMAGE_SUFFIX !== undefined ? process.env.CLN_IMAGE_SUFFIX : "";
-
-                      if (_os2.default.platform() === 'win32') {
-                        prefixCmd = "cross-env ";
-                        suffixCmd = "";
-                      }
-
-                      if (DEP) {
-                        Dockerfile = "Dockerfile_DEP";
-                        BI = BI || "registry-image.rdc.q7b.site/cln-server:0.7.3";
-                      }
-
-                      if (preLoad.length > 0) {
-                        preLoad.forEach(function (p) {
-                          if (p) {
-                            execCmd('docker load < ' + p);
-                          }
-                        });
-                      }
-
-                      fileStr = '-f ' + _paths2.default.ykRootImage + Dockerfile;
-
-
-                      if (DKY) {
-                        buildkit = '';
-                        fileStr = '';
-                        EXPORT = false;
-                        execCmd('cp -rfp ' + _paths2.default.ykRootImage + Dockerfile + ' ./Dockerfile');
-                        execCmd('cp -rfp ' + _paths2.default.ykRootImage + '.dockerignore ./');
-                      }
-
-                      if ((0, _commandExists.sync)('docker')) {
-                        _context6.next = 36;
-                        break;
-                      }
-
-                      _consola2.default.error('docker must be installed!');
-                      process.exit(1);
-                      return _context6.abrupt('return');
-
-                    case 36:
-                      if (!(0, _commandExists.sync)('pxnpm') && !DEP) {
-                        execCmd(isInner ? 'npm i -g pxnpm --registry=https://registry-pxnpm.rdc.q7b.site' : 'npm i -g pxnpm');
-                      }
-                      if (!(0, _commandExists.sync)('cross-env') && !DEP) {
-                        execCmd('pxnpm i -g cross-env');
-                      }
-
-                      if (CLNBUILD) {
-                        execCmd(prefixCmd + ' YK0_server__yk4Addr=http://1.1.1.1 YK0_server__orbAddr=http://1.1.1.1 YK_ENV=' + CLNENV + ' YK_SERVER_ENV=' + CLNENV + ' YK_VERSIONSHA=' + CS + ' YK_DOCKERNAME=' + CS + ' YK_MACHINE_TYPE=workstation YK0_env=docker YK0_CONFIG_WORKERS=' + CLNWORKERS + ' npm run build');
-                      }
-
-                      if (_os2.default.platform() === 'win32') {
-                        (0, _midfilter2.default)(_paths2.default.ykServerPath);
-                      }
-
-                      loop = function loop(i) {
-                        try {
-                          if (i < parseInt(TRY_TIMES)) {
-                            execCmd(prefixCmd + ' ' + buildkit + ' docker build ' + (noCache ? '--no-cache' : '') + ' ' + fileStr + ' --build-arg BASE_IMAGE=' + BI + ' --build-arg YK_VERSIONSHA=' + CS + ' --build-arg YK_ENV=' + CLNENV + ' --build-arg DEP=' + DEP + ' --build-arg NPM_MODULES_CACHE_ID=' + NMCI + ' -t ' + imageReleaseName + ' . ' + suffixCmd);
-                          } else {
-                            _consola2.default.error('Image build failure!');
-                            process.exit(0);
-                          }
-                        } catch (e) {
-                          loop(i + 1);
-                        }
-                      };
-
-                      loop(0);
-
-                      _context6.next = 44;
-                      return (0, _server.delay)(1000);
-
-                    case 44:
-
-                      if (CLNPACK && EXPORT) {
-                        if (!(0, _commandExists.sync)('gzip')) {
-                          execCmd('docker save > ' + imageReleaseNameSave + '.tar ' + imageReleaseName);
-                        } else {
-                          execCmd('docker save ' + imageReleaseName + ' | gzip >' + imageReleaseNameSave + '.tar');
-                        }
-                      }
-
-                      _consola2.default.success('Image tar: ' + imageReleaseNameSave + '.tar');
-                      _consola2.default.success('Image name: ' + imageReleaseName);
-
-                    case 47:
-                    case 'end':
-                      return _context6.stop();
-                  }
-                }
-              }, _callee6, undefined);
-            })));
+            _commander2.default.command('image').description('Build image with cln-ci.');
 
             _commander2.default.command('build').description('build a model').option('-y0ba, --yk0-build-app <appName>', 'Building a specified application').option('-workers <workers>', 'Building a specified application').option('-e, --env <envName>', 'yk server env')
             // .action(async ({app}) => {
             .action(function () {
-              var _ref12 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8(_ref11) {
-                var yk0BuildApp = _ref11.yk0BuildApp,
-                    env = _ref11.env,
-                    wk = _ref11.workers;
+              var _ref29 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee24(_ref28) {
+                var yk0BuildApp = _ref28.yk0BuildApp,
+                    env = _ref28.env,
+                    wk = _ref28.workers;
 
-                var _ref13, apps, workers, cpuLen, i, run;
+                var _ref30, apps, workers, cpuLen, concurrency, nextIndex, activeChildren, heartbeat, abortState, stopActiveChildren, runWorker;
 
-                return _regenerator2.default.wrap(function _callee8$(_context8) {
+                return _regenerator2.default.wrap(function _callee24$(_context24) {
                   while (1) {
-                    switch (_context8.prev = _context8.next) {
+                    switch (_context24.prev = _context24.next) {
                       case 0:
                         // process.env.NODE_ENV = 'production';
                         // process.env.NODE_CMD = 'build';
@@ -540,69 +1666,124 @@ var run = exports.run = function () {
                         _consola2.default.log('In the preparation...');
                         process.env.NODE_ENV = 'production';
                         process.env.NODE_CMD = 'build';
-                        _context8.next = 5;
+                        _context24.next = 5;
                         return gi({ app: yk0BuildApp, ykServerEnv: env });
 
                       case 5:
-                        _ref13 = _context8.sent;
-                        apps = _ref13.apps;
+                        _ref30 = _context24.sent;
+                        apps = _ref30.apps;
                         workers = wk || process.env.YK0_CONFIG_WORKERS || process.env.npm_config_workers;
                         // const workers = process.env.npm_config_workers;
 
                         cpuLen = _os2.default.cpus().length;
 
                         if (workers) {
-                          cpuLen = parseInt(workers);
+                          cpuLen = parseInt(workers, 10);
                         }
 
-                        i = 0;
+                        if (!(0, _isInteger2.default)(cpuLen) || cpuLen <= 0) {
+                          cpuLen = 1;
+                        }
 
-                        run = function run() {
-                          var key = apps[i];
-                          if (key) {
-                            var child = spawn('yk', ['bd', key], { shell: true, stdio: 'inherit' });
+                        concurrency = Math.min(cpuLen, apps.length);
+                        nextIndex = 0;
+                        activeChildren = new _set2.default();
+                        heartbeat = createBuildHeartbeat(apps);
+                        abortState = {
+                          stopped: false,
+                          error: null
+                        };
 
-                            child.on('close', function (exitCode) {
-                              i = i + 1;
-                              run(i);
-                            });
-                          }
+                        stopActiveChildren = function stopActiveChildren() {
+                          activeChildren.forEach(function (child) {
+                            try {
+                              child.kill('SIGTERM');
+                            } catch (e) {}
+                          });
                         };
 
-                        _server._.asyncMap(apps, function () {
-                          var _ref14 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7(key, j) {
-                            return _regenerator2.default.wrap(function _callee7$(_context7) {
+                        runWorker = function () {
+                          var _ref31 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee23() {
+                            var currentIndex;
+                            return _regenerator2.default.wrap(function _callee23$(_context23) {
                               while (1) {
-                                switch (_context7.prev = _context7.next) {
+                                switch (_context23.prev = _context23.next) {
                                   case 0:
-                                    if (j < cpuLen) {
-                                      i = j;
-                                      run();
+                                    if (!(!abortState.stopped && nextIndex < apps.length)) {
+                                      _context23.next = 14;
+                                      break;
+                                    }
+
+                                    currentIndex = nextIndex;
+
+                                    nextIndex += 1;
+                                    _context23.prev = 3;
+                                    _context23.next = 6;
+                                    return spawnBuildProcess(apps[currentIndex], { activeChildren: activeChildren, abortState: abortState });
+
+                                  case 6:
+                                    _context23.next = 12;
+                                    break;
+
+                                  case 8:
+                                    _context23.prev = 8;
+                                    _context23.t0 = _context23['catch'](3);
+
+                                    if (!abortState.error) {
+                                      abortState.error = _context23.t0;
+                                      abortState.stopped = true;
+                                      stopActiveChildren();
                                     }
+                                    throw _context23.t0;
+
+                                  case 12:
+                                    _context23.next = 0;
+                                    break;
 
-                                  case 1:
+                                  case 14:
                                   case 'end':
-                                    return _context7.stop();
+                                    return _context23.stop();
                                 }
                               }
-                            }, _callee7, undefined);
+                            }, _callee23, undefined, [[3, 8]]);
                           }));
 
-                          return function (_x8, _x9) {
-                            return _ref14.apply(this, arguments);
+                          return function runWorker() {
+                            return _ref31.apply(this, arguments);
                           };
-                        }());
+                        }();
 
-                      case 13:
+                        _context24.prev = 18;
+                        _context24.next = 21;
+                        return _promise2.default.all((0, _from2.default)({ length: concurrency }, function () {
+                          return runWorker();
+                        }));
+
+                      case 21:
+                        _context24.next = 26;
+                        break;
+
+                      case 23:
+                        _context24.prev = 23;
+                        _context24.t0 = _context24['catch'](18);
+                        throw abortState.error || _context24.t0;
+
+                      case 26:
+                        _context24.prev = 26;
+
+                        heartbeat.stop();
+                        return _context24.finish(26);
+
+                      case 29:
                       case 'end':
-                        return _context8.stop();
+                        return _context24.stop();
                     }
                   }
-                }, _callee8, undefined);
+                }, _callee24, undefined, [[18, 23, 26, 29]]);
               }));
 
-              return function (_x7) {
-                return _ref12.apply(this, arguments);
+              return function (_x37) {
+                return _ref29.apply(this, arguments);
               };
             }());
 
@@ -610,147 +1791,147 @@ var run = exports.run = function () {
             // .option('-y0ba, --yk0-build-app <appName>', 'Building a specified application')
             // .action(async ({app}) => {
             .action(function () {
-              var _ref15 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9(cmd) {
-                return _regenerator2.default.wrap(function _callee9$(_context9) {
+              var _ref32 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee25(cmd) {
+                return _regenerator2.default.wrap(function _callee25$(_context25) {
                   while (1) {
-                    switch (_context9.prev = _context9.next) {
+                    switch (_context25.prev = _context25.next) {
                       case 0:
                         process.env.NODE_ENV = 'production';
                         process.env.NODE_CMD = 'build';
                         // console.log(app);
                         // gi({app: yk0BuildApp});
                         alias({ appName: cmd });
-                        _context9.next = 5;
+                        _context25.next = 5;
                         return require(params.serverPath)('build', cmd);
 
                       case 5:
                       case 'end':
-                        return _context9.stop();
+                        return _context25.stop();
                     }
                   }
-                }, _callee9, undefined);
+                }, _callee25, undefined);
               }));
 
-              return function (_x10) {
-                return _ref15.apply(this, arguments);
+              return function (_x38) {
+                return _ref32.apply(this, arguments);
               };
             }());
 
-            _commander2.default.command('generate').alias('g').description('generate a model').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10() {
-              return _regenerator2.default.wrap(function _callee10$(_context10) {
+            _commander2.default.command('generate').alias('g').description('generate a model').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee26() {
+              return _regenerator2.default.wrap(function _callee26$(_context26) {
                 while (1) {
-                  switch (_context10.prev = _context10.next) {
+                  switch (_context26.prev = _context26.next) {
                     case 0:
                       process.env.NODE_ENV = 'production';
-                      _context10.next = 3;
+                      _context26.next = 3;
                       return gi();
 
                     case 3:
-                      _context10.prev = 3;
-                      _context10.next = 6;
+                      _context26.prev = 3;
+                      _context26.next = 6;
                       return nuxtCli.run(['generate']);
 
                     case 6:
-                      _context10.next = 12;
+                      _context26.next = 12;
                       break;
 
                     case 8:
-                      _context10.prev = 8;
-                      _context10.t0 = _context10['catch'](3);
+                      _context26.prev = 8;
+                      _context26.t0 = _context26['catch'](3);
 
-                      _consola2.default.fatal(_context10.t0);
+                      _consola2.default.fatal(_context26.t0);
                       process.exit(2);
 
                     case 12:
                     case 'end':
-                      return _context10.stop();
+                      return _context26.stop();
                   }
                 }
-              }, _callee10, undefined, [[3, 8]]);
+              }, _callee26, undefined, [[3, 8]]);
             })));
 
-            _commander2.default.command('clean').description('clean cache').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11() {
-              return _regenerator2.default.wrap(function _callee11$(_context11) {
+            _commander2.default.command('clean').description('clean cache').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee27() {
+              return _regenerator2.default.wrap(function _callee27$(_context27) {
                 while (1) {
-                  switch (_context11.prev = _context11.next) {
+                  switch (_context27.prev = _context27.next) {
                     case 0:
                       _rimraf2.default.sync(_paths2.default.hardSourceCache);
                       _rimraf2.default.sync(_paths2.default.ykRootCacheDir);
 
                     case 2:
                     case 'end':
-                      return _context11.stop();
+                      return _context27.stop();
                   }
                 }
-              }, _callee11, undefined);
+              }, _callee27, undefined);
             })));
 
-            _commander2.default.command('cr').description('Code screening secondary compression').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee12() {
-              return _regenerator2.default.wrap(function _callee12$(_context12) {
+            _commander2.default.command('cr').description('Code screening secondary compression').action((0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee28() {
+              return _regenerator2.default.wrap(function _callee28$(_context28) {
                 while (1) {
-                  switch (_context12.prev = _context12.next) {
+                  switch (_context28.prev = _context28.next) {
                     case 0:
-                      _context12.next = 2;
+                      _context28.next = 2;
                       return (0, _compress2.default)();
 
                     case 2:
                     case 'end':
-                      return _context12.stop();
+                      return _context28.stop();
                   }
                 }
-              }, _callee12, undefined);
+              }, _callee28, undefined);
             })));
 
             _commander2.default.command('verify <cmd>').option('-ed, --edit <envName>', 'commit file').option('-m, --msg <msg>', 'commit msg').option('-y0ba, --yk0-build-app <appName>', 'Building a specified application').option('-e, --env <envName>', 'yk server env').description('husky').action(function () {
-              var _ref20 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee13(cmd, _ref19) {
-                var edit = _ref19.edit,
-                    msg = _ref19.msg,
-                    yk0BuildApp = _ref19.yk0BuildApp,
-                    env = _ref19.env;
-                return _regenerator2.default.wrap(function _callee13$(_context13) {
+              var _ref37 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee29(cmd, _ref36) {
+                var edit = _ref36.edit,
+                    msg = _ref36.msg,
+                    yk0BuildApp = _ref36.yk0BuildApp,
+                    env = _ref36.env;
+                return _regenerator2.default.wrap(function _callee29$(_context29) {
                   while (1) {
-                    switch (_context13.prev = _context13.next) {
+                    switch (_context29.prev = _context29.next) {
                       case 0:
                         alias({ appName: "__common" });
 
                         if (!(cmd !== "commit-init")) {
-                          _context13.next = 4;
+                          _context29.next = 4;
                           break;
                         }
 
-                        _context13.next = 4;
+                        _context29.next = 4;
                         return gi({ app: yk0BuildApp, ykServerEnv: env, appsNoneExit: false });
 
                       case 4:
-                        _context13.t0 = cmd;
-                        _context13.next = _context13.t0 === "commit-init" ? 7 : 8;
+                        _context29.t0 = cmd;
+                        _context29.next = _context29.t0 === "commit-init" ? 7 : 8;
                         break;
 
                       case 7:
-                        return _context13.abrupt('break', 14);
+                        return _context29.abrupt('break', 14);
 
                       case 8:
-                        _context13.next = 10;
+                        _context29.next = 10;
                         return (0, _verify.commitEsLint)({ edit: edit });
 
                       case 10:
-                        _context13.next = 12;
+                        _context29.next = 12;
                         return (0, _verify.commitStyleLint)({ edit: edit });
 
                       case 12:
-                        _context13.next = 14;
+                        _context29.next = 14;
                         return (0, _verify.commitMsg)({ edit: msg });
 
                       case 14:
                       case 'end':
-                        return _context13.stop();
+                        return _context29.stop();
                     }
                   }
-                }, _callee13, undefined);
+                }, _callee29, undefined);
               }));
 
-              return function (_x11, _x12) {
-                return _ref20.apply(this, arguments);
+              return function (_x39, _x40) {
+                return _ref37.apply(this, arguments);
               };
             }()
             // case "commit-eslint":
@@ -765,78 +1946,78 @@ var run = exports.run = function () {
             );
 
             _commander2.default.command('server <cmd>').alias('s').option('-y0ba, --yk0-build-app <appName>', 'Building a specified application').option('-e, --env <envName>', 'yk server env').description('service control').action(function () {
-              var _ref22 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee15(cmd, _ref21) {
-                var yk0BuildApp = _ref21.yk0BuildApp,
-                    env = _ref21.env;
+              var _ref39 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee31(cmd, _ref38) {
+                var yk0BuildApp = _ref38.yk0BuildApp,
+                    env = _ref38.env;
 
-                var _ref23, apps;
+                var _ref40, apps;
 
-                return _regenerator2.default.wrap(function _callee15$(_context15) {
+                return _regenerator2.default.wrap(function _callee31$(_context31) {
                   while (1) {
-                    switch (_context15.prev = _context15.next) {
+                    switch (_context31.prev = _context31.next) {
                       case 0:
                         if (!(_os2.default.platform() === 'win32')) {
-                          _context15.next = 3;
+                          _context31.next = 3;
                           break;
                         }
 
                         _consola2.default.error(_msg.errMsg['os.win32.cmd.server']);
-                        return _context15.abrupt('return');
+                        return _context31.abrupt('return');
 
                       case 3:
                         process.env.NODE_ENV = 'production';
                         process.env.NODE_CMD = 'server ' + cmd;
-                        _context15.next = 7;
+                        _context31.next = 7;
                         return gi({ app: yk0BuildApp, ykServerEnv: env });
 
                       case 7:
-                        _ref23 = _context15.sent;
-                        apps = _ref23.apps;
+                        _ref40 = _context31.sent;
+                        apps = _ref40.apps;
 
                         if (!['start', 'stop', 'restart', 'lite', 'container'].includes(cmd)) {
-                          _context15.next = 21;
+                          _context31.next = 21;
                           break;
                         }
 
-                        _context15.t0 = cmd;
-                        _context15.next = _context15.t0 === 'lite' ? 13 : 17;
+                        _context31.t0 = cmd;
+                        _context31.next = _context31.t0 === 'lite' ? 13 : 17;
                         break;
 
                       case 13:
                         alias({ appName: apps[0] });
-                        _context15.next = 16;
+                        _context31.next = 16;
                         return require(params.serverLite)(cmd);
 
                       case 16:
-                        return _context15.abrupt('break', 19);
+                        return _context31.abrupt('break', 19);
 
                       case 17:
-                        _context15.next = 19;
+                        _context31.next = 19;
                         return _server._.asyncMap(apps, function () {
-                          var _ref24 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee14(key, j) {
-                            return _regenerator2.default.wrap(function _callee14$(_context14) {
+                          var _ref41 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee30(key, j) {
+                            return _regenerator2.default.wrap(function _callee30$(_context30) {
                               while (1) {
-                                switch (_context14.prev = _context14.next) {
+                                switch (_context30.prev = _context30.next) {
                                   case 0:
                                     alias({ appName: key });
-                                    _context14.next = 3;
+                                    _context30.next = 3;
                                     return require(params.serverPath)(cmd, key, j !== apps.length - 1);
 
                                   case 3:
                                   case 'end':
-                                    return _context14.stop();
+                                    return _context30.stop();
                                 }
                               }
-                            }, _callee14, undefined);
+                            }, _callee30, undefined);
                           }));
 
-                          return function (_x15, _x16) {
-                            return _ref24.apply(this, arguments);
+                          return function (_x43, _x44) {
+                            return _ref41.apply(this, arguments);
                           };
                         }());
 
                       case 19:
-                        _context15.next = 23;
+                        _context31.next = 23;
                         break;
 
                       case 21:
@@ -845,14 +2026,14 @@ var run = exports.run = function () {
 
                       case 23:
                       case 'end':
-                        return _context15.stop();
+                        return _context31.stop();
                     }
                   }
-                }, _callee15, undefined);
+                }, _callee31, undefined);
               }));
 
-              return function (_x13, _x14) {
-                return _ref22.apply(this, arguments);
+              return function (_x41, _x42) {
+                return _ref39.apply(this, arguments);
               };
             }()).on('--help', function () {
               console.log('');
@@ -864,29 +2045,29 @@ var run = exports.run = function () {
             });
 
             _commander2.default.command('publish').alias('pub').description('Publish to server').action(function () {
-              var _ref25 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee16(env, options) {
-                return _regenerator2.default.wrap(function _callee16$(_context16) {
+              var _ref42 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee32(env, options) {
+                return _regenerator2.default.wrap(function _callee32$(_context32) {
                   while (1) {
-                    switch (_context16.prev = _context16.next) {
+                    switch (_context32.prev = _context32.next) {
                       case 0:
                         process.env.NODE_TYPE = 'publish';
-                        _context16.next = 3;
+                        _context32.next = 3;
                         return gi();
 
                       case 3:
-                        _context16.next = 5;
+                        _context32.next = 5;
                         return require('../utils/deployment')();
 
                       case 5:
                       case 'end':
-                        return _context16.stop();
+                        return _context32.stop();
                     }
                   }
-                }, _callee16, undefined);
+                }, _callee32, undefined);
               }));
 
-              return function (_x17, _x18) {
-                return _ref25.apply(this, arguments);
+              return function (_x45, _x46) {
+                return _ref42.apply(this, arguments);
               };
             }());
 
@@ -895,18 +2076,18 @@ var run = exports.run = function () {
               process.exit(2);
             });
 
-            _commander2.default.parse(process.argv);
+            _commander2.default.parse(argv);
 
-          case 15:
+          case 32:
           case 'end':
-            return _context17.stop();
+            return _context33.stop();
         }
       }
-    }, _callee17, undefined);
+    }, _callee33, undefined, [[3, 12]]);
   }));
 
-  return function run(_x3) {
-    return _ref3.apply(this, arguments);
+  return function run(_x33) {
+    return _ref21.apply(this, arguments);
   };
 }();