vona-cli-set-api 1.0.401 → 1.0.405

package/dist/index.js

@@ -1,3 +1,3313 @@
-export * from "./lib/beans.js";
-export * from "./lib/commands.js";
-export * from "./lib/utils.js";
+import path from 'node:path';
+import { BeanCliBase, getCommandsMeta } from '@cabloy/cli';
+import aliasImport from '@rollup/plugin-alias';
+import babelImport from '@rollup/plugin-babel';
+import commonjsImport from '@rollup/plugin-commonjs';
+import jsonImport from '@rollup/plugin-json';
+import resolveImport from '@rollup/plugin-node-resolve';
+import replaceImport from '@rollup/plugin-replace';
+import terserImport from '@rollup/plugin-terser';
+import fse from 'fs-extra';
+import { globby } from 'globby';
+import { rimraf } from 'rimraf';
+import { rollup } from 'rollup';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import compileTemplate from 'lodash/template.js';
+import os from 'node:os';
+import * as dotenv from '@cabloy/dotenv';
+import { getEnvFiles } from '@cabloy/dotenv';
+import { glob } from '@cabloy/module-glob';
+import chalk from 'chalk';
+import nodemon from 'nodemon';
+import { catchError, combineApiPathControllerAndActionRaw, replaceTemplate } from '@cabloy/utils';
+import fs from 'node:fs';
+import { getOnionScenesMeta, getOnionMetasMeta, relativeNameToCapitalize } from '@cabloy/module-info';
+import { toUpperCaseFirstChar, stringToCapitalize, replaceTemplate as replaceTemplate$1 } from '@cabloy/word-utils';
+import compressing from 'compressing';
+import randomize from 'randomatic';
+import urllib from 'urllib';
+import * as uuid from 'uuid';
+import { beanFullNameFromOnionName } from 'vona-core';
+
+function getEnvMeta(configMeta) {
+  return {
+    flavor: configMeta.flavor,
+    mode: configMeta.mode,
+    mine: 'mine'
+  };
+}
+function getNodeEnv(mode) {
+  return mode === 'test' ? 'test' : mode === 'dev' ? 'development' : 'production';
+}
+function resolveTemplatePath(file) {
+  const url = new URL(path.join('../../templates', file), import.meta.url);
+  return fileURLToPath(url);
+}
+function generateConfigDefine(env, translates) {
+  const acc = {};
+  for (const key in env) {
+    if (!translates || translates.includes(key)) {
+      acc[`process.env.${key}`] = JSON.stringify(env[key]);
+    } else {
+      acc[`process.env.${key}`] = `'process.env.${key}->app.meta.env.${key}'`;
+    }
+  }
+  return acc;
+}
+function getAbsolutePathOfModule(id, postfix = 'index.js') {
+  const require = createRequire(import.meta.url);
+  let modulePath = require.resolve(id);
+  if (postfix) {
+    const pos = modulePath.lastIndexOf(postfix);
+    if (pos > -1) {
+      modulePath = modulePath.substring(0, modulePath.length - postfix.length - 1);
+    }
+  }
+  return modulePath;
+}
+function requireModule(id) {
+  const require = createRequire(import.meta.url);
+  return require(id);
+}
+async function copyTemplateFile(fileSrc, fileDest, variables) {
+  if (!variables) {
+    await fse.copyFile(fileSrc, fileDest);
+    return;
+  }
+  // src
+  const contentSrc = (await fse.readFile(fileSrc, 'utf-8')).toString();
+  const template = compileTemplate(contentSrc);
+  // dest
+  const contentDest = template(variables);
+  await fse.writeFile(fileDest, contentDest, 'utf-8');
+}
+async function loadJSONFile(fileName) {
+  const pkgContent = (await fse.readFile(fileName)).toString();
+  return JSON.parse(pkgContent);
+}
+async function saveJSONFile(fileName, json) {
+  await fse.writeFile(fileName, `${JSON.stringify(json, null, 2)}\n`);
+}
+function pathToHref(fileName) {
+  return pathToFileURL(fileName).href;
+}
+function getOutDir() {
+  return process.env.BUILD_OUTDIR || `dist/${process.env.META_FLAVOR}`;
+}
+function getOutReleasesDir() {
+  return `dist-releases/${process.env.META_FLAVOR}-${process.env.APP_VERSION}`;
+}
+function copyTemplateIfNeed(fileSrc, fileDest) {
+  if (!fse.existsSync(fileDest)) {
+    fse.copyFileSync(fileSrc, fileDest);
+  }
+}
+function getImportEsm() {
+  // return '--loader=ts-node/esm';
+  return '--import=./.vona/register.js';
+}
+
+function createConfigUtils(configMeta, configOptions) {
+  let __modulesMeta;
+  return {
+    loadEnvs: __loadEnvs,
+    loadModulesMeta: __loadModulesMeta
+  };
+
+  //////////////////////////////
+
+  function __loadEnvs() {
+    const meta = getEnvMeta(configMeta);
+    const envDir = path.join(configOptions.appDir, 'env');
+    const envs = dotenv.loadEnvs(meta, envDir, '.env');
+    const res = Object.assign({
+      NODE_ENV: getNodeEnv(meta.mode)
+    }, envs, {
+      META_FLAVOR: meta.flavor,
+      META_MODE: meta.mode
+    });
+    if (configOptions.workers !== undefined) {
+      res.SERVER_WORKERS = configOptions.workers.toString();
+    }
+    // maybe empty string
+    if (!res.SERVER_WORKERS) {
+      if (meta.mode === 'prod') {
+        res.SERVER_WORKERS = os.cpus().length.toString();
+      } else {
+        res.SERVER_WORKERS = '1';
+      }
+    }
+    for (const key of ['NODE_ENV', 'SERVER_WORKERS', 'META_FLAVOR', 'META_MODE']) {
+      if (res[key] !== false) {
+        process.env[key] = res[key];
+      }
+    }
+    // ok
+    return res;
+  }
+  async function __loadModulesMeta() {
+    const meta = getEnvMeta(configMeta);
+    // modules
+    __modulesMeta = await glob({
+      projectMode: 'vona',
+      projectPath: configOptions.appDir,
+      disabledModules: process.env.PROJECT_DISABLED_MODULES,
+      disabledSuites: process.env.PROJECT_DISABLED_SUITES,
+      log: false,
+      meta
+    });
+    return __modulesMeta;
+  }
+}
+
+const __ImportZodCore = 'zod/v4/core';
+async function generateZod(configOptions) {
+  await __generateZodCoreUtil(configOptions);
+  await __generateZodCoreSchemas(configOptions);
+}
+async function __generateZodCoreUtil(configOptions) {
+  const pathZodCore = parseZodCorePath(configOptions.appDir);
+  const fileSrc = path.join(pathZodCore, 'util.js');
+  const fileSrcBak = path.join(pathZodCore, 'util-origin.js');
+  copyTemplateIfNeed(fileSrc, fileSrcBak);
+  const content = fse.readFileSync(fileSrcBak).toString();
+  const contentNew = content.replace('export function finalizeIssue', `let __localeAdapterFn;
+export function setLocaleAdapter(localeAdapterFn) {
+  __localeAdapterFn=localeAdapterFn;
+}
+export function finalizeIssue`).replace('const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??', `const msg = unwrapMessage(iss.inst?._zod.def?.error?.(iss));
+        const message = (__localeAdapterFn?__localeAdapterFn(msg, iss):msg) ??`);
+  fse.writeFileSync(fileSrc, contentNew);
+}
+async function __generateZodCoreSchemas(configOptions) {
+  const pathZodCore = parseZodCorePath(configOptions.appDir);
+  const fileSrc = path.join(pathZodCore, 'schemas.js');
+  const fileSrcBak = path.join(pathZodCore, 'schemas-origin.js');
+  copyTemplateIfNeed(fileSrc, fileSrcBak);
+  const content = fse.readFileSync(fileSrcBak).toString();
+  const contentNew = content.replace('export const $ZodType =', `let __parseAdapterFn;
+export function setParseAdapter(parseAdapterFn) {
+    __parseAdapterFn = parseAdapterFn;
+}
+export const $ZodType =`).replace('inst._zod.run = inst._zod.parse;', 'inst._zod.run = __parseAdapterFn ? __parseAdapterFn(inst, inst._zod.parse) : inst._zod.parse;').replace(/inst._zod.run = (\(payload, ctx\) => \{[\s\S]*?return runChecks\(result, checks, ctx\);\s*\};)/, (_, $0) => {
+    return `const __run = ${$0}\ninst._zod.run = __parseAdapterFn ? __parseAdapterFn(inst, __run) : __run;`;
+  });
+  fse.writeFileSync(fileSrc, contentNew);
+}
+function parseZodCorePath(appDir) {
+  const require = createRequire(pathToHref(path.join(appDir, '/')));
+  const fileCoreIndex = require.resolve(__ImportZodCore);
+  return path.dirname(fileCoreIndex);
+}
+
+async function generateEntryFiles(configMeta, configOptions, modulesMeta, env) {
+  // config
+  await __generateConfig();
+  // modules meta
+  await __generateModulesMeta();
+  // env
+  await __generateEnvJson();
+  // app
+  await __generateApp();
+  // others
+  await __generateOthers();
+  // zod
+  await generateZod(configOptions);
+
+  //////////////////////////////
+
+  async function __generateConfig() {
+    // check config
+    let configDir = path.join(configOptions.appDir, 'src/backend/config');
+    if (!fse.existsSync(configDir)) {
+      // eslint-disable-next-line
+      console.log(chalk.red('path not found: src/backend/config\n'));
+      process.exit(0);
+    }
+    // meta
+    const meta = getEnvMeta(configMeta);
+    configDir = path.join(configOptions.appDir, 'src/backend/config/config');
+    const files = getEnvFiles(meta, configDir, 'config', '.ts');
+    const filenames = files.map(item => path.basename(item));
+    const imports = [];
+    const constNames = [];
+    for (const filename of filenames) {
+      const parts = filename.split('.');
+      let constName = parts[0];
+      for (let index = 1; index < parts.length - 1; index++) {
+        constName += parts[index].charAt(0).toUpperCase() + parts[index].substring(1);
+      }
+      imports.push(`import ${constName} from '../src/backend/config/config/${filename}';`);
+      constNames.push(constName);
+    }
+    const contentDest = `${imports.join('\n')}\nexport default [${constNames.join(', ')}];`;
+    // output
+    const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'config.ts');
+    fse.ensureFileSync(fileDest);
+    fse.writeFileSync(fileDest, contentDest, 'utf-8');
+  }
+  async function __generateApp() {
+    const templates = [['app/bootstrap.ejs', 'bootstrap.ts'], ['app/app.ejs', 'app.ts']];
+    for (const [templateSrc, templateDest] of templates) {
+      const fileSrc = resolveTemplatePath(templateSrc);
+      const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, templateDest);
+      await fse.ensureDir(path.join(configOptions.appDir, configOptions.runtimeDir));
+      const vars = {
+        appMonkey: fse.existsSync(path.join(configOptions.appDir, 'src/backend/config/monkey.ts'))
+      };
+      await copyTemplateFile(fileSrc, fileDest, vars);
+    }
+  }
+  async function __generateOthers() {
+    const templates = [['app/register.js', 'register.js']];
+    for (const [templateSrc, templateDest] of templates) {
+      const fileSrc = resolveTemplatePath(templateSrc);
+      const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, templateDest);
+      await fse.ensureDir(path.join(configOptions.appDir, configOptions.runtimeDir));
+      const vars = {};
+      await copyTemplateFile(fileSrc, fileDest, vars);
+    }
+  }
+  async function __generateModulesMeta() {
+    // modules
+    const {
+      modules,
+      modulesArray
+    } = modulesMeta;
+    const moduleNames = modulesArray.map(item => item.info.relativeName);
+    // src
+    const fileSrc = resolveTemplatePath('app/vona-modules-meta.ejs');
+    const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'modules-meta.ts');
+    await fse.ensureDir(path.join(configOptions.appDir, configOptions.runtimeDir));
+    await copyTemplateFile(fileSrc, fileDest, {
+      modules,
+      moduleNames
+    });
+  }
+  async function __generateEnvJson() {
+    const contentDest = `export default ${JSON.stringify(env, null, 2)} as unknown as NodeJS.ProcessEnv;\n`;
+    // output
+    const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'env.ts');
+    fse.ensureFileSync(fileDest);
+    fse.writeFileSync(fileDest, contentDest, 'utf-8');
+  }
+}
+
+async function generateVonaMeta(configMeta, configOptions) {
+  // config utils
+  const configUtils = createConfigUtils(configMeta, configOptions);
+  // env
+  const env = configUtils.loadEnvs();
+  // modulesMeta
+  const modulesMeta = await configUtils.loadModulesMeta();
+  // generateEntryFiles
+  await generateEntryFiles(configMeta, configOptions, modulesMeta, env);
+  // ok
+  return {
+    env,
+    modulesMeta
+  };
+}
+
+const commonjs$2 = commonjsImport;
+const resolve$2 = resolveImport;
+// const swc = swcImport as any as typeof swcImport.default;
+const json$2 = jsonImport;
+const babel$2 = babelImport;
+const terser$2 = terserImport;
+const alias$2 = aliasImport;
+const replace = replaceImport;
+const __dialectDriversAll = ['pg', 'mysql2', 'better-sqlite3', 'mysql', 'oracledb', 'pg-native', 'pg-query-stream', 'sqlite3', 'tedious', 'cloudflare:sockets'];
+class CliBinBuild extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    await this._build(projectPath);
+  }
+  async _build(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const mode = 'prod';
+    const flavor = argv.flavor || 'normal';
+    const configMeta = {
+      flavor,
+      mode
+    };
+    const configOptions = {
+      appDir: projectPath,
+      runtimeDir: '.vona',
+      workers: argv.workers
+    };
+    const {
+      env,
+      modulesMeta
+    } = await generateVonaMeta(configMeta, configOptions);
+    const outDir = path.join(projectPath, getOutDir());
+    await rimraf(outDir);
+    await this._rollup(projectPath, env, outDir);
+    await this._assets(projectPath, modulesMeta, outDir);
+    // custom
+    await this._custom(projectPath, env, outDir);
+    // remove .vona
+    await rimraf(path.join(projectPath, '.vona'));
+    // copy
+    const outReleasesDir = path.join(projectPath, getOutReleasesDir());
+    await rimraf(outReleasesDir);
+    fse.copySync(outDir, outReleasesDir);
+    // copy
+    if (process.env.BUILD_COPY_DIST) {
+      const envDist = path.isAbsolute(process.env.BUILD_COPY_DIST) ? process.env.BUILD_COPY_DIST : path.join(projectPath, process.env.BUILD_COPY_DIST);
+      const outDirCopy = path.join(envDist, path.basename(outDir));
+      fse.removeSync(outDirCopy);
+      fse.copySync(outDir, outDirCopy);
+    }
+    if (process.env.BUILD_COPY_RELEASE) {
+      const envRelease = path.isAbsolute(process.env.BUILD_COPY_RELEASE) ? process.env.BUILD_COPY_RELEASE : path.join(projectPath, process.env.BUILD_COPY_RELEASE);
+      const outReleasesDirCopy = path.join(envRelease, path.basename(outReleasesDir));
+      fse.removeSync(outReleasesDirCopy);
+      fse.copySync(outDir, outReleasesDirCopy);
+    }
+  }
+  async _custom(projectPath, env, outDir) {
+    // custom
+    const jsFile = path.join(projectPath, 'src/backend/cli.ts');
+    if (!fse.existsSync(jsFile)) return;
+    return await this.helper.importDynamic(jsFile, async instance => {
+      const options = {
+        cli: this,
+        env,
+        outDir,
+        projectPath
+      };
+      return await instance.afterBuild(options);
+    });
+  }
+  async _assets(_projectPath, modulesMeta, outDir) {
+    const assetsPath = path.join(outDir, 'assets');
+    for (const relativeName in modulesMeta.modules) {
+      const module = modulesMeta.modules[relativeName];
+      const scenes = await globby('assets/*', {
+        cwd: module.root,
+        onlyDirectories: true
+      });
+      for (const scene2 of scenes) {
+        const scene = scene2.substring('assets/'.length);
+        const scenePath = path.join(module.root, scene2);
+        const destPath = path.join(assetsPath, scene, relativeName);
+        await fse.copy(scenePath, destPath);
+      }
+    }
+  }
+  async _rollup(projectPath, env, outDir) {
+    const aliasEntries = [];
+    const dialectDrivers = (process.env.BUILD_DIALECT_DRIVERS || '').split(',');
+    for (const name of __dialectDriversAll) {
+      if (dialectDrivers.includes(name)) continue;
+      aliasEntries.push({
+        find: name,
+        replacement: 'vona-shared'
+      });
+    }
+    const replaceValues = generateConfigDefine(env, ['NODE_ENV', 'META_MODE', 'META_FLAVOR']);
+    const babelPluginZovaBeanModule = getAbsolutePathOfModule('babel-plugin-zova-bean-module', '');
+    const babelPluginTransformTypescriptMetadata = getAbsolutePathOfModule('babel-plugin-transform-typescript-metadata', '');
+    const babelPluginProposalDecorators = getAbsolutePathOfModule('@babel/plugin-proposal-decorators', '');
+    const babelPluginTransformClassProperties = getAbsolutePathOfModule('@babel/plugin-transform-class-properties', '');
+    const babelPluginTransformTypescript = getAbsolutePathOfModule('@babel/plugin-transform-typescript', '');
+    const plugins = [alias$2({
+      entries: aliasEntries
+    }), resolve$2({
+      preferBuiltins: true
+    }), replace({
+      values: replaceValues,
+      preventAssignment: false
+    }), json$2(), commonjs$2(), babel$2({
+      include: '**/*.ts',
+      extensions: ['.ts', '.tsx'],
+      babelHelpers: 'bundled',
+      skipPreflightCheck: true,
+      babelrc: false,
+      configFile: false,
+      plugins: [[babelPluginZovaBeanModule, {
+        brandName: 'vona'
+      }], [babelPluginTransformTypescriptMetadata], [babelPluginProposalDecorators, {
+        version: 'legacy'
+      }], [babelPluginTransformClassProperties, {
+        loose: true
+      }], [babelPluginTransformTypescript]]
+    })];
+    if (process.env.BUILD_MINIFY === 'true') {
+      plugins.push(terser$2({
+        keep_classnames: true
+      }));
+    }
+    const inputOptions = {
+      input: path.join(projectPath, '.vona/bootstrap.ts'),
+      plugins,
+      onLog: (level, log, defaultHandler) => {
+        if (log.code === 'CIRCULAR_DEPENDENCY' && process.env.BUILD_LOG_CIRCULAR_DEPENDENCY === 'false') return;
+        if (log.code === 'THIS_IS_UNDEFINED' && (log.message.includes('ramda/es/partialObject.js') || log.message.includes("The 'this' keyword is equivalent to 'undefined' at the top level of an ES module"))) return;
+        if (log.code === 'EVAL' && log.message.includes('depd/index.js')) return;
+        if (log.code === 'EVAL' && log.message.includes('bluebird/js/release/util.js')) return;
+        defaultHandler(level, log);
+      }
+    };
+    const outputOption = {
+      dir: outDir,
+      // file: path.join(projectPath, 'dist/index.js'),
+      format: 'esm',
+      sourcemap: process.env.BUILD_SOURCEMAP === 'true',
+      // https://github.com/rollup/rollup/issues/4166
+      inlineDynamicImports: false // should not true
+    };
+    let bundle;
+    try {
+      bundle = await rollup(inputOptions);
+      await bundle.write(outputOption);
+    } finally {
+      if (bundle) {
+        // closes the bundle
+        await bundle.close();
+      }
+    }
+  }
+}
+
+const commonjs$1 = commonjsImport;
+const resolve$1 = resolveImport;
+// const swc = swcImport as any as typeof swcImport.default;
+const json$1 = jsonImport;
+const babel$1 = babelImport;
+const terser$1 = terserImport;
+const alias$1 = aliasImport;
+class CliBinBuildGeneral extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    await this._build(projectPath);
+  }
+  async _build(projectPath) {
+    await rimraf(path.join(projectPath, 'dist'));
+    await this._rollup(projectPath);
+  }
+  async _rollup(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const aliasEntries = [];
+    const plugins = [alias$1({
+      entries: aliasEntries
+    }), resolve$1({
+      preferBuiltins: true
+    }), json$1(), commonjs$1(), babel$1({
+      include: '**/*.ts',
+      extensions: ['.ts', '.tsx'],
+      babelHelpers: 'bundled',
+      skipPreflightCheck: true,
+      babelrc: false,
+      configFile: false,
+      plugins: [['babel-plugin-transform-typescript-metadata'], ['@babel/plugin-proposal-decorators', {
+        version: 'legacy'
+      }], ['@babel/plugin-transform-class-properties', {
+        loose: true
+      }], ['@babel/plugin-transform-typescript']]
+    })];
+    if (argv.minify) {
+      plugins.push(terser$1({
+        keep_classnames: true
+      }));
+    }
+    const inputOptions = {
+      input: path.join(projectPath, 'src/index.ts'),
+      plugins,
+      onLog: (level, log, defaultHandler) => {
+        if (log.code === 'CIRCULAR_DEPENDENCY') return;
+        if (log.code === 'THIS_IS_UNDEFINED' && (log.message.includes('ramda/es/partialObject.js') || log.message.includes("The 'this' keyword is equivalent to 'undefined' at the top level of an ES module"))) return;
+        if (log.code === 'EVAL' && log.message.includes('depd/index.js')) return;
+        if (log.code === 'EVAL' && log.message.includes('bluebird/js/release/util.js')) return;
+        defaultHandler(level, log);
+      },
+      external(source, _importer, _isResolved) {
+        if (source.includes('/src/') || source.startsWith('.')) return false;
+        return true;
+      }
+    };
+    const outputOption = {
+      dir: path.join(projectPath, 'dist'),
+      // file: path.join(projectPath, 'dist/index.js'),
+      format: 'esm',
+      sourcemap: argv.sourcemap,
+      // https://github.com/rollup/rollup/issues/4166
+      inlineDynamicImports: true
+    };
+    let bundle;
+    try {
+      bundle = await rollup(inputOptions);
+      await bundle.write(outputOption);
+    } finally {
+      if (bundle) {
+        // closes the bundle
+        await bundle.close();
+      }
+    }
+  }
+}
+
+const commonjs = commonjsImport;
+const resolve = resolveImport;
+// const swc = swcImport as any as typeof swcImport.default;
+const json = jsonImport;
+const babel = babelImport;
+const terser = terserImport;
+const alias = aliasImport;
+class CliBinBuildModule extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    await this._build(projectPath);
+  }
+  async _build(projectPath) {
+    await rimraf(path.join(projectPath, 'dist'));
+    await this._rollup(projectPath);
+  }
+  async _rollup(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const aliasEntries = [];
+    for (const name of ['better-sqlite3', 'mysql', 'oracledb', 'pg-native', 'pg-query-stream', 'sqlite3', 'tedious', 'cloudflare:sockets']) {
+      aliasEntries.push({
+        find: name,
+        replacement: 'vona-shared'
+      });
+    }
+    const plugins = [alias({
+      entries: aliasEntries
+    }), resolve({
+      preferBuiltins: true
+    }), json(), commonjs(), babel({
+      include: '**/*.ts',
+      extensions: ['.ts', '.tsx'],
+      babelHelpers: 'bundled',
+      skipPreflightCheck: true,
+      babelrc: false,
+      configFile: false,
+      plugins: [['babel-plugin-zova-bean-module', {
+        brandName: 'vona'
+      }], ['babel-plugin-transform-typescript-metadata'], ['@babel/plugin-proposal-decorators', {
+        version: 'legacy'
+      }], ['@babel/plugin-transform-class-properties', {
+        loose: true
+      }], ['@babel/plugin-transform-typescript']]
+    })];
+    if (argv.minify) {
+      plugins.push(terser({
+        keep_classnames: true
+      }));
+    }
+    const inputOptions = {
+      input: path.join(projectPath, 'src/index.ts'),
+      plugins,
+      onLog: (level, log, defaultHandler) => {
+        if (log.code === 'CIRCULAR_DEPENDENCY') return;
+        if (log.code === 'THIS_IS_UNDEFINED' && (log.message.includes('ramda/es/partialObject.js') || log.message.includes("The 'this' keyword is equivalent to 'undefined' at the top level of an ES module"))) return;
+        if (log.code === 'EVAL' && log.message.includes('depd/index.js')) return;
+        if (log.code === 'EVAL' && log.message.includes('bluebird/js/release/util.js')) return;
+        defaultHandler(level, log);
+      },
+      external(source, _importer, _isResolved) {
+        if (source.includes('/src/') || source.startsWith('.')) return false;
+        return true;
+      }
+    };
+    const outputOption = {
+      dir: path.join(projectPath, 'dist'),
+      // file: path.join(projectPath, 'dist/index.js'),
+      format: 'esm',
+      sourcemap: argv.sourcemap,
+      // https://github.com/rollup/rollup/issues/4166
+      inlineDynamicImports: true
+    };
+    let bundle;
+    try {
+      bundle = await rollup(inputOptions);
+      await bundle.write(outputOption);
+    } finally {
+      if (bundle) {
+        // closes the bundle
+        await bundle.close();
+      }
+    }
+  }
+}
+
+class CliBinDbReset extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // test
+    await this._dbReset(projectPath);
+  }
+  async _dbReset(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const mode = 'test';
+    const flavor = argv.flavor || 'normal';
+    const configMeta = {
+      flavor,
+      mode
+    };
+    const configOptions = {
+      appDir: projectPath,
+      runtimeDir: '.vona',
+      workers: 1
+    };
+    const {
+      modulesMeta
+    } = await generateVonaMeta(configMeta, configOptions);
+    await this._run(projectPath, modulesMeta);
+    await rimraf(path.join(projectPath, '.vona'));
+  }
+  async _run(projectPath, _modulesMeta) {
+    // testFile
+    let testFile = path.join(import.meta.dirname, './toolsBin/dbReset.ts');
+    if (!fse.existsSync(testFile)) {
+      testFile = path.join(import.meta.dirname, './toolsBin/dbReset.js');
+    }
+    // run
+    let args = [];
+    args = args.concat([getImportEsm(), testFile, projectPath]);
+    // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath]);
+    await this.helper.spawnExe({
+      cmd: 'node',
+      args,
+      options: {
+        cwd: projectPath
+      }
+    });
+  }
+}
+
+class CliBinDev extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // run
+    await this._dev(projectPath);
+  }
+  async _dev(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const mode = 'dev';
+    const flavor = argv.flavor || 'normal';
+    const configMeta = {
+      flavor,
+      mode
+    };
+    const configOptions = {
+      appDir: projectPath,
+      runtimeDir: '.vona',
+      workers: argv.workers
+    };
+    const {
+      modulesMeta
+    } = await generateVonaMeta(configMeta, configOptions);
+    await this._run(projectPath, modulesMeta);
+    await rimraf(path.join(projectPath, '.vona'));
+  }
+  async _run(projectPath, _modulesMeta) {
+    let closed = false;
+    return new Promise((resolve, _reject) => {
+      nodemon({
+        script: '.vona/bootstrap.ts',
+        cwd: projectPath,
+        exec: 'node',
+        execArgs: [getImportEsm()],
+        // execArgs: ['--experimental-transform-types', getImportEsm(), '--trace-deprecation'],
+        // signal: 'SIGHUP',
+        watch: ['packages-utils', 'packages-vona', './src'],
+        ignore: ['**/node_modules/**', '**/dist/**', '**/test/**/*.test.ts', 'src/backend/play/**', 'src/backend/typing/**', '**/src/config/errors.ts', '**/src/config/locale/*.ts', '**/src/config/config.ts', '**/src/config/constants.ts', '**/src/types/**', '**/src/controller/*.ts', '**/src/model/*.ts', '**/src/service/*.ts', '**/src/bean/*.*.ts']
+      });
+      nodemon.on('quit', () => {
+        closed = true;
+        resolve(undefined);
+      }).on('restart', files => {
+        if (closed) {
+          // force exit
+          process.exit(0);
+        }
+        // eslint-disable-next-line
+        console.log('App restarted due to: ', files);
+      });
+    });
+    // await this.helper.spawnExe({
+    //   cmd: 'node',
+    //   args: ['--experimental-transform-types', '--loader=ts-node/esm', '.vona/bootstrap.ts'],
+    //   options: {
+    //     cwd: projectPath,
+    //   },
+    // });
+  }
+}
+
+class CliBinPlay extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // test
+    await this._play(projectPath);
+  }
+  async _play(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const mode = argv.mode || 'dev';
+    const flavor = argv.flavor || 'play';
+    const configMeta = {
+      flavor,
+      mode
+    };
+    if (!argv.retainRuntime || !fse.existsSync(path.join(projectPath, '.vona'))) {
+      const configOptions = {
+        appDir: projectPath,
+        runtimeDir: '.vona',
+        workers: 1
+      };
+      await generateVonaMeta(configMeta, configOptions);
+    }
+    if (argv.attach) {
+      await this._runAttach(projectPath);
+    } else {
+      await this._runIsolate(projectPath);
+    }
+  }
+  async _runAttach(projectPath) {
+    const runtimeFile = path.join(projectPath, '.app/runtime/-.json');
+    if (!fse.existsSync(runtimeFile)) throw new Error('dev server not running');
+    // args
+    let args = [];
+    const pos = process.argv.indexOf(':bin:play');
+    if (pos > -1) {
+      args = args.concat(process.argv.slice(pos + 1));
+    }
+    const body = {
+      args,
+      projectPath
+    };
+    //
+    const runtime = await loadJSONFile(runtimeFile);
+    const runtimeCore = runtime['a-core'];
+    const runtimeUser = runtime['a-user'];
+    const result = await fetch(`${runtimeCore?.protocol}://${runtimeCore?.host}/api/play`, {
+      method: 'post',
+      headers: {
+        'content-type': 'application/json',
+        'authorization': `Bearer ${runtimeUser?.accessToken}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (result.status !== 200) {
+      const message = `error: ${result.status}, ${result.statusText}`;
+      throw new Error(message);
+    }
+    const res = await result.json();
+    if (res.code !== 0) throw new Error(res.message);
+    if (res.data !== undefined) {
+      // eslint-disable-next-line no-console
+      console.log(res.data);
+    }
+  }
+  async _runIsolate(projectPath) {
+    // testFile
+    let testFile = path.join(import.meta.dirname, './toolsBin/play.ts');
+    if (!fse.existsSync(testFile)) {
+      testFile = path.join(import.meta.dirname, './toolsBin/play.js');
+    }
+    // run
+    let args = [];
+    args = args.concat([getImportEsm(), testFile, projectPath]);
+    // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath]);
+    const pos = process.argv.indexOf(':bin:play');
+    if (pos > -1) {
+      args = args.concat(process.argv.slice(pos + 1));
+    }
+    await this.helper.spawnExe({
+      cmd: 'node',
+      args,
+      options: {
+        cwd: projectPath
+      }
+    });
+  }
+}
+
+class CliBinTest extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // test
+    await this._test(projectPath);
+  }
+  async _test(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const mode = 'test';
+    const flavor = argv.flavor || 'normal';
+    const configMeta = {
+      flavor,
+      mode
+    };
+    const configOptions = {
+      appDir: projectPath,
+      runtimeDir: '.vona',
+      workers: 1
+    };
+    const {
+      modulesMeta
+    } = await generateVonaMeta(configMeta, configOptions);
+    await this._run(projectPath, modulesMeta);
+    if (argv.coverage && !argv.ci) {
+      await this._outputCoverageReportViewer(projectPath);
+    }
+    await rimraf(path.join(projectPath, '.vona'));
+  }
+  async _run(projectPath, modulesMeta) {
+    const {
+      argv
+    } = this.context;
+    // globs
+    const patterns = this._combineTestPatterns(projectPath, modulesMeta);
+    // testFile
+    let testFile = path.join(import.meta.dirname, './toolsBin/test.ts');
+    if (!fse.existsSync(testFile)) {
+      testFile = path.join(import.meta.dirname, './toolsBin/test.js');
+    }
+    // run
+    let args = [];
+    if (argv.coverage) {
+      args.push('--experimental-test-coverage');
+    }
+    if (process.env.TEST_WHYISNODERUNNING === 'true') {
+      args.push('--import=why-is-node-running/include');
+    }
+    args = args.concat([getImportEsm(), testFile, projectPath, (!!argv.coverage).toString(), patterns.join(',')]);
+    // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath, (!!argv.coverage).toString(), patterns.join(',')]);
+    // ignore error special in windows
+    await catchError(() => {
+      return this.helper.spawnExe({
+        cmd: 'node',
+        args,
+        options: {
+          cwd: projectPath
+        }
+      });
+    });
+  }
+  async _outputCoverageReportViewer(projectPath) {
+    // lcovCliFile
+    const lcovCliFile = getAbsolutePathOfModule('@lcov-viewer/cli/lib/index.js', '');
+    // run
+    const args = [lcovCliFile, 'lcov', '-o', './coverage/report', './coverage/lcov.info'];
+    await catchError(() => {
+      return this.helper.spawnExe({
+        cmd: 'node',
+        args,
+        options: {
+          cwd: projectPath
+        }
+      });
+    });
+  }
+  _combineTestPatterns(projectPath, modulesMeta) {
+    const patterns = [];
+    for (const moduleName in modulesMeta.modules) {
+      const module = modulesMeta.modules[moduleName];
+      if (module.info.node_modules) continue;
+      const testDir = path.join(module.root, 'test');
+      if (fse.existsSync(testDir)) {
+        const relativePath = path.relative(projectPath, module.root).replaceAll('\\', '/');
+        patterns.push(`${relativePath}/test/**/*.ts`);
+      }
+    }
+    return patterns;
+  }
+}
+
+class CliBinTsc extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    const force = argv.force;
+    await this._tsc(projectPath, force);
+  }
+  async _tsc(projectPath, force) {
+    const suiteNames = Object.keys(this.modulesMeta.suites).filter(suiteName => !this.modulesMeta.suites[suiteName].info.node_modules);
+    const modulesArray = this.modulesMeta.modulesArray.filter(item => !item.suite && !item.info.node_modules);
+    // count
+    const count = 1 + suiteNames.length + modulesArray.length;
+    // begin
+    let counter = 0;
+    const timeBegin = new Date();
+    // eslint-disable-next-line
+    console.log('===> build begin');
+    // args
+    const tscArgs = ['-b'];
+    if (force) {
+      tscArgs.push('--force');
+    }
+    // tsc: project
+    // eslint-disable-next-line
+    console.log(`===>  ${++counter}/${count} project`);
+    await this.helper.processHelper.tsc(tscArgs, {
+      cwd: projectPath
+    });
+    // suites
+    for (const key of suiteNames) {
+      const suite = this.modulesMeta.suites[key];
+      // eslint-disable-next-line
+      console.log(`===>  ${++counter}/${count} suite: ${suite.info.originalName}`);
+      await this.helper.processHelper.tsc(tscArgs, {
+        cwd: suite.root
+      });
+    }
+    // modules
+    for (const module of modulesArray) {
+      // eslint-disable-next-line
+      console.log(`===>  ${++counter}/${count} module: ${module.info.originalName}`);
+      await this.helper.processHelper.tsc(tscArgs, {
+        cwd: module.root
+      });
+    }
+    // end
+    const timeEnd = new Date();
+    // eslint-disable-next-line
+    console.log(`===> build end: ${(timeEnd.valueOf() - timeBegin.valueOf()) / 1000}s`);
+  }
+}
+
+const __ThisSetName__ = 'api';
+
+class CliCreateBean extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv.module;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    // scene name
+    const sceneName = argv.sceneName;
+    argv.sceneNameCapitalize = this.helper.firstCharToUpperCase(sceneName);
+    // scene meta
+    // onionScenesMeta
+    const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
+    const onionSceneMeta = onionScenesMeta[sceneName];
+    // bean name
+    const beanName = argv.beanName;
+    argv.beanNameCapitalize = this.helper.firstCharToUpperCase(beanName);
+    // moduleResourceName
+    argv.moduleResourceName = this.helper.combineModuleNameAndResource(argv.moduleInfo.relativeName, argv.beanName);
+    // directory
+    const beanDir = path.join(targetDir, onionSceneMeta.sceneIsolate ? `src/${sceneName}` : 'src/bean');
+    const beanFile = path.join(beanDir, onionSceneMeta.sceneIsolate ? `${beanName}.ts` : `${sceneName}.${beanName}.ts`);
+    if (fs.existsSync(beanFile)) {
+      throw new Error(`${sceneName} bean exists: ${beanName}`);
+    }
+    await this.helper.ensureDir(beanDir);
+    // snippets/boilerplate
+    const snippets = this._getBoilerplatesOrSnippets('snippets');
+    const boilerplates = this._getBoilerplatesOrSnippets('boilerplate', argv.boilerplate);
+    const snippetsName = snippets[`${sceneName}:${argv.beanName}`] || snippets[sceneName];
+    const boilerplateName = boilerplates[`${sceneName}:${argv.beanName}`] || boilerplates[sceneName];
+    // render
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: beanDir,
+      setName: __ThisSetName__,
+      snippetsPath: snippetsName,
+      boilerplatePath: boilerplateName
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+  _getBoilerplatesOrSnippets(type, custom) {
+    const type2 = custom ? `${type}${toUpperCaseFirstChar(custom)}` : type;
+    const result = {};
+    // scenes
+    const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
+    for (const sceneName in onionScenesMeta) {
+      const onionSceneMeta = onionScenesMeta[sceneName];
+      const scenePath = onionSceneMeta[type2];
+      if (scenePath) {
+        result[sceneName] = path.join(onionSceneMeta.module.root, scenePath);
+      }
+    }
+    // metas
+    const onionMetasMeta = getOnionMetasMeta(this.modulesMeta.modules);
+    for (const sceneName in onionMetasMeta) {
+      const onionMetaMeta = onionMetasMeta[sceneName];
+      const scenePath = onionMetaMeta[type2];
+      if (scenePath) {
+        result[`meta:${sceneName}`] = path.join(onionMetaMeta.module.root, scenePath);
+      }
+    }
+    return result;
+  }
+}
+
+class CliCreateModule extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // suite name/info
+    const suiteName = argv.suite;
+    if (suiteName) {
+      argv.suiteInfo = this.helper.parseSuiteInfo(suiteName);
+      // check if exists
+      argv._suite = this.helper.findSuite(suiteName);
+      if (!argv._suite) {
+        throw new Error(`suite does not exist: ${suiteName}`);
+      }
+    }
+    // nameMeta
+    const nameMeta = this.helper.parseNameMeta(argv.name);
+    const moduleDir = nameMeta.directory || 'module';
+    argv.name = nameMeta.short;
+    // module name/info
+    const moduleName = argv.name;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    argv.relativeNameCapitalize = this.helper.stringToCapitalize(argv.moduleInfo.relativeName, '-');
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!argv.force && _module) {
+      throw new Error(`module exists: ${moduleName}`);
+    }
+    // target dir
+    let targetDir;
+    if (suiteName) {
+      targetDir = path.join(argv._suite.root, 'modules', moduleName);
+    } else {
+      targetDir = path.join(argv.projectPath, `src/${moduleDir}`, moduleName);
+    }
+    if (!argv.force && fs.existsSync(targetDir)) {
+      throw new Error(`module exists: ${moduleName}`);
+    }
+    // render module snippets for suite
+    if (suiteName) {
+      await this.template.renderBoilerplateAndSnippets({
+        targetDir: argv._suite.root,
+        setName: __ThisSetName__,
+        snippetsPath: 'create/module/snippets',
+        boilerplatePath: null
+      });
+      await this.helper.removeGitkeep(path.join(argv._suite.root, 'modules'));
+    }
+    // render module boilerplate
+    targetDir = await this.helper.ensureDir(targetDir);
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'create/module/boilerplate'
+    });
+    // tools.deps
+    if (!argv.vscode) {
+      await this.helper.invokeCli([':tools:deps'], {
+        cwd: argv.projectPath
+      });
+    }
+    // pnpm install
+    if (!argv.vscode && !argv.ci) {
+      await this.helper.pnpmInstall();
+    }
+  }
+}
+
+class CliCreateProject extends BeanCliBase {
+  constructor(options) {
+    super(options);
+    this.httpClient = void 0;
+    this.httpClient = urllib;
+  }
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // project name
+    const projectName = argv.name;
+    // target dir
+    const targetDir = path.join(argv.projectPath, projectName);
+    if (!argv.force && fs.existsSync(targetDir)) {
+      throw new Error(`project exists: ${projectName}`);
+    }
+    fse.ensureDirSync(targetDir);
+    // vars
+    argv.SERVER_KEYS = `vona_${uuid.v4()}_${Date.now()}_${random(100, 10000)}`;
+    argv.SERVER_KEYS_PROD = `vona_${uuid.v4()}_${Date.now()}_${random(100, 10000)}`;
+    argv.DATABASE_CLIENT_MYSQL_USER = 'web_user';
+    argv.DATABASE_CLIENT_MYSQL_PASSWORD = randomize('*', 16, {
+      exclude: '\\\'"$'
+    });
+    argv.DATABASE_CLIENT_MYSQL_PASSWORD_ROOT = randomize('*', 16, {
+      exclude: '\\\'"$'
+    });
+    argv.DATABASE_CLIENT_PG_USER = 'postgres';
+    argv.DATABASE_CLIENT_PG_PASSWORD = randomize('*', 16, {
+      exclude: '\\\'"$'
+    });
+    argv.DATABASE_CLIENT_PG_PASSWORD_ROOT = randomize('*', 16, {
+      exclude: '\\\'"$'
+    });
+    // template
+    const template = argv.template;
+    // render project boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: `create/project/${template}/boilerplate`
+    });
+    // create docker-compose/data/pg
+    fse.ensureDirSync(path.join(targetDir, 'docker-compose/data/pg'));
+    // copy package.json
+    fse.copyFileSync(path.join(targetDir, 'package.original.json'), path.join(targetDir, 'package.json'));
+    // npm run init
+    await this.helper.spawnCmd({
+      cmd: 'npm',
+      args: ['run', 'init'],
+      options: {
+        cwd: targetDir
+      }
+    });
+    // done
+    await this.printUsage(targetDir);
+  }
+  async printUsage(targetDir) {
+    await this.console.log(`usage:
+      - cd ${targetDir}
+      - pnpm install
+      - npm run dev
+      - npm run test
+      - npm run build
+      - npm run start
+    `);
+  }
+  async downloadBoilerplate(packageName) {
+    const result = await this.getPackageInfo(packageName, false);
+    const tgzUrl = result.dist.tarball;
+    await this.console.log(`downloading ${tgzUrl}`);
+    const saveDir = path.join(os.tmpdir(), 'zova-project-boilerplate');
+    await rimraf(saveDir);
+    const response = await this.curl(tgzUrl, {
+      streaming: true,
+      followRedirect: true
+    });
+    await compressing.tgz.uncompress(response.res, saveDir);
+    await this.console.log(`extract to ${saveDir}`);
+    return path.join(saveDir, '/package');
+  }
+  async getPackageInfo(packageName, withFallback) {
+    await this.console.log(`fetching npm info of ${packageName}`);
+    try {
+      const registry = await this.helper.getRegistry();
+      const result = await this.curl(`${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;
+    } catch (err) {
+      if (withFallback) {
+        await this.console.log(`use fallback from ${packageName}`);
+        const require = createRequire(import.meta.url);
+        return require(`${packageName}/package.json`);
+      }
+      throw err;
+    }
+  }
+  async curl(url, options) {
+    options = options || {};
+    if (!options.timeout) {
+      options.timeout = 30000;
+    }
+    return await this.httpClient.request(url, options);
+  }
+}
+function random(start, end) {
+  return Math.floor(Math.random() * (end - start) + start);
+}
+
+class CliCreateSuite extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // nameMeta
+    const nameMeta = this.helper.parseNameMeta(argv.name);
+    const suiteDir = nameMeta.directory || 'suite';
+    argv.name = nameMeta.short;
+    // suite name/info
+    const suiteName = argv.name;
+    argv.suiteInfo = this.helper.parseSuiteInfo(suiteName);
+    // check if exists
+    const _suite = this.helper.findSuite(suiteName);
+    if (_suite) {
+      throw new Error(`suite exists: ${suiteName}`);
+    }
+    // target dir
+    let targetDir = path.join(argv.projectPath, `src/${suiteDir}`, suiteName);
+    if (fs.existsSync(targetDir)) {
+      throw new Error(`suite exists: ${suiteName}`);
+    }
+    targetDir = await this.helper.ensureDir(targetDir);
+    // templateDir
+    const templateDir = this.template.resolveTemplatePath(__ThisSetName__, 'create/suite');
+    // render
+    await this.template.renderDir(targetDir, templateDir);
+  }
+}
+
+class CliCreateTest extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv.module;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    // name
+    argv.nameCapitalize = this.helper.firstCharToUpperCase(argv.name);
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(argv.name, ['test']);
+    // directory
+    const testDir = path.join(targetDir, 'test');
+    const testFile = path.join(testDir, `${argv.name}.test.ts`);
+    if (fs.existsSync(testFile)) {
+      throw new Error(`test exists: ${testFile}`);
+    }
+    await this.helper.ensureDir(testDir);
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: testDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'create/test/boilerplate'
+    });
+  }
+}
+
+class CliDefaultList extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // set/group
+    const setWant = argv.set;
+    let groupWant = argv.group;
+    if (!setWant) groupWant = undefined;
+    // commandsAll
+    const commandsAll = (await getCommandsMeta()).all;
+    // setsShow
+    let setsShow;
+    if (setWant) {
+      if (!commandsAll[setWant]) throw new Error(`cli set not found: ${setWant}`);
+      setsShow = [setWant];
+    } else {
+      setsShow = Object.keys(commandsAll);
+    }
+    // loop
+    const total = setsShow.length;
+    for (let index = 0; index < total; index++) {
+      const setShow = setsShow[index];
+      // log
+      await this.console.log({
+        total,
+        progress: index,
+        text: setShow
+      });
+      // show
+      await this._setShow({
+        setShow,
+        groupWant,
+        commandsAll
+      });
+    }
+    // await this.console.log({ text: JSON.stringify(modulesWant) });
+  }
+  async _setShow({
+    setShow,
+    groupWant,
+    commandsAll
+  }) {
+    // _set
+    const _set = commandsAll[setShow];
+    // groupsShow
+    let groupsShow;
+    if (groupWant) {
+      if (!_set[groupWant]) throw new Error(`cli set group not found: ${setShow}:${groupWant}`);
+      groupsShow = [groupWant];
+    } else {
+      groupsShow = Object.keys(_set);
+    }
+    // table
+    const table = this.helper.newTable({
+      head: ['Command', 'Version', 'Description'],
+      colWidths: [30, 10, 40]
+    });
+    // group
+    const groupCount = groupsShow.length;
+    for (let index = 0; index < groupCount; index++) {
+      const groupShow = groupsShow[index];
+      const _group = _set[groupShow];
+      for (const commandName in _group) {
+        const _command = _group[commandName].command;
+        const cliFullName = this._combineCliFullName({
+          setShow,
+          groupShow,
+          commandName
+        });
+        const version = _command.info.version;
+        const description = _command.info.description || _command.info.title;
+        table.push([cliFullName, version, description]);
+      }
+      if (index < groupCount - 1) {
+        table.push([]);
+      }
+    }
+    // log
+    await this.console.log({
+      text: table.toString()
+    });
+  }
+  _combineCliFullName({
+    setShow,
+    groupShow,
+    commandName
+  }) {
+    const parts = [];
+    if (setShow === 'api') {
+      parts.push('');
+    } else {
+      parts.push(setShow);
+    }
+    if (groupShow === 'default') {
+      parts.push('');
+    } else {
+      parts.push(groupShow);
+    }
+    parts.push(commandName);
+    return parts.join(':');
+  }
+}
+
+class CliInitAppMonkey extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // target dir
+    const targetDir = path.join(argv.projectPath, 'src/backend/config');
+    const monkeyFile = path.join(targetDir, 'monkey.ts');
+    if (fse.existsSync(monkeyFile)) {
+      throw new Error('app monkey exists');
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/appMonkey/boilerplate'
+    });
+  }
+}
+
+class CliInitAsset extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv.module;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    // scene
+    const scene = argv.scene;
+    // directory
+    const assetDir = path.join(targetDir, 'assets', scene);
+    if (fse.existsSync(assetDir)) {
+      throw new Error(`asset exists: ${moduleName}/assets/${scene}`);
+    }
+    await this.helper.ensureDir(assetDir);
+  }
+}
+
+class CliInitConfig extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const configFile = path.join(targetDir, 'src/config/config.ts');
+    if (fse.existsSync(configFile)) {
+      throw new Error(`config exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/config/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitConstant extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const constantFile = path.join(targetDir, 'src/config/constants.ts');
+    if (fse.existsSync(constantFile)) {
+      throw new Error(`constant exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/constant/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitError extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const errorFile = path.join(targetDir, 'src/config/errors.ts');
+    if (fse.existsSync(errorFile)) {
+      throw new Error(`error exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/error/boilerplate'
+    });
+    // special for locale
+    const localeFile = path.join(targetDir, 'src/config/locale');
+    if (!fse.existsSync(localeFile)) {
+      // render boilerplate
+      await this.template.renderBoilerplateAndSnippets({
+        targetDir: path.join(targetDir, 'src'),
+        setName: __ThisSetName__,
+        snippetsPath: null,
+        boilerplatePath: 'init/locale/boilerplate'
+      });
+    }
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitLib extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const mainFile = path.join(targetDir, 'src/lib/index.ts');
+    if (fse.existsSync(mainFile)) {
+      throw new Error(`lib exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/lib/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitLocale extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const localeFile = path.join(targetDir, 'src/config/locale');
+    if (fse.existsSync(localeFile)) {
+      throw new Error(`locale exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/locale/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitMain extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const mainFile = path.join(targetDir, 'src/main.ts');
+    if (fse.existsSync(mainFile)) {
+      throw new Error(`main exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/main/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliInitMonkey extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const monkeyFile = path.join(targetDir, 'src/monkey.ts');
+    if (fse.existsSync(monkeyFile)) {
+      throw new Error(`monkey exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/monkey/boilerplate'
+    });
+    // set vonaModule.capabilities.monkey: true
+    await this._setPackageInfo(targetDir);
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+  async _setPackageInfo(modulePath) {
+    const pkgFile = path.join(modulePath, 'package.json');
+    const pkg = await this.helper.loadJSONFile(pkgFile);
+    if (!pkg.vonaModule) pkg.vonaModule = {};
+    if (!pkg.vonaModule.capabilities) pkg.vonaModule.capabilities = {};
+    let changed;
+    // monkey
+    if (!pkg.vonaModule.capabilities.monkey) {
+      pkg.vonaModule.capabilities.monkey = true;
+      changed = true;
+    }
+    // // dependencies
+    // if (!pkg.vonaModule.dependencies) pkg.vonaModule.dependencies = {};
+    // if (!pkg.vonaModule.dependencies['a-vona']) {
+    //   pkg.vonaModule.dependencies['a-vona'] = '5.0.0';
+    //   changed = true;
+    // }
+    // save
+    if (changed) {
+      await this.helper.saveJSONFile(pkgFile, pkg);
+    }
+  }
+}
+
+class CliInitStatic extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const staticDir = path.join(targetDir, 'assets/static');
+    if (fse.existsSync(staticDir)) {
+      throw new Error(`static exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/static/boilerplate'
+    });
+    // // tools.metadata
+    // if (!argv.nometadata) {
+    //   await this.helper.invokeCli([':tools:metadata', moduleName], { cwd: argv.projectPath });
+    // }
+  }
+}
+
+class CliInitTypes extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv._[0];
+    if (!moduleName) return;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    const mainFile = path.join(targetDir, 'src/types/index.ts');
+    if (fse.existsSync(mainFile)) {
+      throw new Error(`types exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/types/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliToolsCrud extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat
+    argv.noformat = true;
+    // module name/info
+    const moduleName = argv.module;
+    argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+    // check if exists
+    const _module = this.helper.findModule(moduleName);
+    if (!_module) {
+      throw new Error(`module does not exist: ${moduleName}`);
+    }
+    // target dir
+    const targetDir = await this.helper.ensureDir(_module.root);
+    // resourceName
+    const resourceName = argv.resourceName;
+    argv.resourceNameCapitalize = this.helper.firstCharToUpperCase(resourceName);
+    // moduleResourceName
+    argv.moduleResourceName = this.helper.combineModuleNameAndResource(argv.moduleInfo.relativeName, argv.resourceName);
+    argv.moduleActionPathRaw = combineApiPathControllerAndActionRaw(moduleName, resourceName, '', true);
+    // controller
+    const controllerFile = path.join(targetDir, 'src/controller', `${resourceName}.ts`);
+    if (fs.existsSync(controllerFile)) {
+      throw new Error(`resource exists: ${resourceName}`);
+    }
+    // render
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'tools/crud/snippets',
+      boilerplatePath: 'tools/crud/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliToolsDeps extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // generate
+    await this._generate(projectPath);
+  }
+  async _generate(projectPath) {
+    // generate package.json
+    await this.common._generatePackageJson(projectPath);
+    // generate type modules file
+    await this.common._generateTypeModulesFile(projectPath);
+    // generate type project file
+    await this._generateTypeProjectFile(projectPath);
+  }
+  _getProjectMode(projectPath) {
+    const vonaPath = this._getVonaPath(projectPath);
+    return vonaPath.includes('packages-vona') ? 'source' : 'project';
+  }
+  _getVonaPath(projectPath) {
+    let vonaPath = path.join(projectPath, 'packages-vona/vona');
+    if (fse.existsSync(vonaPath)) return vonaPath;
+    vonaPath = path.join(projectPath, 'node_modules/vona');
+    if (fse.existsSync(vonaPath)) return vonaPath;
+  }
+  async _generateTypeProjectFile(projectPath) {
+    const projectMode = this._getProjectMode(projectPath);
+    const fileTemplate = resolveTemplatePath(`config/_tsconfig_${projectMode}.json`);
+    const fileConfig = path.join(projectPath, 'tsconfig.json');
+    if (!fse.existsSync(fileConfig)) {
+      await fse.copyFile(fileTemplate, fileConfig);
+    }
+  }
+}
+
+function checkIgnoreOfParts(parts) {
+  const indexLast = parts.length - 1;
+  if (parts[indexLast].endsWith('_')) {
+    parts[indexLast] = parts[indexLast].substring(0, parts[indexLast].length - 1);
+    return true;
+  }
+  return false;
+}
+function getScopeModuleName(moduleName) {
+  return `ScopeModule${stringToCapitalize(moduleName, '-')}`;
+}
+async function globBeanFiles(sceneName, sceneMeta, moduleName, modulePath) {
+  const result = [];
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  const pattern = sceneMeta.sceneIsolate ? `src/${sceneName}/*.ts` : `src/bean/${sceneName}.*.ts`;
+  const files = await globby(pattern, {
+    cwd: modulePath
+  });
+  if (files.length === 0) return result;
+  files.sort();
+  for (const file of files) {
+    const filePath = path.join(modulePath, file);
+    const fileName = path.basename(file);
+    if (fileName.startsWith('_')) continue;
+    const parts = fileName.split('.').slice(0, -1);
+    if (sceneMeta.sceneIsolate && parts.length !== 1) continue;
+    if (!sceneMeta.sceneIsolate && parts.length < 2) continue;
+    const isIgnore = checkIgnoreOfParts(parts);
+    const fileNameJS = fileName; // fileName.replace('.ts', '.js');
+    const fileNameJSRelative = sceneMeta.sceneIsolate ? `../${sceneName}/${fileNameJS}` : `../bean/${fileNameJS}`;
+    const className = (sceneMeta.sceneIsolate ? sceneNameCapitalize : '') + parts.map(item => toUpperCaseFirstChar(item)).join('');
+    const beanName = parts[parts.length - 1];
+    const beanNameFull = `${moduleName}:${beanName}`;
+    const beanNameCapitalize = toUpperCaseFirstChar(beanName);
+    const fileContent = isIgnore ? '' : fse.readFileSync(filePath).toString();
+    const isVirtual = fileContent.includes('@Virtual()');
+    result.push({
+      sceneName,
+      sceneNameCapitalize,
+      file: filePath,
+      fileContent,
+      fileName,
+      fileNameJS,
+      fileNameJSRelative,
+      className,
+      beanName,
+      beanNameFull,
+      beanNameCapitalize,
+      isIgnore,
+      isVirtual
+    });
+  }
+  return result;
+}
+function extractBeanInfo(sceneName, fileContent, sceneMeta) {
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  // optionsCustomInterface
+  let optionsCustomInterface;
+  let optionsCustomInterfaceFrom;
+  let reg = new RegExp(`@${sceneNameCapitalize}<(I${sceneNameCapitalize}Options[^>]*)>`);
+  let matches = fileContent.match(reg);
+  if (matches) {
+    optionsCustomInterface = matches[1];
+    // optionsCustomInterfaceFrom
+    reg = new RegExp(`import type {[\\s\\S]*?${optionsCustomInterface}[, ][\\s\\S]*?} from '([^']*)'`);
+    matches = fileContent.match(reg);
+    if (matches) {
+      optionsCustomInterfaceFrom = matches[1];
+    }
+  }
+  // isGlobal
+  const isGlobal = sceneMeta.hasLocal ? fileContent.match(/@.*?\(\{([\s\S]*?)global: true([\s\S]*?)\}([\s\S]*?)\)\s*export class/) : true;
+  return {
+    optionsCustomInterface,
+    optionsCustomInterfaceFrom,
+    isGlobal
+  };
+}
+
+async function generateBeanGenerals(sceneName, sceneMeta, moduleName, modulePath) {
+  const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+  if (globFiles.length === 0) return '';
+  //
+  const contentImports = [];
+  const contentRecords = [];
+  for (const globFile of globFiles) {
+    const {
+      fileNameJSRelative,
+      className,
+      beanName,
+      isIgnore
+    } = globFile;
+    const beanFullName = `${moduleName}.${sceneName}.${beanName}`;
+    if (isIgnore) continue;
+    if (!sceneMeta.scopeResource) {
+      contentImports.push(`import type { ${className} } from '${fileNameJSRelative}';`);
+    }
+    contentRecords.push(`'${beanFullName}': ${className};`);
+  }
+  if (contentRecords.length === 0) return '';
+  // combine
+  const content = `/** ${sceneName}: begin */
+${contentImports.join('\n')}
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    ${contentRecords.join('\n')}
+  }
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+async function generateConfig(modulePath) {
+  const configFile = path.join(modulePath, 'src/config/config.ts');
+  if (!fse.existsSync(configFile)) return '';
+  // combine
+  const content = `/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+`;
+  return content;
+}
+async function generateConstant(modulePath) {
+  const constantFile = path.join(modulePath, 'src/config/constants.ts');
+  if (!fse.existsSync(constantFile)) return '';
+  // combine
+  const content = `/** constant: begin */
+export * from '../config/constants.ts';
+import { constants } from '../config/constants.ts';
+/** constant: end */
+`;
+  return content;
+}
+async function generateLocale(modulePath) {
+  const files = await globby('src/config/locale/*.ts', {
+    cwd: modulePath
+  });
+  if (files.length === 0) return '';
+  files.sort();
+  const contentImports = [];
+  const contentLocales = [];
+  for (const file of files) {
+    const localeName = path.basename(file, '.ts');
+    const className = `locale_${localeName.replace('-', '_')}`;
+    contentImports.push(`import ${className} from '../config/locale/${localeName}.ts';`);
+    contentLocales.push(`'${localeName}': ${className},`);
+  }
+  // combine
+  const content = `/** locale: begin */
+${contentImports.join('\n')}
+export const locales = {
+  ${contentLocales.join('\n')}
+};
+/** locale: end */
+`;
+  return content;
+}
+async function generateError(modulePath) {
+  const errorFile = path.join(modulePath, 'src/config/errors.ts');
+  if (!fse.existsSync(errorFile)) return '';
+  // combine
+  const content = `/** error: begin */
+export * from '../config/errors.ts';
+import type { errors } from '../config/errors.ts';
+/** error: end */
+`;
+  return content;
+}
+
+async function generateMetadataCustom(cli, sceneName, sceneMeta, moduleName, modulePath) {
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+  if (globFiles.length === 0) return '';
+  // custom
+  const jsFile = path.join(sceneMeta.module.root, sceneMeta.metadataCustom);
+  return await cli.helper.importDynamic(jsFile, async instance => {
+    const options = {
+      cli,
+      sceneName,
+      sceneNameCapitalize,
+      sceneMeta,
+      moduleName,
+      modulePath,
+      globFiles
+    };
+    return await instance.default(options);
+  });
+}
+
+async function generateMonkey(modulePath) {
+  const monkeyFile = path.join(modulePath, 'src/monkey.ts');
+  if (!fse.existsSync(monkeyFile)) return '';
+  // combine
+  const content = `/** monkey: begin */
+export * from '../monkey.ts';
+/** monkey: end */
+`;
+  return content;
+}
+async function generateMain(modulePath) {
+  const monkeyFile = path.join(modulePath, 'src/main.ts');
+  if (!fse.existsSync(monkeyFile)) return '';
+  // combine
+  const content = `/** main: begin */
+export * from '../main.ts';
+/** main: end */
+`;
+  return content;
+}
+
+async function generateOnions(sceneName, sceneMeta, moduleName, modulePath) {
+  const scopeModuleName = getScopeModuleName(moduleName);
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+  if (globFiles.length === 0) return '';
+  //
+  const contentExports = [];
+  const contentScopes = [];
+  const contentImports = [];
+  const contentRecordsGlobal = [];
+  const contentRecordsLocal = [];
+  let needImportOptionsGlobalInterface;
+  for (const globFile of globFiles) {
+    const {
+      fileContent,
+      fileNameJSRelative,
+      sceneName,
+      className,
+      beanNameFull,
+      isIgnore,
+      isVirtual
+    } = globFile;
+    const isBeanGlobal = fileNameJSRelative.includes('../bean/bean.');
+    contentExports.push(`export * from '${fileNameJSRelative}';`);
+    if (isIgnore) continue; // get scope() also can be ignored
+    // options
+    let onionOptions;
+    if (!sceneMeta.optionsNone) {
+      // fileInfo
+      const fileInfo = extractBeanInfo(sceneName, fileContent, sceneMeta);
+      // import options
+      if (fileInfo.optionsCustomInterface) {
+        contentImports.push(`import type { ${fileInfo.optionsCustomInterface} } from '${fileInfo.optionsCustomInterfaceFrom || fileNameJSRelative}';`);
+      }
+      // valueOptionsCustomInterface
+      let valueOptionsCustomInterface = fileInfo.optionsCustomInterface;
+      if (valueOptionsCustomInterface && sceneMeta.optionsCustomInterfaceTemplate) {
+        valueOptionsCustomInterface = replaceTemplate(sceneMeta.optionsCustomInterfaceTemplate, {
+          optionsCustomInterface: valueOptionsCustomInterface
+        });
+      }
+      // record
+      if (fileInfo.isGlobal) {
+        if (valueOptionsCustomInterface) {
+          onionOptions = valueOptionsCustomInterface;
+          contentRecordsGlobal.push(`'${beanNameFull}': ${valueOptionsCustomInterface};`);
+        } else {
+          if (sceneMeta.optionsGlobalInterfaceName) {
+            onionOptions = sceneMeta.optionsGlobalInterfaceName;
+            contentRecordsGlobal.push(`'${beanNameFull}': ${sceneMeta.optionsGlobalInterfaceName};`);
+            needImportOptionsGlobalInterface = true;
+          } else {
+            contentRecordsGlobal.push(`'${beanNameFull}': never;`);
+          }
+        }
+      } else {
+        if (valueOptionsCustomInterface) {
+          onionOptions = valueOptionsCustomInterface;
+          contentRecordsLocal.push(`'${beanNameFull}': ${valueOptionsCustomInterface};`);
+        } else {
+          contentRecordsLocal.push(`'${beanNameFull}': never;`);
+        }
+      }
+    }
+    // get scope() also can be ignored
+    if (!['entity', 'dto'].includes(sceneName) && !isVirtual) {
+      contentScopes.push(`
+        export interface ${className} {
+          /** @internal */
+          get scope(): ${scopeModuleName};
+        }`);
+      if (!isBeanGlobal) {
+        const contentOnionOptions = onionOptions ? `get $onionOptions(): ${onionOptions};` : '';
+        contentScopes.push(`
+          export interface ${className} {
+            get $beanFullName(): '${beanFullNameFromOnionName(beanNameFull, sceneName)}';
+            get $onionName(): '${beanNameFull}';
+            ${contentOnionOptions}
+          }`);
+      }
+    }
+  }
+  // middlewareGlobal
+  const exportRecordsMiddlewareGlobal = `
+    export interface I${sceneNameCapitalize}Record${sceneMeta.hasLocal ? 'Global' : ''} {
+      ${contentRecordsGlobal.join('\n')}
+    }
+`;
+  // middlewareLocal
+  const exportRecordsMiddlewareLocal = `
+export interface I${sceneNameCapitalize}RecordLocal {
+  ${contentRecordsLocal.join('\n')}
+}
+`;
+  // combine
+  const content = `/** ${sceneName}: begin */
+${contentExports.join('\n')}
+${contentImports.join('\n')}
+${needImportOptionsGlobalInterface ? `import { type ${sceneMeta.optionsGlobalInterfaceName} } from '${sceneMeta.optionsGlobalInterfaceFrom || 'vona'}';` : `import '${sceneMeta.optionsGlobalInterfaceFrom || 'vona'}';`}
+declare module '${sceneMeta.optionsGlobalInterfaceFrom || 'vona'}' {
+  ${contentRecordsGlobal.length > 0 ? exportRecordsMiddlewareGlobal : ''}
+  ${contentRecordsLocal.length > 0 ? exportRecordsMiddlewareLocal : ''}
+}
+declare module 'vona-module-${moduleName}' {
+  ${contentScopes.join('\n')} 
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+async function generateScope(moduleName, relativeNameCapitalize, scopeResources, options) {
+  // scopeVariable
+  const parts = moduleName.split('-');
+  const scopeVariable = parts[0] === 'a' ? parts[1] : relativeNameToCapitalize(moduleName, false);
+  const contentImports = [];
+  const contentRecords = [];
+  // basic
+  contentImports.push('BeanScopeBase');
+  // util
+  contentImports.push('type BeanScopeUtil');
+  contentRecords.push('util: BeanScopeUtil;');
+  //
+  if (options.config) {
+    contentImports.push('type TypeModuleConfig');
+    contentRecords.push('config: TypeModuleConfig<typeof config>;');
+  }
+  if (options.errors) {
+    contentImports.push('type TypeModuleErrors');
+    contentRecords.push('error: TypeModuleErrors<typeof errors>;');
+  }
+  if (options.locales) {
+    contentImports.push('type TypeModuleLocales');
+    contentImports.push('type TypeLocaleBase');
+    contentRecords.push('locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;');
+  }
+  if (options.constants) {
+    contentImports.push('type TypeModuleConstants');
+    contentRecords.push('constant: TypeModuleConstants<typeof constants>;');
+  }
+  // loop
+  for (const sceneName in scopeResources) {
+    contentRecords.push(`${sceneName}: ${scopeResources[sceneName]};`);
+  }
+  // combine
+  const content = `/** scope: begin */
+import { ${contentImports.join(', ')} } from 'vona';
+import { Scope } from '${moduleName === 'a-bean' ? '../lib/scope.ts' : 'vona-module-a-bean'}';
+
+@Scope()
+export class ScopeModule${relativeNameCapitalize} extends BeanScopeBase {}
+
+export interface ScopeModule${relativeNameCapitalize} {
+  ${contentRecords.join('\n')}
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    '${moduleName}': ScopeModule${relativeNameCapitalize};
+  }
+
+  export interface IBeanScopeContainer {
+    ${scopeVariable}: ScopeModule${relativeNameCapitalize};
+  }
+  
+  ${options.config ? `export interface IBeanScopeConfig {
+    '${moduleName}': ReturnType<typeof config>;
+  }` : ''}
+
+  ${options.locales ? `export interface IBeanScopeLocale {
+    '${moduleName}': (typeof locales)[TypeLocaleBase];
+  }` : ''}
+
+  ${options.errors ? `export interface IBeanScopeErrors {
+    '${moduleName}': typeof errors;
+  }` : ''}
+}
+${options.locales ? `\nexport function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): \`${moduleName}::\${K}\` {
+  return \`${moduleName}::\${key}\`;
+}` : ''}
+/** scope: end */
+`;
+  return content;
+}
+
+async function generateScopeResources(sceneName, sceneMeta, moduleName, modulePath) {
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+  if (globFiles.length === 0) return '';
+  //
+  const contentImports = [];
+  const contentRecords = [];
+  for (const globFile of globFiles) {
+    const {
+      fileNameJSRelative,
+      className,
+      beanName,
+      isIgnore
+    } = globFile;
+    if (isIgnore) continue;
+    contentImports.push(`import type { ${className} } from '${fileNameJSRelative}';`);
+    let typeClassName = className;
+    if (sceneMeta.scopeResourceTypeTemplate) {
+      typeClassName = replaceTemplate$1(sceneMeta.scopeResourceTypeTemplate, {
+        className
+      });
+    }
+    contentRecords.push(`'${beanName}': ${typeClassName};`);
+  }
+  if (contentImports.length === 0) return '';
+  // combine
+  const content = `/** ${sceneName}: begin */
+${contentImports.join('\n')}
+export interface IModule${sceneNameCapitalize} {
+  ${contentRecords.join('\n')}
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+async function generateScopeResourcesMeta(metaName, _metaMeta, _sceneName, _sceneMeta, _moduleName, modulePath) {
+  const files = await globby(`src/bean/meta.${metaName}.ts`, {
+    cwd: modulePath
+  });
+  if (files.length === 0) return '';
+  // combine
+  const content = `/** meta ${metaName}: begin */
+import type { Meta${toUpperCaseFirstChar(metaName)} } from '../bean/meta.${metaName}.ts';
+/** meta ${metaName}: end */
+`;
+  return content;
+}
+
+class CliToolsMetadata extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // noformat: src/index.ts need format
+    // argv.noformat = true;
+    // moduleNames
+    let moduleNames = argv._;
+    const force = argv.force ?? moduleNames.length > 0;
+    if (moduleNames.length === 0) {
+      moduleNames = this.modulesMeta.modulesArray.filter(item => !item.info.node_modules).map(item => item.info.relativeName);
+    }
+    const total = moduleNames.length;
+    for (let index = 0; index < total; index++) {
+      const moduleName = moduleNames[index];
+      // log
+      await this.console.log({
+        total,
+        progress: index,
+        text: moduleName
+      });
+      // generate res
+      await this._generateMetadata(moduleName, force);
+    }
+  }
+  async _generateMetadata(moduleName, force) {
+    const module = this.helper.findModule(moduleName);
+    if (!module) throw new Error(`module not found: ${moduleName}`);
+    const modulePath = module.root;
+    const metaDir = path.join(modulePath, 'src/.metadata');
+    const metaIndexFile = path.join(metaDir, 'index.ts');
+    if (fse.existsSync(metaIndexFile) && !force) {
+      // do nothing
+      return;
+    }
+    await this.helper.ensureDir(metaDir);
+    // relativeNameCapitalize
+    const relativeNameCapitalize = this.helper.stringToCapitalize(moduleName, '-');
+    // onionScenesMeta
+    const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
+    // content
+    let content = '';
+    // onions
+    const scopeResources = {};
+    for (const sceneName in onionScenesMeta) {
+      const sceneMeta = onionScenesMeta[sceneName];
+      // general
+      content += await generateOnions(sceneName, sceneMeta, moduleName, modulePath);
+      // scope resources
+      if (sceneMeta.scopeResource) {
+        const contentScopeResource = await generateScopeResources(sceneName, sceneMeta, moduleName, modulePath);
+        if (contentScopeResource) {
+          content += contentScopeResource;
+          scopeResources[sceneName] = `IModule${toUpperCaseFirstChar(sceneName)}`;
+        }
+      }
+      // bean generals
+      if (sceneMeta.beanGeneral) {
+        content += await generateBeanGenerals(sceneName, sceneMeta, moduleName, modulePath);
+      }
+      // metas
+      if (sceneName === 'meta') {
+        const onionMetasMeta = getOnionMetasMeta(this.modulesMeta.modules);
+        for (const metaName in onionMetasMeta) {
+          const metaMeta = onionMetasMeta[metaName];
+          if (metaMeta.scopeResource) {
+            const contentScopeResourceMeta = await generateScopeResourcesMeta(metaName, metaMeta, sceneName, sceneMeta, moduleName, modulePath);
+            if (contentScopeResourceMeta) {
+              content += contentScopeResourceMeta;
+              scopeResources[metaName] = `Meta${toUpperCaseFirstChar(metaName)}`;
+            }
+          }
+        }
+      }
+      // metadata custom
+      if (sceneMeta.metadataCustom) {
+        content += await generateMetadataCustom(this, sceneName, sceneMeta, moduleName, modulePath);
+      }
+    }
+    // config
+    const contentConfig = await generateConfig(modulePath);
+    content += contentConfig;
+    // constant
+    const contentConstants = await generateConstant(modulePath);
+    content += contentConstants;
+    // locale
+    const contentLocales = await generateLocale(modulePath);
+    content += contentLocales;
+    // error
+    const contentErrors = await generateError(modulePath);
+    content += contentErrors;
+    // monkey
+    content += await generateMonkey(modulePath);
+    // main
+    content += await generateMain(modulePath);
+    // scope
+    content += await generateScope(moduleName, relativeNameCapitalize, scopeResources, {
+      config: contentConfig,
+      errors: contentErrors,
+      locales: contentLocales,
+      constants: contentConstants
+    });
+    // patch
+    content = this._generatePatch(content);
+    // empty
+    if (!content.trim()) {
+      content = 'export {};';
+    } else {
+      content = `/* eslint-disable */\n${content}`;
+    }
+    // save
+    await fse.writeFile(metaIndexFile, content);
+    // await this.helper.formatFile({ fileName: metaIndexFile, logPrefix: 'format: ' });
+    // generate this
+    await this._generateThis(moduleName, relativeNameCapitalize, modulePath);
+    // index
+    await this._generateIndex(modulePath);
+    // package
+    await this._generatePackage(modulePath);
+  }
+  _generatePatch(content) {
+    if (!content) return content;
+    content = this._generatePatch_resources(content, 'table-identity', ['TableIdentity'], true);
+    content = this._generatePatch_resources(content, 'vona-module-a-openapi', ['TypeEntityOptionsFields', 'TypeControllerOptionsActions'], true);
+    content = this._generatePatch_resources(content, 'vona-module-a-orm', ['TypeEntityMeta', 'TypeModelsClassLikeGeneral', 'TypeSymbolKeyFieldsMore', 'IModelRelationHasOne', 'IModelRelationBelongsTo', 'IModelRelationHasMany', 'IModelRelationBelongsToMany'], true);
+    content = this._generatePatch_resources(content, 'vona', ['PowerPartial'], true);
+    return content;
+  }
+  _generatePatch_resources(content, packageName, resources, type) {
+    const items = resources.filter(item => {
+      const regexp = new RegExp(`${item}[\\[\\]<,;?:\\s]`);
+      return !!regexp.exec(content);
+    });
+    if (items.length === 0) return content;
+    const importContent = `import ${type ? 'type ' : ''}{ ${items.join(',')} } from '${packageName}';`;
+    return `${importContent}\n${content}`;
+  }
+  async _generateThis(moduleName, relativeNameCapitalize, modulePath) {
+    const thisDest = path.join(modulePath, 'src/.metadata/this.ts');
+    if (fse.existsSync(thisDest)) return;
+    const content = `export const __ThisModule__ = '${moduleName}';
+export { ScopeModule${relativeNameCapitalize} as ScopeModule } from './index.ts';
+`;
+    // save
+    await fse.writeFile(thisDest, content);
+  }
+  async _generateIndex(modulePath) {
+    let jsContent = '';
+    const jsFile = path.join(modulePath, 'src/index.ts');
+    if (fse.existsSync(jsFile)) {
+      jsContent = (await fse.readFile(jsFile)).toString();
+    }
+    // jsTypes
+    const jsTypes = "export * from './types/index.ts';";
+    const jsTypesFile = path.join(modulePath, 'src/types/index.ts');
+    if (fse.existsSync(jsTypesFile) && !jsContent.includes(jsTypes)) {
+      jsContent = `${jsTypes}\n${jsContent}`;
+    }
+    // jsLib
+    const jsLib = "export * from './lib/index.ts';";
+    const jsLibFile = path.join(modulePath, 'src/lib/index.ts');
+    if (fse.existsSync(jsLibFile) && !jsContent.includes(jsLib)) {
+      jsContent = `${jsLib}\n${jsContent}`;
+    }
+    // jsMetadata
+    const jsMetadata = "export * from './.metadata/index.ts';";
+    const jsMetadataFile = path.join(modulePath, 'src/.metadata/index.ts');
+    if (fse.existsSync(jsMetadataFile) && !jsContent.includes(jsMetadata)) {
+      jsContent = `${jsMetadata}\n${jsContent}`;
+    }
+    // trim empty
+    jsContent = jsContent.replace('export {};\n', '');
+    // write
+    await fse.writeFile(jsFile, jsContent);
+    await this.helper.formatFile({
+      fileName: jsFile,
+      logPrefix: 'format: '
+    });
+  }
+  async _generatePackage(modulePath) {
+    let pkgFile;
+    let pkg;
+    let changed;
+    async function _loadPkg() {
+      if (!pkg) {
+        pkgFile = path.join(modulePath, 'package.json');
+        pkg = await loadJSONFile(pkgFile);
+      }
+      return pkg;
+    }
+    // cli
+    const cli = path.join(modulePath, 'cli');
+    if (fse.existsSync(cli)) {
+      pkg = await _loadPkg();
+      const index = pkg.files.indexOf('cli');
+      if (index === -1) {
+        changed = true;
+        pkg.files.push('cli');
+      }
+    }
+    // save
+    if (changed) {
+      await saveJSONFile(pkgFile, pkg);
+      await this.helper.formatFile({
+        fileName: pkgFile
+      });
+    }
+  }
+}
+
+const beans = {
+  'default.list': CliDefaultList,
+  'bin.build': CliBinBuild,
+  'bin.buildModule': CliBinBuildModule,
+  'bin.buildGeneral': CliBinBuildGeneral,
+  'bin.dbReset': CliBinDbReset,
+  'bin.play': CliBinPlay,
+  'bin.dev': CliBinDev,
+  'bin.test': CliBinTest,
+  'bin.tsc': CliBinTsc,
+  'create.suite': CliCreateSuite,
+  'create.bean': CliCreateBean,
+  'create.module': CliCreateModule,
+  'create.project': CliCreateProject,
+  'create.test': CliCreateTest,
+  'init.config': CliInitConfig,
+  'init.constant': CliInitConstant,
+  'init.error': CliInitError,
+  'init.locale': CliInitLocale,
+  'init.monkey': CliInitMonkey,
+  'init.main': CliInitMain,
+  'init.static': CliInitStatic,
+  'init.asset': CliInitAsset,
+  'init.lib': CliInitLib,
+  'init.types': CliInitTypes,
+  'init.appMonkey': CliInitAppMonkey,
+  'tools.deps': CliToolsDeps,
+  'tools.metadata': CliToolsMetadata,
+  'tools.crud': CliToolsCrud
+};
+
+var binBuild = {
+  bean: 'bin.build',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Bin',
+    usage: 'vona :bin:build [--workers=] [--flavor=] [--sourcemap=]'
+  },
+  options: {
+    workers: {
+      description: 'workers',
+      type: 'number'
+    },
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    }
+  }
+};
+
+var binBuildGeneral = {
+  bean: 'bin.buildGeneral',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Bin',
+    usage: 'vona :bin:buildGeneral [--minify] [--sourcemap]'
+  },
+  options: {
+    minify: {
+      description: 'minify',
+      type: 'boolean'
+    },
+    sourcemap: {
+      description: 'sourcemap',
+      type: 'boolean'
+    }
+  }
+};
+
+var binBuildModule = {
+  bean: 'bin.buildModule',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Bin',
+    usage: 'vona :bin:buildModule [--minify] [--sourcemap]'
+  },
+  options: {
+    minify: {
+      description: 'minify',
+      type: 'boolean'
+    },
+    sourcemap: {
+      description: 'sourcemap',
+      type: 'boolean'
+    }
+  }
+};
+
+var binDbReset = {
+  bean: 'bin.dbReset',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Bin: DbReset',
+    usage: 'vona :bin:dbReset [--flavor=]'
+  },
+  options: {
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    }
+  }
+};
+
+var binDev = {
+  bean: 'bin.dev',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Bin: Dev',
+    usage: 'vona :bin:dev [--workers=] [--flavor=]'
+  },
+  options: {
+    workers: {
+      description: 'workers',
+      type: 'number'
+    },
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    }
+  }
+};
+
+var binPlay = {
+  bean: 'bin.play',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Bin: Play',
+    usage: 'vona :bin:play [index.ts] [--flavor=] [--retainRuntime=] [--attach]'
+  },
+  options: {
+    mode: {
+      description: 'mode',
+      type: 'string'
+    },
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    },
+    retainRuntime: {
+      description: 'retainRuntime',
+      type: 'boolean'
+    },
+    attach: {
+      alias: 'a',
+      description: 'attach',
+      type: 'boolean'
+    }
+  }
+};
+
+var binTest = {
+  bean: 'bin.test',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Bin: Test',
+    usage: 'vona :bin:test [--coverage=] [--flavor=]'
+  },
+  options: {
+    coverage: {
+      description: 'coverage',
+      type: 'boolean'
+    },
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    }
+  }
+};
+
+var binTsc = {
+  bean: 'bin.tsc',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Bin: Tsc',
+    usage: 'vona :bin:tsc [--force]'
+  },
+  options: {
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  }
+};
+
+var createBean = {
+  bean: 'create.bean',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Bean',
+    usage: 'vona :create:bean sceneName beanName [--module=] [--boilerplate=]'
+  },
+  options: {
+    module: {
+      alias: 'm',
+      description: 'module name',
+      type: 'string'
+    },
+    boilerplate: {
+      description: 'boilerplate',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        sceneName: {
+          type: 'input',
+          message: 'sceneName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        beanName: {
+          type: 'input',
+          message: 'beanName',
+          initial: {
+            expression: 'context.argv._[1]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var createModule = {
+  bean: 'create.module',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Module',
+    usage: 'vona :create:module moduleName [--suite=] [--force]'
+  },
+  options: {
+    suite: {
+      description: 'suite name',
+      type: 'string'
+    },
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        name: {
+          type: 'input',
+          message: 'module name',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        suite: {
+          type: 'input',
+          message: 'suite name'
+        }
+      }
+    }
+  }
+};
+
+var createProject = {
+  bean: 'create.project',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Project',
+    usage: 'vona :create:project projectName [--template=] [--force]'
+  },
+  options: {
+    template: {
+      description: 'template',
+      type: 'string'
+    },
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        template: {
+          type: 'select',
+          message: 'Specify the project template',
+          choices: [{
+            name: 'basic',
+            message: 'basic'
+          }]
+        }
+      }
+    },
+    moduleInfo: {
+      questions: {
+        name: {
+          type: 'input',
+          message: 'project name',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var createSuite = {
+  bean: 'create.suite',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Suite',
+    usage: 'vona :create:suite suiteName'
+  },
+  options: {},
+  groups: {
+    suiteInfo: {
+      questions: {
+        name: {
+          type: 'input',
+          message: 'suite name',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var createTest = {
+  bean: 'create.test',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Test',
+    usage: 'vona :create:test name [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        name: {
+          type: 'input',
+          message: 'name',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var defaultList = {
+  bean: 'default.list',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Command List'
+  },
+  options: {
+    module: {
+      description: 'module',
+      type: 'string'
+    },
+    group: {
+      description: 'group',
+      type: 'string'
+    }
+  },
+  groups: null
+};
+
+var initAppMonkey = {
+  bean: 'init.appMonkey',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: App Monkey',
+    usage: 'vona :init:appMonkey'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initAsset = {
+  bean: 'init.asset',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Asset Resources',
+    usage: 'vona :init:asset scene [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        scene: {
+          type: 'input',
+          message: 'scene',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var initConfig = {
+  bean: 'init.config',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Config',
+    usage: 'vona :init:config module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initConstant = {
+  bean: 'init.constant',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Constant',
+    usage: 'vona :init:constant module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initError = {
+  bean: 'init.error',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Error',
+    usage: 'vona :init:error module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initLib = {
+  bean: 'init.lib',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Lib',
+    usage: 'vona :init:lib module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initLocale = {
+  bean: 'init.locale',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Locale',
+    usage: 'vona :init:locale module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMain = {
+  bean: 'init.main',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Main',
+    usage: 'vona :init:main module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMonkey = {
+  bean: 'init.monkey',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Monkey',
+    usage: 'vona :init:monkey module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initStatic = {
+  bean: 'init.static',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Static Resources',
+    usage: 'vona :init:static module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initTypes = {
+  bean: 'init.types',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Types',
+    usage: 'vona :init:types module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var toolsCrud = {
+  bean: 'tools.crud',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Crud',
+    usage: 'vona :tools:crud resourceName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        resourceName: {
+          type: 'input',
+          message: 'resourceName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var toolsDeps = {
+  bean: 'tools.deps',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Deps',
+    usage: 'vona :tools:deps'
+  },
+  options: {}
+};
+
+var toolsMetadata = {
+  bean: 'tools.metadata',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Metadata',
+    usage: 'vona :tools:metadata module1 [module2] [--force]'
+  },
+  options: {
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  }
+};
+
+const commands = {
+  default: {
+    list: defaultList
+  },
+  bin: {
+    build: binBuild,
+    buildModule: binBuildModule,
+    buildGeneral: binBuildGeneral,
+    dbReset: binDbReset,
+    dev: binDev,
+    play: binPlay,
+    test: binTest,
+    tsc: binTsc
+  },
+  create: {
+    suite: createSuite,
+    module: createModule,
+    project: createProject,
+    bean: createBean,
+    test: createTest
+  },
+  init: {
+    config: initConfig,
+    locale: initLocale,
+    constant: initConstant,
+    error: initError,
+    monkey: initMonkey,
+    main: initMain,
+    static: initStatic,
+    asset: initAsset,
+    lib: initLib,
+    types: initTypes,
+    appMonkey: initAppMonkey
+  },
+  refactor: {},
+  tools: {
+    deps: toolsDeps,
+    metadata: toolsMetadata,
+    crud: toolsCrud
+  }
+};
+
+export { beans, commands, copyTemplateFile, copyTemplateIfNeed, generateConfigDefine, getAbsolutePathOfModule, getEnvMeta, getImportEsm, getNodeEnv, getOutDir, getOutReleasesDir, loadJSONFile, pathToHref, requireModule, resolveTemplatePath, saveJSONFile };