@cabloy/cli 3.0.66 → 3.0.68

package/dist/index.js

@@ -1,6 +1,1615 @@
-export * from "./config.js";
-export * from "./lib/index.js";
-export * from "./registry.js";
-export * from "./start.js";
-export * from "./types/index.js";
-export * from "./utils.js";
+import { glob } from '@cabloy/module-glob';
+import { createRequire } from 'node:module';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import semver from 'semver';
+import urllib from 'urllib';
+import NPMConfig from '@npmcli/config';
+import npmDefinitions from '@npmcli/config/lib/definitions/index.js';
+import path from 'node:path';
+import fse from 'fs-extra';
+import { pathToFileURL } from 'node:url';
+import * as ModuleInfo from '@cabloy/module-info';
+import { ProcessHelper } from '@cabloy/process-helper';
+import { combineResourceName, catchError, evaluate } from '@cabloy/utils';
+import TableClass from 'cli-table3';
+import gogocode from 'gogocode';
+import tmp from 'tmp';
+import fs from 'node:fs';
+import ejs from '@zhennann/ejs';
+import { globby } from 'globby';
+import isTextOrBinary from 'istextorbinary';
+import BaseCommand from '@zhennann/common-bin';
+import enquirer from 'enquirer';
+import is from 'is-type-of';
+
+const commandsConfig = {
+  sets: {
+    zova: {
+      front: 'zova-cli-set-front'
+    },
+    vona: {
+      api: 'vona-cli-set-api'
+    }
+  },
+  helper: {
+    chalk: {
+      options: {
+        level: 2
+      }
+    },
+    boxen: {
+      options: {
+        padding: 1,
+        margin: 1,
+        align: 'center',
+        borderColor: 'yellow',
+        borderStyle: 'round'
+      }
+    }
+  },
+  template: {
+    render: {
+      fileMapping: {
+        'gitignore': '.gitignore',
+        '_gitignore': '.gitignore',
+        '_.gitignore': '.gitignore',
+        '_package.json': 'package.json',
+        '_.eslintrc': '.eslintrc',
+        '_.eslintignore': '.eslintignore',
+        '_.npmignore': '.npmignore',
+        '_.npmrc': '.npmrc',
+        '_.eslintrc.js': '.eslintrc.js',
+        '_jsconfig.json': 'jsconfig.json',
+        '_tsconfig.json': 'tsconfig.json',
+        '_tsconfig.base.json': 'tsconfig.base.json',
+        '_tsconfig.build.json': 'tsconfig.build.json'
+      },
+      ignore: ['.DS_Store']
+    }
+  }
+};
+
+let __registry;
+async function getRegistry() {
+  if (!__registry) {
+    const npmConfig = new NPMConfig(Object.assign({
+      npmPath: ''
+    }, npmDefinitions));
+    await npmConfig.load();
+    __registry = npmConfig.get('registry') || 'https://registry.npmjs.org/';
+    if (!__registry.endsWith('/')) {
+      __registry = `${__registry}/`;
+    }
+  }
+  return __registry;
+}
+
+const boxenOptions = {
+  padding: 1,
+  margin: 1,
+  align: 'center',
+  borderColor: 'yellow',
+  borderStyle: 'round'
+};
+async function checkForUpdates(packageName) {
+  try {
+    // version old
+    const require = createRequire(import.meta.url);
+    const pkg = require(`${packageName}/package.json`);
+    const versionOld = pkg.version;
+    // version new
+    const info = await getPackageInfo(packageName);
+    const versionNew = info.version;
+    // check
+    const lt = semver.lt(versionOld, versionNew);
+    if (!lt) return;
+    // log
+    let message = `[${chalk.keyword('cyan')(packageName)}] new version available: ${chalk.keyword('yellow')(versionOld)} → ${chalk.keyword('orange')(versionNew)}`;
+    message += `\nRun ${chalk.keyword('orange')(`> pnpm add -g ${packageName} <`)} to update!`;
+    // eslint-disable-next-line
+    console.log('\n' + boxen(message, boxenOptions));
+  } catch (_err) {
+    // donothing
+  }
+}
+async function getPackageInfo(packageName) {
+  const registry = await getRegistry();
+  const result = await urllib.request(`${registry}${packageName}/latest`, {
+    dataType: 'json',
+    followRedirect: true,
+    maxRedirects: 5
+  });
+  if (result.status !== 200) {
+    const message = `npm info ${packageName} got error: ${result.status}, ${result.data.reason}`;
+    throw new Error(message);
+  }
+  return result.data;
+}
+function patchFlavor(flavor) {
+  return Array.isArray(flavor) ? flavor[flavor.length - 1] : flavor;
+}
+
+class LocalCommon {
+  constructor(cli) {
+    this.cli = void 0;
+    this.cli = cli;
+  }
+  async _generateTypeModulesFile(projectPath) {
+    const pathName = this.cli.context.brandName === 'zova' ? 'front' : 'backend';
+    const typeFile = path.join(projectPath, `src/${pathName}/typing/modules.d.ts`);
+    let content = '';
+    // // all suites
+    // for (const key in this.modulesMeta.suites) {
+    //   const suite = this.modulesMeta.suites[key];
+    //   content += `import '${suite.package.name}';\n`;
+    // }
+    // all modules
+    this.cli.modulesMeta.modulesArray.forEach(module => {
+      content += `import '${module.package.name}';\n`;
+    });
+    await fse.writeFile(typeFile, content);
+    const typeFileStat = await fse.stat(typeFile);
+    // all modules: type file
+    const promises = [];
+    for (const module of this.cli.modulesMeta.modulesArray) {
+      if (module.info.node_modules) continue;
+      const moduleTypeFile = path.join(module.root, 'src/.metadata/modules.d.ts');
+      promises.push(this._generateTypeModulesFileInner(typeFile, typeFileStat, moduleTypeFile));
+    }
+    await Promise.all(promises);
+  }
+  async _generateTypeModulesFileInner(typeFile, typeFileStat, moduleTypeFile) {
+    const win = true; // process.platform.startsWith('win');
+    let needCreate = true;
+    const exists = await fse.exists(moduleTypeFile);
+    if (exists) {
+      try {
+        if (win) {
+          const stat = await fse.stat(moduleTypeFile);
+          if (stat.size === typeFileStat.size) {
+            needCreate = false;
+          }
+        }
+      } catch (_err) {}
+    }
+    if (needCreate) {
+      await fse.remove(moduleTypeFile);
+      {
+        await fse.copy(typeFile, moduleTypeFile);
+      }
+    }
+  }
+  async _generatePackageJson(projectPath) {
+    const pkgFile = path.join(projectPath, 'package.json');
+    const pkgOriginalFile = path.join(projectPath, 'package.original.json');
+    // check original
+    if (!fse.existsSync(pkgOriginalFile)) {
+      await fse.copyFile(pkgFile, pkgOriginalFile);
+    }
+    // prepare deps
+    const {
+      deps,
+      depsDev
+    } = await this._generatePackageJson_prepareDeps(projectPath);
+    // pkg/pkgOriginal
+    const pkgOriginal = await this.cli.helper.loadJSONFile(pkgOriginalFile);
+    if (fse.existsSync(pkgFile)) {
+      const pkg = await this.cli.helper.loadJSONFile(pkgFile);
+      // save back
+      await this._generatePackageJson_saveBack(pkg, pkgOriginal, pkgOriginalFile, deps, depsDev);
+    }
+    // generate pkg from pkgOriginal
+    await this._generatePackageJson_pkgFromPkgOriginal(pkgOriginal, pkgFile, deps, depsDev);
+  }
+  async _generatePackageJson_prepareDeps(_projectPath) {
+    const deps = {};
+    const depsDev = {};
+    // all modules
+    this.cli.modulesMeta.modulesArray.forEach(module => {
+      const onlyDev = _checkIfModuleOnlyDev(module);
+      const version = module.info.node_modules ? `^${module.package.version}` : 'workspace:^';
+      if (onlyDev) {
+        depsDev[module.package.name] = version;
+      } else {
+        deps[module.package.name] = version;
+      }
+    });
+    // all globalDependencies of modules
+    this.cli.modulesMeta.modulesArray.forEach(module => {
+      _collectModuleDevs(module, deps, 'dependencies', 'globalDependencies');
+      _collectModuleDevs(module, depsDev, 'devDependencies', 'globalDependenciesDev');
+    });
+    return {
+      deps,
+      depsDev
+    };
+  }
+  async _generatePackageJson_pkgFromPkgOriginal(pkgOriginal, pkgFile, deps, depsDev) {
+    function _handleDeps(nameDependencies, deps) {
+      for (const key in deps) {
+        const version = deps[key];
+        if (!pkgOriginal[nameDependencies][key]) {
+          pkgOriginal[nameDependencies][key] = version;
+        }
+      }
+    }
+    _handleDeps('dependencies', deps);
+    _handleDeps('devDependencies', depsDev);
+    await this.cli.helper.saveJSONFile(pkgFile, pkgOriginal);
+  }
+  async _generatePackageJson_saveBack(pkg, pkgOriginal, pkgOriginalFile, deps, depsDev) {
+    let changed = false;
+    for (const key of ['version', 'gitHead']) {
+      if (pkgOriginal[key] !== pkg[key]) {
+        pkgOriginal[key] = pkg[key];
+        changed = true;
+      }
+    }
+    function _handleDeps(nameDependencies, deps) {
+      const moduleDeps = pkg[nameDependencies];
+      const moduleDepsOriginal = pkgOriginal[nameDependencies];
+      for (const key in moduleDeps) {
+        const version = moduleDeps[key];
+        if (moduleDepsOriginal[key] && moduleDepsOriginal[key] === version) continue;
+        const isModule = key.includes('vona-module-') || key.includes('zova-module-');
+        const isModuleWorkspace = isModule && version.startsWith('workspace:');
+        if (isModuleWorkspace) continue;
+        if (deps[key] && !isModule) continue;
+        moduleDepsOriginal[key] = version;
+        changed = true;
+      }
+    }
+    _handleDeps('dependencies', deps);
+    _handleDeps('devDependencies', depsDev);
+    if (changed) {
+      await this.cli.helper.saveJSONFile(pkgOriginalFile, pkgOriginal);
+    }
+  }
+}
+function _checkIfModuleOnlyDev(module) {
+  const meta = module.package.vonaModule?.capabilities?.meta || module.package.zovaModule?.capabilities?.meta;
+  if (!meta || !meta.mode) return false;
+  const modes = Array.isArray(meta.mode) ? meta.mode : [meta.mode];
+  return !modes.some(mode => ['prod', 'production'].includes(mode));
+}
+function _collectModuleDevs(module, deps, nameDependencies, nameGlobalDependencies) {
+  const moduleDeps = module.package[nameDependencies];
+  const globalDependencies = module.package.vonaModule?.[nameGlobalDependencies] || module.package.zovaModule?.[nameGlobalDependencies];
+  if (globalDependencies) {
+    for (const key in globalDependencies) {
+      let version = globalDependencies[key];
+      if (version !== false) {
+        if (version === true) version = moduleDeps[key];
+        deps[key] = version;
+      }
+    }
+  }
+  return deps;
+}
+
+class LocalConsole {
+  constructor(cli) {
+    this.cli = void 0;
+    this.cli = cli;
+  }
+  get options() {
+    return this.cli.options;
+  }
+  get context() {
+    return this.cli.options.context;
+  }
+  async log(data, options = {}) {
+    if (!data) return;
+    // data
+    if (typeof data !== 'object') {
+      data = {
+        text: String(data)
+      };
+    }
+    let {
+      /* progressNo, */total,
+      progress,
+      text
+    } = data;
+    // logPrefix
+    const logPrefix = options.logPrefix;
+    if (logPrefix) {
+      text = this._adjustText(logPrefix, text);
+    }
+    // fallback
+    if (!this.cli.terminal) {
+      if (total !== undefined && progress !== undefined) {
+        const progressValid = progress >= 0;
+        const progressText = `(${progressValid ? progress + 1 : '-'}/${total})`;
+        if (progressValid) {
+          text = this._adjustText(`${progressText}=> `, text);
+        }
+      }
+      // eslint-disable-next-line
+      console.log(text);
+    }
+  }
+  _adjustText(prefix, text) {
+    return String(text).split('\n').map(item => item ? prefix + item : item).join('\n');
+  }
+}
+
+class LocalHelper {
+  constructor(cli) {
+    this.cli = void 0;
+    this.processHelper = void 0;
+    this.cli = cli;
+    this.processHelper = new ProcessHelper(this.cwd, this.console);
+  }
+  get options() {
+    return this.cli.options;
+  }
+  get context() {
+    return this.cli.options.context;
+  }
+  get console() {
+    return this.cli.console;
+  }
+  get template() {
+    return this.cli.template;
+  }
+  get moduleConfig() {
+    return commandsConfig;
+  }
+  get chalk() {
+    return this.newChalk();
+  }
+  get Table() {
+    return TableClass;
+  }
+  get cwd() {
+    return this.context.argv.projectPath;
+  }
+  newChalk(options) {
+    if (!options) {
+      options = this.moduleConfig.helper.chalk.options;
+    }
+    return new chalk.Instance(options);
+  }
+  newTable(options) {
+    return new TableClass(options);
+  }
+  boxen({
+    text,
+    options
+  }) {
+    if (!options) {
+      options = this.moduleConfig.helper.boxen.options;
+    }
+    return boxen(text, options);
+  }
+  gogocode(sourceCode, options) {
+    return gogocode(sourceCode, options);
+  }
+  firstCharToLowerCase(name) {
+    return name.charAt(0).toLowerCase() + name.substring(1);
+  }
+  firstCharToUpperCase(name) {
+    return name.charAt(0).toUpperCase() + name.substring(1);
+  }
+  stringToCapitalize(str, separator) {
+    if (typeof str === 'string') str = str.split(separator);
+    return str.map(name => {
+      return this.firstCharToUpperCase(name);
+    }).join('');
+  }
+  slashPrefixForPath(count) {
+    if (count === 0) return './';
+    return '../'.repeat(count);
+  }
+  parseNameMeta(name, ignores) {
+    const original = name;
+    const parts = original.split('/');
+    const directory = parts.slice(0, parts.length - 1).join('/');
+    const short = parts[parts.length - 1];
+    const shortCapitalize = this.firstCharToUpperCase(short);
+    let partsFull;
+    if (ignores && parts.length > 1 && ignores.includes(parts[0])) {
+      partsFull = parts.slice(1);
+    } else {
+      partsFull = parts;
+    }
+    if (partsFull.length > 1 && partsFull[0] === partsFull[1]) {
+      partsFull = partsFull.slice(1);
+    }
+    const fullCapitalize = this.stringToCapitalize(partsFull, '/');
+    const full = this.firstCharToLowerCase(fullCapitalize);
+    return {
+      original,
+      parts,
+      directory,
+      short,
+      shortCapitalize,
+      full,
+      fullCapitalize
+    };
+  }
+  parseModuleInfo(moduleName) {
+    const moduleInfo = ModuleInfo.parseInfoPro(moduleName, process.env.CabloyCliBrandName, 'module');
+    if (!moduleInfo) throw new Error(`module name is not valid: ${moduleName}`);
+    return moduleInfo;
+  }
+  findModule(moduleName) {
+    const moduleInfo = this.parseModuleInfo(moduleName);
+    return this.cli.modulesMeta.modules[moduleInfo.relativeName];
+  }
+  parseSuiteInfo(suiteName) {
+    const suiteInfo = ModuleInfo.parseInfoPro(suiteName, process.env.CabloyCliBrandName, 'suite');
+    if (!suiteInfo) throw new Error(`suite name is not valid: ${suiteName}`);
+    return suiteInfo;
+  }
+  findSuite(suiteName) {
+    const suiteInfo = this.parseSuiteInfo(suiteName);
+    return this.cli.modulesMeta.suites[suiteInfo.relativeName];
+  }
+  async ensureDir(dir) {
+    await fse.ensureDir(dir);
+    return dir;
+  }
+  async pnpmInstall() {
+    // args
+    const args = ['install'];
+    // log
+    await this.console.log('===> pnpm install');
+    // spawn
+    await this.spawnCmd({
+      cmd: 'pnpm',
+      args
+    });
+  }
+  async formatFile({
+    fileName,
+    logPrefix
+  }) {
+    if (_formatFileDisable(fileName)) return;
+    return await this.processHelper.formatFile({
+      fileName,
+      logPrefix
+    });
+  }
+  async spawnBin({
+    cmd,
+    args,
+    options
+  }) {
+    return await this.processHelper.spawnBin({
+      cmd,
+      args,
+      options
+    });
+  }
+  async spawnCmd({
+    cmd,
+    args,
+    options
+  }) {
+    return await this.processHelper.spawnCmd({
+      cmd,
+      args,
+      options
+    });
+  }
+  async spawnExe({
+    cmd,
+    args,
+    options
+  }) {
+    return await this.processHelper.spawnExe({
+      cmd,
+      args,
+      options
+    });
+  }
+  async spawn({
+    cmd,
+    args = [],
+    options = {}
+  }) {
+    return await this.processHelper.spawn({
+      cmd,
+      args,
+      options
+    });
+  }
+  async gitCommit({
+    cwd,
+    message
+  }) {
+    return await this.processHelper.gitCommit(message, {
+      cwd
+    });
+  }
+  async getRegistry() {
+    return await getRegistry();
+  }
+  parseBrandPath() {
+    const require = createRequire(import.meta.url);
+    const modulePath = require.resolve(`${process.env.CabloyCliBrandName}-cli/package.json`);
+    // ts or js
+    let file = path.join(path.dirname(modulePath), `src/bin/${process.env.CabloyCliBrandName}.ts`);
+    if (!fse.existsSync(file)) {
+      file = path.join(path.dirname(modulePath), `dist/bin/${process.env.CabloyCliBrandName}.js`);
+    }
+    return file;
+  }
+  async invokeCli(args, options) {
+    // tsx: spawnCmd, node: spawnExe
+    await this.processHelper.spawnCmd({
+      cmd: 'tsx',
+      args: [this.parseBrandPath()].concat(args),
+      // cmd: 'node',
+      // args: ['--experimental-transform-types', getImportEsm(), this.parseBrandPath()].concat(args),
+      options
+    });
+  }
+  async loadJSONFile(fileName) {
+    const pkgContent = (await fse.readFile(fileName)).toString();
+    return JSON.parse(pkgContent);
+  }
+  async saveJSONFile(fileName, json, format) {
+    await fse.writeFile(fileName, `${JSON.stringify(json, null, 2)}\n`);
+    if (format !== false) {
+      await this.formatFile({
+        fileName
+      });
+    }
+  }
+  safeSplit(str, sep = ',') {
+    let left = 0;
+    let start = 0;
+    const result = [];
+    while (start < str.length) {
+      let end = start;
+      while (end < str.length) {
+        if (str[end] === sep && left === 0) {
+          result.push(str.substring(start, end));
+          start = end + 1;
+          break;
+        }
+        if (str[end] === '<') left++;
+        if (str[end] === '>') left--;
+        end++;
+      }
+      if (start < end) {
+        result.push(str.substring(start, end));
+        start = end + 1;
+      }
+    }
+    if (start <= str.length) {
+      result.push(str.substring(start, str.length));
+    }
+    return result;
+  }
+  async removeGitkeep(parentPath) {
+    const gitkeep = path.join(parentPath, '.gitkeep');
+    if (fse.existsSync(gitkeep)) {
+      await fse.remove(gitkeep);
+    }
+  }
+  combineModuleNameAndResource(moduleName, resourceName) {
+    return combineResourceName(resourceName, moduleName, true, true);
+  }
+  async importDynamic(fileName, fn) {
+    // load
+    const instance = await import(this.pathToHref(fileName));
+    if (!fn) return instance;
+    return await fn(instance);
+  }
+  requireDynamic(file) {
+    if (!file) throw new Error('file should not empty');
+    const require = createRequire(import.meta.url);
+    let instance = require(file);
+    const mtime = this._requireDynamic_getFileTime(file);
+    if (instance.__requireDynamic_mtime === undefined) {
+      instance.__requireDynamic_mtime = mtime;
+    } else if (instance.__requireDynamic_mtime !== mtime) {
+      delete require.cache[require.resolve(file)];
+      instance = require(file);
+      instance.__requireDynamic_mtime = mtime;
+    }
+    return instance;
+  }
+  _requireDynamic_getFileTime(file) {
+    if (!path.isAbsolute(file)) return null;
+    const exists = fse.pathExistsSync(file);
+    if (!exists) return null;
+    // stat
+    const stat = fse.statSync(file);
+    return stat.mtime.valueOf();
+  }
+  async tempFile(fn, options) {
+    // temp
+    const fileTempObj = tmp.fileSync(options);
+    const fileTemp = fileTempObj.name;
+    try {
+      return await fn(fileTemp);
+    } finally {
+      // delete temp
+      fileTempObj.removeCallback();
+    }
+  }
+  pathToHref(fileName) {
+    return pathToFileURL(fileName).href;
+  }
+}
+function _formatFileDisable(fileName) {
+  const baseName = path.basename(fileName);
+  if (/.env\..*$/.test(baseName)) return true;
+  if (['.env', 'docker-compose-dockerfile-app', 'docker-compose.yml'].includes(baseName)) return true;
+  return false;
+}
+
+// async importDynamic<RESULT>(fileName: string, fn: (instance: any) => Promise<RESULT>): Promise<RESULT> {
+//   return await this.tempFile(
+//     async fileTemp => {
+//       // build
+//       const esBuildConfig = this._createEsbuildConfig(fileName, fileTemp);
+//       await esBuild(esBuildConfig as any);
+//       // load
+//       const instance = await import(this._pathToHref(fileTemp));
+//       return await fn(instance);
+//     },
+//     {
+//       tmpdir: path.dirname(fileName),
+//       prefix: '.temp-dynamic-',
+//       postfix: '.mjs',
+//     },
+//   );
+// }
+
+// private _createEsbuildConfig(fileSrc: string, fileDest: string) {
+//   return {
+//     platform: 'node',
+//     format: 'esm',
+//     bundle: true,
+//     packages: 'external',
+//     resolveExtensions: ['.mjs', '.js', '.mts', '.ts', '.json'],
+//     entryPoints: [fileSrc],
+//     outfile: fileDest,
+//   };
+// }
+
+class LocalTemplate {
+  constructor(cli) {
+    this.cli = void 0;
+    this.cli = cli;
+  }
+  get options() {
+    return this.cli.options;
+  }
+  get context() {
+    return this.cli.options.context;
+  }
+  get console() {
+    return this.cli.console;
+  }
+  get helper() {
+    return this.cli.helper;
+  }
+  get moduleConfig() {
+    return commandsConfig;
+  }
+  get fileMapping() {
+    return this.moduleConfig.template.render.fileMapping;
+  }
+  get filesIgnore() {
+    return this.moduleConfig.template.render.ignore;
+  }
+  resolveTemplatePath(setName, _path) {
+    if (path.isAbsolute(_path)) return _path;
+    const sets = this.moduleConfig.sets;
+    const require = createRequire(import.meta.url);
+    const modulePath = require.resolve(`${sets[process.env.CabloyCliBrandName][setName]}/package.json`);
+    return path.join(path.dirname(modulePath), 'cli/templates', _path);
+  }
+  async renderBoilerplateAndSnippets({
+    targetDir,
+    setName,
+    snippetsPath,
+    boilerplatePath
+  }) {
+    await this.helper.ensureDir(targetDir);
+    // first
+    if (snippetsPath) {
+      const snippetsDir = this.resolveTemplatePath(setName, snippetsPath);
+      await this.applySnippets(targetDir, snippetsDir);
+    }
+    // then
+    if (boilerplatePath) {
+      const templateDir = this.resolveTemplatePath(setName, boilerplatePath);
+      await this.renderDir(targetDir, templateDir);
+    }
+  }
+  async renderDir(targetDir, templateDir) {
+    const {
+      argv
+    } = this.context;
+    // files
+    const files = await globby('**/*', {
+      cwd: templateDir,
+      dot: true,
+      onlyFiles: false
+    });
+    // loop
+    for (const file of files) {
+      const {
+        dir: dirname,
+        base: basename
+      } = path.parse(file);
+      if (this.filesIgnore.includes(basename)) continue;
+      const templateFile = path.join(templateDir, file);
+      const fileName = this.parseFileBaseName(basename);
+      const parentPath = path.join(targetDir, dirname);
+      const targetFile = path.join(parentPath, this.replaceTemplate(fileName, argv));
+      await this.renderFile({
+        targetFile,
+        templateFile
+      });
+      if (fileName !== '.gitkeep') {
+        await this.helper.removeGitkeep(parentPath);
+      }
+    }
+    return files;
+  }
+  replaceTemplate(content, scope) {
+    if (!content) return null;
+    return content.toString().replace(/(\\)?\{\{ *([\w.]+) *\}\}/g, (block, skip, key) => {
+      if (skip) {
+        return block.substring(skip.length);
+      }
+      const value = this.getProperty(scope, key);
+      return value !== undefined ? value : '';
+    });
+  }
+  getProperty(obj, name, sep) {
+    return this._getProperty(obj, name, sep, false);
+  }
+  _getProperty(obj, name, sep, forceObject) {
+    if (!obj) return undefined;
+    const names = name.split(sep || '.');
+    // loop
+    for (const name of names) {
+      if (obj[name] === undefined || obj[name] === null) {
+        if (forceObject) {
+          obj[name] = {};
+        } else {
+          obj = obj[name];
+          break;
+        }
+      }
+      obj = obj[name];
+    }
+    return obj;
+  }
+  parseFileBaseName(basename) {
+    let fileName = this.fileMapping[basename] || basename;
+    if (fileName.lastIndexOf('_') === fileName.length - 1) {
+      fileName = fileName.substring(0, fileName.length - 1);
+    }
+    return fileName;
+  }
+  async renderFile({
+    targetFile,
+    templateFile
+  }) {
+    const stats = fs.lstatSync(templateFile);
+    if (stats.isSymbolicLink()) {
+      const target = fs.readlinkSync(templateFile);
+      fs.symlinkSync(target, targetFile);
+      await this.console.log(`${targetFile} link to ${target}`);
+    } else if (stats.isDirectory()) {
+      await this.helper.ensureDir(targetFile);
+    } else if (stats.isFile()) {
+      const content = fs.readFileSync(templateFile);
+      await this.console.log(`write to ${targetFile}`);
+      // check if content is a text file
+      let result;
+      let changed;
+      if (!isTextOrBinary.isTextSync(templateFile, content)) {
+        result = content;
+      } else {
+        const _content = content.toString('utf8');
+        result = await this.renderContent({
+          content: _content
+        });
+        changed = _content !== result;
+      }
+      // save
+      fs.writeFileSync(targetFile, result);
+      // format
+      if (changed && !this.context.argv.noformat) {
+        await catchError(() => {
+          return this.helper.formatFile({
+            fileName: targetFile,
+            logPrefix: 'format: '
+          });
+        });
+      }
+    } else {
+      await this.console.log(`ignore ${templateFile}, only support file, dir, symlink`);
+    }
+  }
+  async renderContent({
+    content
+  }) {
+    if (!content) return content;
+    const data = this.getEjsData();
+    const options = this.getEjsOptions();
+    return await ejs.render(content, data, options);
+  }
+  getEjsOptions() {
+    return {
+      async: true,
+      cache: false,
+      compileDebug: true,
+      outputFunctionName: 'echo',
+      rmWhitespace: false
+    };
+  }
+  getEjsData() {
+    return {
+      cli: this.cli,
+      ...this.context
+    };
+  }
+  getAstData(ast, snippet) {
+    return {
+      cli: this.cli,
+      ast,
+      snippet,
+      ...this.context
+    };
+  }
+  getInitData(targetFile) {
+    return {
+      cli: this.cli,
+      targetFile,
+      ...this.context
+    };
+  }
+  async applySnippets(targetDir, snippetsDir) {
+    // snippets
+    let files = await globby('*.{cjs,ts}', {
+      cwd: snippetsDir,
+      onlyFiles: true
+    });
+    // snippets sort
+    files = files.filter(item => item[0] !== '-').sort((a, b) => this._parseSnippetFilePrefix(a) - this._parseSnippetFilePrefix(b));
+    // for
+    for (const file of files) {
+      const snippetTemplatePath = path.join(snippetsDir, file);
+      await this._loadSnippetInstance(snippetTemplatePath, async snippet => {
+        if (!snippet.file) {
+          throw new Error(`should provider file path for: ${file}`);
+        }
+        let fileName;
+        if (typeof snippet.file === 'function') {
+          fileName = snippet.file(this.getEjsData());
+        } else {
+          fileName = await this.renderContent({
+            content: snippet.file
+          });
+        }
+        if (!fileName) ; else {
+          const targetFile = path.join(targetDir, fileName);
+          await this.applySnippet(targetFile, snippet);
+        }
+      });
+    }
+  }
+  async _loadSnippetInstance(snippetTemplatePath, fn) {
+    return await this.helper.importDynamic(snippetTemplatePath, instance => {
+      return fn(instance.default);
+    });
+  }
+  async applySnippet(targetFile, snippet) {
+    await this.console.log(`apply changes to ${targetFile}`);
+    // source code
+    let sourceCode;
+    if (fs.existsSync(targetFile)) {
+      sourceCode = fs.readFileSync(targetFile);
+      sourceCode = sourceCode.toString('utf8');
+    } else {
+      if (!snippet.init) {
+        throw new Error(`should provider init content for: ${targetFile}`);
+      }
+      let content;
+      if (typeof snippet.init === 'function') {
+        content = await snippet.init(this.getInitData(targetFile));
+      } else {
+        content = snippet.init;
+      }
+      sourceCode = await this.renderContent({
+        content
+      });
+    }
+    // language
+    const language = snippet.language;
+    // transform
+    let outputCode;
+    if (language === 'plain') {
+      const ast = sourceCode;
+      const outAst = await snippet.transform(this.getAstData(ast, snippet));
+      outputCode = outAst;
+    } else if (language === 'json') {
+      const ast = JSON.parse(sourceCode);
+      const outAst = await snippet.transform(this.getAstData(ast, snippet));
+      outputCode = outAst === undefined ? outAst : JSON.stringify(outAst, null, 2);
+    } else {
+      const ast = gogocode(sourceCode, {
+        parseOptions: snippet.parseOptions
+      });
+      const outAst = await snippet.transform(this.getAstData(ast, snippet));
+      outputCode = outAst === undefined ? outAst : outAst.root().generate();
+    }
+    if (outputCode !== undefined) {
+      // save
+      fs.writeFileSync(targetFile, outputCode);
+      // format
+      if (snippet.format || !this.context.argv.noformat) {
+        await catchError(() => {
+          return this.helper.formatFile({
+            fileName: targetFile,
+            logPrefix: 'format: '
+          });
+        });
+      }
+    }
+  }
+  _parseSnippetFilePrefix(fileName) {
+    const num = fileName.split('-')[0];
+    if (!num || Number.isNaN(num)) return 10000;
+    return Number.parseInt(num);
+  }
+}
+
+class BeanCliBase {
+  constructor(options) {
+    this.options = void 0;
+    this.terminal = void 0;
+    this.__console = void 0;
+    this.__helper = void 0;
+    this.__template = void 0;
+    this.__common = void 0;
+    this.modulesMeta = void 0;
+    this.options = options;
+    this.terminal = options.terminal !== false;
+  }
+  get console() {
+    if (!this.__console) {
+      this.__console = new LocalConsole(this);
+    }
+    return this.__console;
+  }
+  get helper() {
+    if (!this.__helper) {
+      this.__helper = new LocalHelper(this);
+    }
+    return this.__helper;
+  }
+  get template() {
+    if (!this.__template) {
+      this.__template = new LocalTemplate(this);
+    }
+    return this.__template;
+  }
+  get common() {
+    if (!this.__common) {
+      this.__common = new LocalCommon(this);
+    }
+    return this.__common;
+  }
+  get context() {
+    return this.options.context;
+  }
+  get cliFullName() {
+    return this.options.context.argv.cliFullName;
+  }
+  async meta() {
+    await this._loadModulesMeta();
+    const metaLocale = this._commandMeta();
+    return metaLocale;
+  }
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    if (argv.flavor) {
+      argv.flavor = patchFlavor(argv.flavor);
+    }
+    await this._loadModulesMeta();
+  }
+  async _loadModulesMeta() {
+    //
+    if (this.modulesMeta) return;
+    // all modules
+    this.modulesMeta = await glob({
+      projectPath: this.context.argv.projectPath,
+      disabledModules: undefined,
+      disabledSuites: undefined,
+      log: false,
+      projectMode: process.env.CabloyCliBrandName
+    });
+  }
+  _commandMeta() {
+    const {
+      command
+    } = this.options;
+    const {
+      argv
+    } = this.context;
+    const meta = {};
+    meta.info = this._commandMeta_info({
+      info: command.info,
+      argv
+    });
+    meta.options = this._commandMeta_options({
+      options: command.options,
+      argv
+    });
+    meta.groups = this._commandMeta_groups({
+      groups: command.groups,
+      argv
+    });
+    return meta;
+  }
+  _commandMeta_groups({
+    groups
+  }) {
+    const metaGroups = {};
+    if (groups) {
+      for (const groupName in groups) {
+        const group = groups[groupName];
+        metaGroups[groupName] = this._commandMeta_group({
+          group
+        });
+      }
+    }
+    return metaGroups;
+  }
+  _commandMeta_group({
+    group
+  }) {
+    const metaGroup = {
+      description: group.description,
+      condition: group.condition,
+      questions: {}
+    };
+    for (const key in group.questions) {
+      const question = group.questions[key];
+      metaGroup.questions[key] = {
+        ...question,
+        message: question.message
+      };
+    }
+    return metaGroup;
+  }
+  _commandMeta_options({
+    options
+  }) {
+    const metaOptions = {};
+    if (options) {
+      for (const key in options) {
+        const option = options[key];
+        metaOptions[key] = {
+          ...option,
+          description: option.description
+        };
+      }
+    }
+    return metaOptions;
+  }
+  _commandMeta_info({
+    info,
+    argv
+  }) {
+    // info
+    const metaInfo = {
+      version: info.version,
+      title: info.title,
+      usage: info.usage
+    };
+    // usage
+    if (!metaInfo.usage) {
+      metaInfo.usage = `${'Usage'}: ${process.env.CabloyCliBrandName} ${argv.cliFullName} [options] [-h] [-v]`;
+    }
+    // welcomes
+    metaInfo.welcomes = this._commandMeta_info_welcomes({
+      info
+    });
+    // ok
+    return metaInfo;
+  }
+  _commandMeta_info_welcomes({
+    info
+  }) {
+    let welcomes = info.welcomes || [];
+    if (!Array.isArray(welcomes)) welcomes = [welcomes];
+    welcomes = welcomes.map(item => item);
+    return welcomes;
+  }
+}
+
+let __commandsMeta;
+async function getCommandsMeta() {
+  await collectCommands();
+  return __commandsMeta;
+}
+function findCommand(cliFullName) {
+  return __commandsMeta.map[cliFullName];
+}
+async function collectCommands() {
+  await _collectCommands();
+}
+async function _collectCommands() {
+  if (__commandsMeta) return;
+  const _commandsMap = {};
+  const _commandsAll = {};
+  const sets = commandsConfig.sets[process.env.CabloyCliBrandName];
+  for (const setName in sets) {
+    const setModuleName = sets[setName];
+    const setModule = await import(setModuleName); // 270ms
+    const commands = setModule.commands;
+    if (!commands) continue;
+    const _commandsSet = _commandsAll[setName] = {};
+    for (const groupName in commands) {
+      const group = commands[groupName];
+      const _commandsGroup = _commandsSet[groupName] = {};
+      for (const key in group) {
+        const command = group[key];
+        const fullKey = `${setName}:${groupName}:${key}`;
+        // command BeanClass
+        const BeanClass = setModule.beans[command.bean];
+        // ok
+        _commandsMap[fullKey] = _commandsGroup[key] = {
+          command,
+          BeanClass
+        };
+      }
+    }
+  }
+  // ok
+  __commandsMeta = {
+    map: _commandsMap,
+    all: _commandsAll
+  };
+}
+
+class BeanCli {
+  async meta({
+    context
+  }) {
+    // command
+    const {
+      argv
+    } = context;
+    const cliFullName = argv.cliFullName;
+    const {
+      command,
+      BeanClass
+    } = await this._findCliCommand({
+      cliFullName
+    });
+    // command bean
+    const beanCommand = new BeanClass({
+      command,
+      context,
+      terminal: false
+    });
+    if (!beanCommand) throw new Error(`cli command bean not found: ${command.beanFullName}`);
+    // meta
+    return await beanCommand.meta();
+  }
+  async execute({
+    context
+  }) {
+    // command
+    const {
+      argv
+    } = context;
+    const cliFullName = argv.cliFullName;
+    const {
+      command,
+      BeanClass
+    } = await this._findCliCommand({
+      cliFullName
+    });
+    // command bean
+    const beanCommand = new BeanClass({
+      command,
+      context,
+      terminal: false
+    });
+    if (!beanCommand) throw new Error(`cli command bean not found: ${command.beanFullName}`);
+    // execute
+    await beanCommand.execute();
+  }
+  _findCliCommand({
+    cliFullName
+  }) {
+    const commandInfo = findCommand(cliFullName);
+    if (!commandInfo || !commandInfo.command) throw new Error(`cli command not found: ${cliFullName}`);
+    return commandInfo;
+  }
+}
+
+const __envFields = ['TERM', 'TERM_PROGRAM', 'TERM_PROGRAM_VERSION', 'SHELL', 'COLOR', 'LANG', 'npm_config_registry'];
+const __comment_seperator = '====================================================================';
+class CliCommand extends BaseCommand {
+  constructor(rawArgv, {
+    meta,
+    argv
+  }) {
+    super(rawArgv);
+    this.__meta = void 0;
+    this.__groups = void 0;
+    this.__argv = void 0;
+    this.usage = meta.info.usage; // readonly
+    this.options = meta.options; // readonly
+    this.version = meta.info.version;
+    this.__meta = meta;
+    this.__groups = meta.groups;
+    this.__argv = argv;
+  }
+  async run(options) {
+    let {
+      argv,
+      cwd,
+      env,
+      rawArgv
+    } = options;
+    // argv
+    argv = this._prepareArgv(argv);
+    // context
+    const context = {
+      brandName: process.env.CabloyCliBrandName,
+      argv,
+      cwd,
+      env: this._adjustEnv({
+        env
+      }),
+      rawArgv
+    };
+    // log start
+    if (!argv.dummy) {
+      // eslint-disable-next-line no-console
+      console.log(`${process.env.CabloyCliBrandName} ${chalk.cyan(argv.cliFullName)} at %s\n`, cwd);
+    }
+    // log meta welcomes
+    if (!argv.dummy) {
+      this._logMetaWelcomes();
+    }
+    // prompt
+    await this._promptGroups({
+      context,
+      groups: this.__groups
+    });
+    // execute
+    const beanCli = new BeanCli();
+    await beanCli.execute({
+      context
+    });
+    // done: log cli docs
+    if (!argv.dummy) {
+      this._logCliDocs();
+    }
+    // done
+    // console.log(chalk.cyan('\n  cli successfully!\n'));
+  }
+  _getMetaWelcomes() {
+    let welcomes = this.__meta.info.welcomes;
+    if (!welcomes) return null;
+    if (!Array.isArray(welcomes)) welcomes = [welcomes];
+    if (welcomes.length === 0) return null;
+    return welcomes;
+  }
+  _logMetaWelcomes() {
+    const welcomes = this._getMetaWelcomes();
+    if (!welcomes) return;
+    // eslint-disable-next-line no-console
+    console.log(__comment_seperator);
+    for (const welcome of welcomes) {
+      // eslint-disable-next-line no-console
+      console.log(welcome);
+    }
+    // eslint-disable-next-line no-console
+    console.log(__comment_seperator);
+    // eslint-disable-next-line no-console
+    console.log('');
+  }
+  _logCliDocs() {
+    const welcomes = this._getMetaWelcomes();
+    if (!welcomes) return;
+    const welcome = welcomes[0];
+    if (!welcome || !welcome.includes('articles/cli-introduce.html')) return;
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(__comment_seperator);
+    // eslint-disable-next-line no-console
+    console.log(welcome);
+    // eslint-disable-next-line no-console
+    console.log(__comment_seperator);
+  }
+  _adjustEnv({
+    env
+  }) {
+    const res = {};
+    for (const field of __envFields) {
+      if (env[field]) res[field] = env[field];
+    }
+    return res;
+  }
+  async _promptGroups({
+    context,
+    groups
+  }) {
+    for (const groupName in groups) {
+      const group = groups[groupName];
+      await this._promptGroup({
+        group,
+        context
+      });
+    }
+  }
+  async _promptGroup({
+    group,
+    context
+  }) {
+    const {
+      argv
+    } = context;
+    // check
+    const check = this._checkGroupCondition({
+      group,
+      context
+    });
+    if (!check) return;
+    // prepare
+    const varsWant = [];
+    for (const key in group.questions) {
+      const value = argv[key];
+      if (value !== undefined) continue;
+      const question = group.questions[key];
+      const varWant = this._prepareQuestion({
+        group,
+        question,
+        key,
+        context
+      });
+      if (varWant) {
+        varsWant.push(varWant);
+      }
+    }
+    if (varsWant.length === 0) return;
+    // log description
+    if (group.description) {
+      // eslint-disable-next-line no-console
+      console.log('===>', group.description);
+    }
+    // prompt
+    await enquirer.prompt(varsWant);
+  }
+  _prepareQuestionPropertyExpression({
+    group,
+    question,
+    key,
+    context,
+    propName
+  }) {
+    // expression
+    const expression = question[propName] && question[propName].expression;
+    if (!expression) return null;
+    return function (value) {
+      return evaluate(expression, {
+        value,
+        group,
+        question,
+        key,
+        context
+      });
+    };
+  }
+  _prepareQuestion({
+    group,
+    question,
+    key,
+    context
+  }) {
+    const {
+      argv
+    } = context;
+    // want
+    const varWant = {
+      name: key,
+      ...question
+    };
+    // message/skip/initial/format/validate
+    for (const propName of ['message', 'skip', 'initial', 'format', 'validate']) {
+      const propFunction = this._prepareQuestionPropertyExpression({
+        group,
+        question,
+        key,
+        context,
+        propName
+      });
+      if (propFunction) {
+        varWant[propName] = propFunction;
+      }
+    }
+    // special check initial
+    let initial = varWant.initial;
+    if (initial && is.function(initial)) {
+      initial = initial();
+      if (initial !== undefined) {
+        argv[key] = initial;
+        return null;
+      }
+    }
+    // result
+    varWant.result = value => {
+      const propFunction = this._prepareQuestionPropertyExpression({
+        group,
+        question,
+        key,
+        context,
+        propName: 'result'
+      });
+      if (propFunction) {
+        value = propFunction(value);
+      }
+      argv[key] = value;
+      return value;
+    };
+    // required
+    if (question.required) {
+      varWant.validate = value => {
+        if (!value) return 'Required';
+        return true;
+      };
+    }
+    // ok
+    return varWant;
+  }
+  _checkGroupCondition({
+    group,
+    context
+  }) {
+    const expression = group.condition && group.condition.expression;
+    if (!expression) return true;
+    return evaluate(expression, {
+      group,
+      context
+    });
+  }
+  _prepareArgv(argv) {
+    argv = Object.assign({}, argv, this.__argv);
+    delete argv.$0;
+    // alias
+    const options = this.__meta.options;
+    if (options) {
+      for (const key in options) {
+        const option = options[key];
+        if (option.alias && argv[key] === undefined) {
+          argv[key] = argv[option.alias];
+        }
+      }
+    }
+    return argv;
+  }
+}
+
+const DISPATCH = Symbol.for('eb:Command#dispatch');
+const PARSE = Symbol.for('eb:Command#parse');
+class CabloyCommand extends BaseCommand {
+  constructor(brandName, rawArgv) {
+    super(rawArgv);
+    this.brandName = void 0;
+    this.defaultSetName = void 0;
+    this.usage = `Usage: ${brandName} [command] [options]`;
+    this.defaultSetName = brandName === 'zova' ? 'front' : 'api';
+    this.brandName = brandName;
+    process.env.CabloyCliBrandName = brandName;
+  }
+  async [DISPATCH]() {
+    const parsed = await this[PARSE](this.rawArgv);
+    if (parsed._.length === 0) {
+      await super[DISPATCH]();
+      return;
+    }
+    // checkForUpdates
+    checkForUpdates(`${this.brandName}-cli`);
+    // collectCommands
+    await collectCommands();
+    // cli
+    await this._handleCli();
+  }
+  async _handleCli() {
+    // get parsed argument without handling helper and version
+    const parsed = await this[PARSE](this.rawArgv);
+    // argv
+    const argv = {
+      projectPath: process.cwd()
+    };
+    // indexBrandName
+    const indexBrandName = this.rawArgv.indexOf(this.brandName);
+    // cli
+    const indexCommand = indexBrandName > -1 ? indexBrandName + 1 : 0;
+    Object.assign(argv, this._prepareCliFullName(parsed._[indexCommand]));
+    // cli meta
+    const context = {
+      brandName: this.brandName,
+      argv
+    };
+    const beanCli = new BeanCli();
+    const meta = await beanCli.meta({
+      context
+    });
+    // cli run
+    const rawArgv = this.rawArgv.slice();
+    if (indexBrandName > -1) {
+      rawArgv.splice(0, indexBrandName + 2);
+    } else {
+      rawArgv.splice(0, 1);
+    }
+    const command = new CliCommand(rawArgv, {
+      meta,
+      argv
+    });
+    await command[DISPATCH]();
+    // should not force exit, let app shutdown gracefully
+    // process.exit(0);
+  }
+  _prepareCliFullName(cliName) {
+    if (!cliName) {
+      return {
+        cliFullName: `${this.defaultSetName}:default:list`
+      };
+      // throw new Error('Please specify the cli name');
+    }
+    const parts = cliName.split(':');
+    if (parts.length === 1) {
+      // means show module's commands
+      parts[1] = '';
+    }
+    if (parts.length === 2) {
+      if (parts[1]) {
+        // means show group's commands
+        parts[2] = '';
+      } else {
+        // means show module's commands
+        if (!parts[0]) parts[0] = this.defaultSetName;
+        return {
+          cliFullName: `${this.defaultSetName}:default:list`,
+          set: parts[0]
+        };
+      }
+    }
+    if (!parts[0]) parts[0] = this.defaultSetName;
+    if (!parts[1]) parts[1] = 'default';
+    if (!parts[2]) {
+      // means show group's commands
+      return {
+        cliFullName: `${this.defaultSetName}:default:list`,
+        set: parts[0],
+        group: parts[1]
+      };
+    }
+    // default
+    return {
+      cliFullName: parts.join(':')
+    };
+  }
+}
+
+function metadataCustomSnippet(snippet) {
+  return snippet;
+}
+
+export { BeanCli, BeanCliBase, CabloyCommand, CliCommand, LocalConsole, LocalHelper, LocalTemplate, checkForUpdates, collectCommands, commandsConfig, findCommand, getCommandsMeta, getPackageInfo, getRegistry, metadataCustomSnippet, patchFlavor };